1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2014 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #include "bfd_stdint.h"
32 #include "libiberty.h"
34 #include "elf/x86-64.h"
41 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
42 #define MINUS_ONE (~ (bfd_vma) 0)
44 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
45 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
46 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
47 since they are the same. */
49 #define ABI_64_P(abfd) \
50 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
52 /* The relocation "howto" table. Order of fields:
53 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
54 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
55 static reloc_howto_type x86_64_elf_howto_table
[] =
57 HOWTO(R_X86_64_NONE
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
58 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
60 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
61 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
63 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
64 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
66 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
67 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
69 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
70 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
72 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
73 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
75 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
76 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
78 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
79 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
81 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
82 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
84 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
85 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
87 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
88 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
90 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
91 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
93 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
94 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
95 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
96 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
97 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
98 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
99 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
100 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
101 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
102 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
104 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
105 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
107 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
108 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
110 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
111 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
113 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
114 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
116 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
117 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
119 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
120 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
122 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
123 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
125 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
126 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
128 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
129 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
130 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
131 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
132 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
133 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
134 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
135 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
137 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
138 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
140 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
141 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
142 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
143 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
144 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
146 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
147 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
149 HOWTO(R_X86_64_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
150 bfd_elf_generic_reloc
, "R_X86_64_SIZE32", FALSE
, 0xffffffff, 0xffffffff,
152 HOWTO(R_X86_64_SIZE64
, 0, 4, 64, FALSE
, 0, complain_overflow_unsigned
,
153 bfd_elf_generic_reloc
, "R_X86_64_SIZE64", FALSE
, MINUS_ONE
, MINUS_ONE
,
155 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
156 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
157 "R_X86_64_GOTPC32_TLSDESC",
158 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
159 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
160 complain_overflow_dont
, bfd_elf_generic_reloc
,
161 "R_X86_64_TLSDESC_CALL",
163 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
164 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
166 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
167 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
168 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
170 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
171 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
173 HOWTO(R_X86_64_PC32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
174 bfd_elf_generic_reloc
, "R_X86_64_PC32_BND", FALSE
, 0xffffffff, 0xffffffff,
176 HOWTO(R_X86_64_PLT32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
177 bfd_elf_generic_reloc
, "R_X86_64_PLT32_BND", FALSE
, 0xffffffff, 0xffffffff,
180 /* We have a gap in the reloc numbers here.
181 R_X86_64_standard counts the number up to this point, and
182 R_X86_64_vt_offset is the value to subtract from a reloc type of
183 R_X86_64_GNU_VT* to form an index into this table. */
184 #define R_X86_64_standard (R_X86_64_PLT32_BND + 1)
185 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
187 /* GNU extension to record C++ vtable hierarchy. */
188 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
189 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
191 /* GNU extension to record C++ vtable member usage. */
192 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
193 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
196 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
197 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
198 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
202 #define IS_X86_64_PCREL_TYPE(TYPE) \
203 ( ((TYPE) == R_X86_64_PC8) \
204 || ((TYPE) == R_X86_64_PC16) \
205 || ((TYPE) == R_X86_64_PC32) \
206 || ((TYPE) == R_X86_64_PC32_BND) \
207 || ((TYPE) == R_X86_64_PC64))
209 /* Map BFD relocs to the x86_64 elf relocs. */
212 bfd_reloc_code_real_type bfd_reloc_val
;
213 unsigned char elf_reloc_val
;
216 static const struct elf_reloc_map x86_64_reloc_map
[] =
218 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
219 { BFD_RELOC_64
, R_X86_64_64
, },
220 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
221 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
222 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
223 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
224 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
225 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
226 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
227 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
228 { BFD_RELOC_32
, R_X86_64_32
, },
229 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
230 { BFD_RELOC_16
, R_X86_64_16
, },
231 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
232 { BFD_RELOC_8
, R_X86_64_8
, },
233 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
234 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
235 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
236 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
237 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
238 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
239 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
240 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
241 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
242 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
243 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
244 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
245 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
246 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
247 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
248 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
249 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
250 { BFD_RELOC_SIZE32
, R_X86_64_SIZE32
, },
251 { BFD_RELOC_SIZE64
, R_X86_64_SIZE64
, },
252 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
253 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
254 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
255 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
256 { BFD_RELOC_X86_64_PC32_BND
, R_X86_64_PC32_BND
,},
257 { BFD_RELOC_X86_64_PLT32_BND
, R_X86_64_PLT32_BND
,},
258 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
259 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
262 static reloc_howto_type
*
263 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
267 if (r_type
== (unsigned int) R_X86_64_32
)
272 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
274 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
275 || r_type
>= (unsigned int) R_X86_64_max
)
277 if (r_type
>= (unsigned int) R_X86_64_standard
)
279 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
281 r_type
= R_X86_64_NONE
;
286 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
287 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
288 return &x86_64_elf_howto_table
[i
];
291 /* Given a BFD reloc type, return a HOWTO structure. */
292 static reloc_howto_type
*
293 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
294 bfd_reloc_code_real_type code
)
298 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
301 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
302 return elf_x86_64_rtype_to_howto (abfd
,
303 x86_64_reloc_map
[i
].elf_reloc_val
);
308 static reloc_howto_type
*
309 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
314 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
316 /* Get x32 R_X86_64_32. */
317 reloc_howto_type
*reloc
318 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
319 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
323 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
324 if (x86_64_elf_howto_table
[i
].name
!= NULL
325 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
326 return &x86_64_elf_howto_table
[i
];
331 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
334 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
335 Elf_Internal_Rela
*dst
)
339 r_type
= ELF32_R_TYPE (dst
->r_info
);
340 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
341 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
344 /* Support for core dump NOTE sections. */
346 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
351 switch (note
->descsz
)
356 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
358 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
361 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
369 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
371 elf_tdata (abfd
)->core
->signal
372 = bfd_get_16 (abfd
, note
->descdata
+ 12);
375 elf_tdata (abfd
)->core
->lwpid
376 = bfd_get_32 (abfd
, note
->descdata
+ 32);
385 /* Make a ".reg/999" section. */
386 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
387 size
, note
->descpos
+ offset
);
391 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
393 switch (note
->descsz
)
398 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
399 elf_tdata (abfd
)->core
->pid
400 = bfd_get_32 (abfd
, note
->descdata
+ 12);
401 elf_tdata (abfd
)->core
->program
402 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
403 elf_tdata (abfd
)->core
->command
404 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
407 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
408 elf_tdata (abfd
)->core
->pid
409 = bfd_get_32 (abfd
, note
->descdata
+ 24);
410 elf_tdata (abfd
)->core
->program
411 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
412 elf_tdata (abfd
)->core
->command
413 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
416 /* Note that for some reason, a spurious space is tacked
417 onto the end of the args in some (at least one anyway)
418 implementations, so strip it off if it exists. */
421 char *command
= elf_tdata (abfd
)->core
->command
;
422 int n
= strlen (command
);
424 if (0 < n
&& command
[n
- 1] == ' ')
425 command
[n
- 1] = '\0';
433 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
436 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
438 const char *fname
, *psargs
;
449 va_start (ap
, note_type
);
450 fname
= va_arg (ap
, const char *);
451 psargs
= va_arg (ap
, const char *);
454 if (bed
->s
->elfclass
== ELFCLASS32
)
457 memset (&data
, 0, sizeof (data
));
458 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
459 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
460 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
461 &data
, sizeof (data
));
466 memset (&data
, 0, sizeof (data
));
467 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
468 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
469 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
470 &data
, sizeof (data
));
475 va_start (ap
, note_type
);
476 pid
= va_arg (ap
, long);
477 cursig
= va_arg (ap
, int);
478 gregs
= va_arg (ap
, const void *);
481 if (bed
->s
->elfclass
== ELFCLASS32
)
483 if (bed
->elf_machine_code
== EM_X86_64
)
485 prstatusx32_t prstat
;
486 memset (&prstat
, 0, sizeof (prstat
));
488 prstat
.pr_cursig
= cursig
;
489 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
490 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
491 &prstat
, sizeof (prstat
));
496 memset (&prstat
, 0, sizeof (prstat
));
498 prstat
.pr_cursig
= cursig
;
499 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
500 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
501 &prstat
, sizeof (prstat
));
507 memset (&prstat
, 0, sizeof (prstat
));
509 prstat
.pr_cursig
= cursig
;
510 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
511 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
512 &prstat
, sizeof (prstat
));
519 /* Functions for the x86-64 ELF linker. */
521 /* The name of the dynamic interpreter. This is put in the .interp
524 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
525 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
527 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
528 copying dynamic variables from a shared lib into an app's dynbss
529 section, and instead use a dynamic relocation to point into the
531 #define ELIMINATE_COPY_RELOCS 1
533 /* The size in bytes of an entry in the global offset table. */
535 #define GOT_ENTRY_SIZE 8
537 /* The size in bytes of an entry in the procedure linkage table. */
539 #define PLT_ENTRY_SIZE 16
541 /* The first entry in a procedure linkage table looks like this. See the
542 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
544 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
546 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
547 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
548 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
551 /* Subsequent entries in a procedure linkage table look like this. */
553 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
555 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
556 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
557 0x68, /* pushq immediate */
558 0, 0, 0, 0, /* replaced with index into relocation table. */
559 0xe9, /* jmp relative */
560 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
563 /* The first entry in a procedure linkage table with BND relocations
566 static const bfd_byte elf_x86_64_bnd_plt0_entry
[PLT_ENTRY_SIZE
] =
568 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
569 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
570 0x0f, 0x1f, 0 /* nopl (%rax) */
573 /* Subsequent entries for legacy branches in a procedure linkage table
574 with BND relocations look like this. */
576 static const bfd_byte elf_x86_64_legacy_plt_entry
[PLT_ENTRY_SIZE
] =
578 0x68, 0, 0, 0, 0, /* pushq immediate */
579 0xe9, 0, 0, 0, 0, /* jmpq relative */
580 0x66, 0x0f, 0x1f, 0x44, 0, 0 /* nopw (%rax,%rax,1) */
583 /* Subsequent entries for branches with BND prefx in a procedure linkage
584 table with BND relocations look like this. */
586 static const bfd_byte elf_x86_64_bnd_plt_entry
[PLT_ENTRY_SIZE
] =
588 0x68, 0, 0, 0, 0, /* pushq immediate */
589 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
590 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
593 /* Entries for legacy branches in the second procedure linkage table
596 static const bfd_byte elf_x86_64_legacy_plt2_entry
[8] =
598 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
599 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
600 0x66, 0x90 /* xchg %ax,%ax */
603 /* Entries for branches with BND prefix in the second procedure linkage
604 table look like this. */
606 static const bfd_byte elf_x86_64_bnd_plt2_entry
[8] =
608 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
609 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
613 /* .eh_frame covering the .plt section. */
615 static const bfd_byte elf_x86_64_eh_frame_plt
[] =
617 #define PLT_CIE_LENGTH 20
618 #define PLT_FDE_LENGTH 36
619 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
620 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
621 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
622 0, 0, 0, 0, /* CIE ID */
624 'z', 'R', 0, /* Augmentation string */
625 1, /* Code alignment factor */
626 0x78, /* Data alignment factor */
627 16, /* Return address column */
628 1, /* Augmentation size */
629 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
630 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
631 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
632 DW_CFA_nop
, DW_CFA_nop
,
634 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
635 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
636 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
637 0, 0, 0, 0, /* .plt size goes here */
638 0, /* Augmentation size */
639 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
640 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
641 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
642 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
643 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
644 11, /* Block length */
645 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
646 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
647 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
648 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
649 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
652 /* Architecture-specific backend data for x86-64. */
654 struct elf_x86_64_backend_data
656 /* Templates for the initial PLT entry and for subsequent entries. */
657 const bfd_byte
*plt0_entry
;
658 const bfd_byte
*plt_entry
;
659 unsigned int plt_entry_size
; /* Size of each PLT entry. */
661 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
662 unsigned int plt0_got1_offset
;
663 unsigned int plt0_got2_offset
;
665 /* Offset of the end of the PC-relative instruction containing
667 unsigned int plt0_got2_insn_end
;
669 /* Offsets into plt_entry that are to be replaced with... */
670 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
671 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
672 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
674 /* Length of the PC-relative instruction containing plt_got_offset. */
675 unsigned int plt_got_insn_size
;
677 /* Offset of the end of the PC-relative jump to plt0_entry. */
678 unsigned int plt_plt_insn_end
;
680 /* Offset into plt_entry where the initial value of the GOT entry points. */
681 unsigned int plt_lazy_offset
;
683 /* .eh_frame covering the .plt section. */
684 const bfd_byte
*eh_frame_plt
;
685 unsigned int eh_frame_plt_size
;
688 #define get_elf_x86_64_arch_data(bed) \
689 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
691 #define get_elf_x86_64_backend_data(abfd) \
692 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
694 #define GET_PLT_ENTRY_SIZE(abfd) \
695 get_elf_x86_64_backend_data (abfd)->plt_entry_size
697 /* These are the standard parameters. */
698 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
700 elf_x86_64_plt0_entry
, /* plt0_entry */
701 elf_x86_64_plt_entry
, /* plt_entry */
702 sizeof (elf_x86_64_plt_entry
), /* plt_entry_size */
703 2, /* plt0_got1_offset */
704 8, /* plt0_got2_offset */
705 12, /* plt0_got2_insn_end */
706 2, /* plt_got_offset */
707 7, /* plt_reloc_offset */
708 12, /* plt_plt_offset */
709 6, /* plt_got_insn_size */
710 PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
711 6, /* plt_lazy_offset */
712 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
713 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
716 static const struct elf_x86_64_backend_data elf_x86_64_bnd_arch_bed
=
718 elf_x86_64_bnd_plt0_entry
, /* plt0_entry */
719 elf_x86_64_bnd_plt_entry
, /* plt_entry */
720 sizeof (elf_x86_64_bnd_plt_entry
), /* plt_entry_size */
721 2, /* plt0_got1_offset */
722 1+8, /* plt0_got2_offset */
723 1+12, /* plt0_got2_insn_end */
724 1+2, /* plt_got_offset */
725 1, /* plt_reloc_offset */
726 7, /* plt_plt_offset */
727 1+6, /* plt_got_insn_size */
728 11, /* plt_plt_insn_end */
729 0, /* plt_lazy_offset */
730 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
731 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
734 #define elf_backend_arch_data &elf_x86_64_arch_bed
736 /* x86-64 ELF linker hash entry. */
738 struct elf_x86_64_link_hash_entry
740 struct elf_link_hash_entry elf
;
742 /* Track dynamic relocs copied for this symbol. */
743 struct elf_dyn_relocs
*dyn_relocs
;
745 #define GOT_UNKNOWN 0
749 #define GOT_TLS_GDESC 4
750 #define GOT_TLS_GD_BOTH_P(type) \
751 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
752 #define GOT_TLS_GD_P(type) \
753 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
754 #define GOT_TLS_GDESC_P(type) \
755 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
756 #define GOT_TLS_GD_ANY_P(type) \
757 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
758 unsigned char tls_type
;
760 /* TRUE if symbol has at least one BND relocation. */
761 bfd_boolean has_bnd_reloc
;
763 /* Information about the second PLT entry. Filled when has_bnd_reloc is
765 union gotplt_union plt_bnd
;
767 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
768 starting at the end of the jump table. */
772 #define elf_x86_64_hash_entry(ent) \
773 ((struct elf_x86_64_link_hash_entry *)(ent))
775 struct elf_x86_64_obj_tdata
777 struct elf_obj_tdata root
;
779 /* tls_type for each local got entry. */
780 char *local_got_tls_type
;
782 /* GOTPLT entries for TLS descriptors. */
783 bfd_vma
*local_tlsdesc_gotent
;
786 #define elf_x86_64_tdata(abfd) \
787 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
789 #define elf_x86_64_local_got_tls_type(abfd) \
790 (elf_x86_64_tdata (abfd)->local_got_tls_type)
792 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
793 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
795 #define is_x86_64_elf(bfd) \
796 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
797 && elf_tdata (bfd) != NULL \
798 && elf_object_id (bfd) == X86_64_ELF_DATA)
801 elf_x86_64_mkobject (bfd
*abfd
)
803 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
807 /* x86-64 ELF linker hash table. */
809 struct elf_x86_64_link_hash_table
811 struct elf_link_hash_table elf
;
813 /* Short-cuts to get to dynamic linker sections. */
816 asection
*plt_eh_frame
;
821 bfd_signed_vma refcount
;
825 /* The amount of space used by the jump slots in the GOT. */
826 bfd_vma sgotplt_jump_table_size
;
828 /* Small local sym cache. */
829 struct sym_cache sym_cache
;
831 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
832 bfd_vma (*r_sym
) (bfd_vma
);
833 unsigned int pointer_r_type
;
834 const char *dynamic_interpreter
;
835 int dynamic_interpreter_size
;
837 /* _TLS_MODULE_BASE_ symbol. */
838 struct bfd_link_hash_entry
*tls_module_base
;
840 /* Used by local STT_GNU_IFUNC symbols. */
841 htab_t loc_hash_table
;
842 void * loc_hash_memory
;
844 /* The offset into splt of the PLT entry for the TLS descriptor
845 resolver. Special values are 0, if not necessary (or not found
846 to be necessary yet), and -1 if needed but not determined
849 /* The offset into sgot of the GOT entry used by the PLT entry
853 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
854 bfd_vma next_jump_slot_index
;
855 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
856 bfd_vma next_irelative_index
;
859 /* Get the x86-64 ELF linker hash table from a link_info structure. */
861 #define elf_x86_64_hash_table(p) \
862 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
863 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
865 #define elf_x86_64_compute_jump_table_size(htab) \
866 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
868 /* Create an entry in an x86-64 ELF linker hash table. */
870 static struct bfd_hash_entry
*
871 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
872 struct bfd_hash_table
*table
,
875 /* Allocate the structure if it has not already been allocated by a
879 entry
= (struct bfd_hash_entry
*)
880 bfd_hash_allocate (table
,
881 sizeof (struct elf_x86_64_link_hash_entry
));
886 /* Call the allocation method of the superclass. */
887 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
890 struct elf_x86_64_link_hash_entry
*eh
;
892 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
893 eh
->dyn_relocs
= NULL
;
894 eh
->tls_type
= GOT_UNKNOWN
;
895 eh
->has_bnd_reloc
= FALSE
;
896 eh
->plt_bnd
.offset
= (bfd_vma
) -1;
897 eh
->tlsdesc_got
= (bfd_vma
) -1;
903 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
904 for local symbol so that we can handle local STT_GNU_IFUNC symbols
905 as global symbol. We reuse indx and dynstr_index for local symbol
906 hash since they aren't used by global symbols in this backend. */
909 elf_x86_64_local_htab_hash (const void *ptr
)
911 struct elf_link_hash_entry
*h
912 = (struct elf_link_hash_entry
*) ptr
;
913 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
916 /* Compare local hash entries. */
919 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
921 struct elf_link_hash_entry
*h1
922 = (struct elf_link_hash_entry
*) ptr1
;
923 struct elf_link_hash_entry
*h2
924 = (struct elf_link_hash_entry
*) ptr2
;
926 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
929 /* Find and/or create a hash entry for local symbol. */
931 static struct elf_link_hash_entry
*
932 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
933 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
936 struct elf_x86_64_link_hash_entry e
, *ret
;
937 asection
*sec
= abfd
->sections
;
938 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
939 htab
->r_sym (rel
->r_info
));
942 e
.elf
.indx
= sec
->id
;
943 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
944 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
945 create
? INSERT
: NO_INSERT
);
952 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
956 ret
= (struct elf_x86_64_link_hash_entry
*)
957 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
958 sizeof (struct elf_x86_64_link_hash_entry
));
961 memset (ret
, 0, sizeof (*ret
));
962 ret
->elf
.indx
= sec
->id
;
963 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
964 ret
->elf
.dynindx
= -1;
970 /* Destroy an X86-64 ELF linker hash table. */
973 elf_x86_64_link_hash_table_free (bfd
*obfd
)
975 struct elf_x86_64_link_hash_table
*htab
976 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
978 if (htab
->loc_hash_table
)
979 htab_delete (htab
->loc_hash_table
);
980 if (htab
->loc_hash_memory
)
981 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
982 _bfd_elf_link_hash_table_free (obfd
);
985 /* Create an X86-64 ELF linker hash table. */
987 static struct bfd_link_hash_table
*
988 elf_x86_64_link_hash_table_create (bfd
*abfd
)
990 struct elf_x86_64_link_hash_table
*ret
;
991 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
993 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
997 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
998 elf_x86_64_link_hash_newfunc
,
999 sizeof (struct elf_x86_64_link_hash_entry
),
1006 if (ABI_64_P (abfd
))
1008 ret
->r_info
= elf64_r_info
;
1009 ret
->r_sym
= elf64_r_sym
;
1010 ret
->pointer_r_type
= R_X86_64_64
;
1011 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1012 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1016 ret
->r_info
= elf32_r_info
;
1017 ret
->r_sym
= elf32_r_sym
;
1018 ret
->pointer_r_type
= R_X86_64_32
;
1019 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1020 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1023 ret
->loc_hash_table
= htab_try_create (1024,
1024 elf_x86_64_local_htab_hash
,
1025 elf_x86_64_local_htab_eq
,
1027 ret
->loc_hash_memory
= objalloc_create ();
1028 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1030 elf_x86_64_link_hash_table_free (abfd
);
1033 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1035 return &ret
->elf
.root
;
1038 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1039 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1043 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
1044 struct bfd_link_info
*info
)
1046 struct elf_x86_64_link_hash_table
*htab
;
1048 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1051 htab
= elf_x86_64_hash_table (info
);
1055 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1057 htab
->srelbss
= bfd_get_linker_section (dynobj
, ".rela.bss");
1060 || (!info
->shared
&& !htab
->srelbss
))
1063 if (!info
->no_ld_generated_unwind_info
1064 && htab
->plt_eh_frame
== NULL
1065 && htab
->elf
.splt
!= NULL
)
1067 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1068 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1069 | SEC_LINKER_CREATED
);
1071 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1072 if (htab
->plt_eh_frame
== NULL
1073 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1079 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1082 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1083 struct elf_link_hash_entry
*dir
,
1084 struct elf_link_hash_entry
*ind
)
1086 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1088 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1089 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1091 if (!edir
->has_bnd_reloc
)
1092 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1094 if (eind
->dyn_relocs
!= NULL
)
1096 if (edir
->dyn_relocs
!= NULL
)
1098 struct elf_dyn_relocs
**pp
;
1099 struct elf_dyn_relocs
*p
;
1101 /* Add reloc counts against the indirect sym to the direct sym
1102 list. Merge any entries against the same section. */
1103 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1105 struct elf_dyn_relocs
*q
;
1107 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1108 if (q
->sec
== p
->sec
)
1110 q
->pc_count
+= p
->pc_count
;
1111 q
->count
+= p
->count
;
1118 *pp
= edir
->dyn_relocs
;
1121 edir
->dyn_relocs
= eind
->dyn_relocs
;
1122 eind
->dyn_relocs
= NULL
;
1125 if (ind
->root
.type
== bfd_link_hash_indirect
1126 && dir
->got
.refcount
<= 0)
1128 edir
->tls_type
= eind
->tls_type
;
1129 eind
->tls_type
= GOT_UNKNOWN
;
1132 if (ELIMINATE_COPY_RELOCS
1133 && ind
->root
.type
!= bfd_link_hash_indirect
1134 && dir
->dynamic_adjusted
)
1136 /* If called to transfer flags for a weakdef during processing
1137 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1138 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1139 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1140 dir
->ref_regular
|= ind
->ref_regular
;
1141 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1142 dir
->needs_plt
|= ind
->needs_plt
;
1143 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1146 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1150 elf64_x86_64_elf_object_p (bfd
*abfd
)
1152 /* Set the right machine number for an x86-64 elf64 file. */
1153 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1158 elf32_x86_64_elf_object_p (bfd
*abfd
)
1160 /* Set the right machine number for an x86-64 elf32 file. */
1161 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1165 /* Return TRUE if the TLS access code sequence support transition
1169 elf_x86_64_check_tls_transition (bfd
*abfd
,
1170 struct bfd_link_info
*info
,
1173 Elf_Internal_Shdr
*symtab_hdr
,
1174 struct elf_link_hash_entry
**sym_hashes
,
1175 unsigned int r_type
,
1176 const Elf_Internal_Rela
*rel
,
1177 const Elf_Internal_Rela
*relend
)
1180 unsigned long r_symndx
;
1181 bfd_boolean largepic
= FALSE
;
1182 struct elf_link_hash_entry
*h
;
1184 struct elf_x86_64_link_hash_table
*htab
;
1186 /* Get the section contents. */
1187 if (contents
== NULL
)
1189 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1190 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1193 /* FIXME: How to better handle error condition? */
1194 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1197 /* Cache the section contents for elf_link_input_bfd. */
1198 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1202 htab
= elf_x86_64_hash_table (info
);
1203 offset
= rel
->r_offset
;
1206 case R_X86_64_TLSGD
:
1207 case R_X86_64_TLSLD
:
1208 if ((rel
+ 1) >= relend
)
1211 if (r_type
== R_X86_64_TLSGD
)
1213 /* Check transition from GD access model. For 64bit, only
1214 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1215 .word 0x6666; rex64; call __tls_get_addr
1216 can transit to different access model. For 32bit, only
1217 leaq foo@tlsgd(%rip), %rdi
1218 .word 0x6666; rex64; call __tls_get_addr
1219 can transit to different access model. For largepic
1221 leaq foo@tlsgd(%rip), %rdi
1222 movabsq $__tls_get_addr@pltoff, %rax
1226 static const unsigned char call
[] = { 0x66, 0x66, 0x48, 0xe8 };
1227 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1229 if ((offset
+ 12) > sec
->size
)
1232 if (memcmp (contents
+ offset
+ 4, call
, 4) != 0)
1234 if (!ABI_64_P (abfd
)
1235 || (offset
+ 19) > sec
->size
1237 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0
1238 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1239 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1244 else if (ABI_64_P (abfd
))
1247 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1253 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1259 /* Check transition from LD access model. Only
1260 leaq foo@tlsld(%rip), %rdi;
1262 can transit to different access model. For largepic
1264 leaq foo@tlsld(%rip), %rdi
1265 movabsq $__tls_get_addr@pltoff, %rax
1269 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1271 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1274 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1277 if (0xe8 != *(contents
+ offset
+ 4))
1279 if (!ABI_64_P (abfd
)
1280 || (offset
+ 19) > sec
->size
1281 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1282 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1289 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1290 if (r_symndx
< symtab_hdr
->sh_info
)
1293 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1294 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1295 may be versioned. */
1297 && h
->root
.root
.string
!= NULL
1299 ? ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
1300 : (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1301 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
))
1302 && (strncmp (h
->root
.root
.string
,
1303 "__tls_get_addr", 14) == 0));
1305 case R_X86_64_GOTTPOFF
:
1306 /* Check transition from IE access model:
1307 mov foo@gottpoff(%rip), %reg
1308 add foo@gottpoff(%rip), %reg
1311 /* Check REX prefix first. */
1312 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1314 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1315 if (val
!= 0x48 && val
!= 0x4c)
1317 /* X32 may have 0x44 REX prefix or no REX prefix. */
1318 if (ABI_64_P (abfd
))
1324 /* X32 may not have any REX prefix. */
1325 if (ABI_64_P (abfd
))
1327 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1331 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1332 if (val
!= 0x8b && val
!= 0x03)
1335 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1336 return (val
& 0xc7) == 5;
1338 case R_X86_64_GOTPC32_TLSDESC
:
1339 /* Check transition from GDesc access model:
1340 leaq x@tlsdesc(%rip), %rax
1342 Make sure it's a leaq adding rip to a 32-bit offset
1343 into any register, although it's probably almost always
1346 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1349 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1350 if ((val
& 0xfb) != 0x48)
1353 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1356 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1357 return (val
& 0xc7) == 0x05;
1359 case R_X86_64_TLSDESC_CALL
:
1360 /* Check transition from GDesc access model:
1361 call *x@tlsdesc(%rax)
1363 if (offset
+ 2 <= sec
->size
)
1365 /* Make sure that it's a call *x@tlsdesc(%rax). */
1366 static const unsigned char call
[] = { 0xff, 0x10 };
1367 return memcmp (contents
+ offset
, call
, 2) == 0;
1377 /* Return TRUE if the TLS access transition is OK or no transition
1378 will be performed. Update R_TYPE if there is a transition. */
1381 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1382 asection
*sec
, bfd_byte
*contents
,
1383 Elf_Internal_Shdr
*symtab_hdr
,
1384 struct elf_link_hash_entry
**sym_hashes
,
1385 unsigned int *r_type
, int tls_type
,
1386 const Elf_Internal_Rela
*rel
,
1387 const Elf_Internal_Rela
*relend
,
1388 struct elf_link_hash_entry
*h
,
1389 unsigned long r_symndx
)
1391 unsigned int from_type
= *r_type
;
1392 unsigned int to_type
= from_type
;
1393 bfd_boolean check
= TRUE
;
1395 /* Skip TLS transition for functions. */
1397 && (h
->type
== STT_FUNC
1398 || h
->type
== STT_GNU_IFUNC
))
1403 case R_X86_64_TLSGD
:
1404 case R_X86_64_GOTPC32_TLSDESC
:
1405 case R_X86_64_TLSDESC_CALL
:
1406 case R_X86_64_GOTTPOFF
:
1407 if (info
->executable
)
1410 to_type
= R_X86_64_TPOFF32
;
1412 to_type
= R_X86_64_GOTTPOFF
;
1415 /* When we are called from elf_x86_64_relocate_section,
1416 CONTENTS isn't NULL and there may be additional transitions
1417 based on TLS_TYPE. */
1418 if (contents
!= NULL
)
1420 unsigned int new_to_type
= to_type
;
1422 if (info
->executable
1425 && tls_type
== GOT_TLS_IE
)
1426 new_to_type
= R_X86_64_TPOFF32
;
1428 if (to_type
== R_X86_64_TLSGD
1429 || to_type
== R_X86_64_GOTPC32_TLSDESC
1430 || to_type
== R_X86_64_TLSDESC_CALL
)
1432 if (tls_type
== GOT_TLS_IE
)
1433 new_to_type
= R_X86_64_GOTTPOFF
;
1436 /* We checked the transition before when we were called from
1437 elf_x86_64_check_relocs. We only want to check the new
1438 transition which hasn't been checked before. */
1439 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1440 to_type
= new_to_type
;
1445 case R_X86_64_TLSLD
:
1446 if (info
->executable
)
1447 to_type
= R_X86_64_TPOFF32
;
1454 /* Return TRUE if there is no transition. */
1455 if (from_type
== to_type
)
1458 /* Check if the transition can be performed. */
1460 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1461 symtab_hdr
, sym_hashes
,
1462 from_type
, rel
, relend
))
1464 reloc_howto_type
*from
, *to
;
1467 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1468 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1471 name
= h
->root
.root
.string
;
1474 struct elf_x86_64_link_hash_table
*htab
;
1476 htab
= elf_x86_64_hash_table (info
);
1481 Elf_Internal_Sym
*isym
;
1483 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1485 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1489 (*_bfd_error_handler
)
1490 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1491 "in section `%A' failed"),
1492 abfd
, sec
, from
->name
, to
->name
, name
,
1493 (unsigned long) rel
->r_offset
);
1494 bfd_set_error (bfd_error_bad_value
);
1502 /* Look through the relocs for a section during the first phase, and
1503 calculate needed space in the global offset table, procedure
1504 linkage table, and dynamic reloc sections. */
1507 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1509 const Elf_Internal_Rela
*relocs
)
1511 struct elf_x86_64_link_hash_table
*htab
;
1512 Elf_Internal_Shdr
*symtab_hdr
;
1513 struct elf_link_hash_entry
**sym_hashes
;
1514 const Elf_Internal_Rela
*rel
;
1515 const Elf_Internal_Rela
*rel_end
;
1518 if (info
->relocatable
)
1521 BFD_ASSERT (is_x86_64_elf (abfd
));
1523 htab
= elf_x86_64_hash_table (info
);
1527 symtab_hdr
= &elf_symtab_hdr (abfd
);
1528 sym_hashes
= elf_sym_hashes (abfd
);
1532 rel_end
= relocs
+ sec
->reloc_count
;
1533 for (rel
= relocs
; rel
< rel_end
; rel
++)
1535 unsigned int r_type
;
1536 unsigned long r_symndx
;
1537 struct elf_link_hash_entry
*h
;
1538 Elf_Internal_Sym
*isym
;
1540 bfd_boolean size_reloc
;
1542 r_symndx
= htab
->r_sym (rel
->r_info
);
1543 r_type
= ELF32_R_TYPE (rel
->r_info
);
1545 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1547 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1552 if (r_symndx
< symtab_hdr
->sh_info
)
1554 /* A local symbol. */
1555 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1560 /* Check relocation against local STT_GNU_IFUNC symbol. */
1561 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1563 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
1568 /* Fake a STT_GNU_IFUNC symbol. */
1569 h
->type
= STT_GNU_IFUNC
;
1572 h
->forced_local
= 1;
1573 h
->root
.type
= bfd_link_hash_defined
;
1581 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1582 while (h
->root
.type
== bfd_link_hash_indirect
1583 || h
->root
.type
== bfd_link_hash_warning
)
1584 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1587 /* Check invalid x32 relocations. */
1588 if (!ABI_64_P (abfd
))
1594 case R_X86_64_DTPOFF64
:
1595 case R_X86_64_TPOFF64
:
1597 case R_X86_64_GOTOFF64
:
1598 case R_X86_64_GOT64
:
1599 case R_X86_64_GOTPCREL64
:
1600 case R_X86_64_GOTPC64
:
1601 case R_X86_64_GOTPLT64
:
1602 case R_X86_64_PLTOFF64
:
1605 name
= h
->root
.root
.string
;
1607 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1609 (*_bfd_error_handler
)
1610 (_("%B: relocation %s against symbol `%s' isn't "
1611 "supported in x32 mode"), abfd
,
1612 x86_64_elf_howto_table
[r_type
].name
, name
);
1613 bfd_set_error (bfd_error_bad_value
);
1621 /* Create the ifunc sections for static executables. If we
1622 never see an indirect function symbol nor we are building
1623 a static executable, those sections will be empty and
1624 won't appear in output. */
1630 case R_X86_64_PC32_BND
:
1631 case R_X86_64_PLT32_BND
:
1633 case R_X86_64_PLT32
:
1636 /* MPX PLT is supported only if elf_x86_64_arch_bed
1637 is used in 64-bit mode. */
1640 && (get_elf_x86_64_backend_data (abfd
)
1641 == &elf_x86_64_arch_bed
))
1643 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= TRUE
;
1645 /* Create the second PLT for Intel MPX support. */
1646 if (htab
->plt_bnd
== NULL
)
1648 unsigned int plt_bnd_align
;
1649 const struct elf_backend_data
*bed
;
1651 bed
= get_elf_backend_data (info
->output_bfd
);
1652 switch (sizeof (elf_x86_64_bnd_plt2_entry
))
1664 if (htab
->elf
.dynobj
== NULL
)
1665 htab
->elf
.dynobj
= abfd
;
1667 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
1669 (bed
->dynamic_sec_flags
1674 if (htab
->plt_bnd
== NULL
1675 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
1684 case R_X86_64_GOTPCREL
:
1685 case R_X86_64_GOTPCREL64
:
1686 if (htab
->elf
.dynobj
== NULL
)
1687 htab
->elf
.dynobj
= abfd
;
1688 if (!_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
1693 /* It is referenced by a non-shared object. */
1695 h
->root
.non_ir_ref
= 1;
1698 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1699 symtab_hdr
, sym_hashes
,
1700 &r_type
, GOT_UNKNOWN
,
1701 rel
, rel_end
, h
, r_symndx
))
1706 case R_X86_64_TLSLD
:
1707 htab
->tls_ld_got
.refcount
+= 1;
1710 case R_X86_64_TPOFF32
:
1711 if (!info
->executable
&& ABI_64_P (abfd
))
1714 name
= h
->root
.root
.string
;
1716 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1718 (*_bfd_error_handler
)
1719 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1721 x86_64_elf_howto_table
[r_type
].name
, name
);
1722 bfd_set_error (bfd_error_bad_value
);
1727 case R_X86_64_GOTTPOFF
:
1728 if (!info
->executable
)
1729 info
->flags
|= DF_STATIC_TLS
;
1732 case R_X86_64_GOT32
:
1733 case R_X86_64_GOTPCREL
:
1734 case R_X86_64_TLSGD
:
1735 case R_X86_64_GOT64
:
1736 case R_X86_64_GOTPCREL64
:
1737 case R_X86_64_GOTPLT64
:
1738 case R_X86_64_GOTPC32_TLSDESC
:
1739 case R_X86_64_TLSDESC_CALL
:
1740 /* This symbol requires a global offset table entry. */
1742 int tls_type
, old_tls_type
;
1746 default: tls_type
= GOT_NORMAL
; break;
1747 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1748 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1749 case R_X86_64_GOTPC32_TLSDESC
:
1750 case R_X86_64_TLSDESC_CALL
:
1751 tls_type
= GOT_TLS_GDESC
; break;
1756 h
->got
.refcount
+= 1;
1757 old_tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
1761 bfd_signed_vma
*local_got_refcounts
;
1763 /* This is a global offset table entry for a local symbol. */
1764 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1765 if (local_got_refcounts
== NULL
)
1769 size
= symtab_hdr
->sh_info
;
1770 size
*= sizeof (bfd_signed_vma
)
1771 + sizeof (bfd_vma
) + sizeof (char);
1772 local_got_refcounts
= ((bfd_signed_vma
*)
1773 bfd_zalloc (abfd
, size
));
1774 if (local_got_refcounts
== NULL
)
1776 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1777 elf_x86_64_local_tlsdesc_gotent (abfd
)
1778 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1779 elf_x86_64_local_got_tls_type (abfd
)
1780 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1782 local_got_refcounts
[r_symndx
] += 1;
1784 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1787 /* If a TLS symbol is accessed using IE at least once,
1788 there is no point to use dynamic model for it. */
1789 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1790 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1791 || tls_type
!= GOT_TLS_IE
))
1793 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1794 tls_type
= old_tls_type
;
1795 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1796 && GOT_TLS_GD_ANY_P (tls_type
))
1797 tls_type
|= old_tls_type
;
1801 name
= h
->root
.root
.string
;
1803 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1805 (*_bfd_error_handler
)
1806 (_("%B: '%s' accessed both as normal and thread local symbol"),
1808 bfd_set_error (bfd_error_bad_value
);
1813 if (old_tls_type
!= tls_type
)
1816 elf_x86_64_hash_entry (h
)->tls_type
= tls_type
;
1818 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1823 case R_X86_64_GOTOFF64
:
1824 case R_X86_64_GOTPC32
:
1825 case R_X86_64_GOTPC64
:
1827 if (htab
->elf
.sgot
== NULL
)
1829 if (htab
->elf
.dynobj
== NULL
)
1830 htab
->elf
.dynobj
= abfd
;
1831 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1837 case R_X86_64_PLT32
:
1838 case R_X86_64_PLT32_BND
:
1839 /* This symbol requires a procedure linkage table entry. We
1840 actually build the entry in adjust_dynamic_symbol,
1841 because this might be a case of linking PIC code which is
1842 never referenced by a dynamic object, in which case we
1843 don't need to generate a procedure linkage table entry
1846 /* If this is a local symbol, we resolve it directly without
1847 creating a procedure linkage table entry. */
1852 h
->plt
.refcount
+= 1;
1855 case R_X86_64_PLTOFF64
:
1856 /* This tries to form the 'address' of a function relative
1857 to GOT. For global symbols we need a PLT entry. */
1861 h
->plt
.refcount
+= 1;
1865 case R_X86_64_SIZE32
:
1866 case R_X86_64_SIZE64
:
1871 if (!ABI_64_P (abfd
))
1876 /* Let's help debug shared library creation. These relocs
1877 cannot be used in shared libs. Don't error out for
1878 sections we don't care about, such as debug sections or
1879 non-constant sections. */
1881 && (sec
->flags
& SEC_ALLOC
) != 0
1882 && (sec
->flags
& SEC_READONLY
) != 0)
1885 name
= h
->root
.root
.string
;
1887 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1888 (*_bfd_error_handler
)
1889 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1890 abfd
, x86_64_elf_howto_table
[r_type
].name
, name
);
1891 bfd_set_error (bfd_error_bad_value
);
1899 case R_X86_64_PC32_BND
:
1903 if (h
!= NULL
&& info
->executable
)
1905 /* If this reloc is in a read-only section, we might
1906 need a copy reloc. We can't check reliably at this
1907 stage whether the section is read-only, as input
1908 sections have not yet been mapped to output sections.
1909 Tentatively set the flag for now, and correct in
1910 adjust_dynamic_symbol. */
1913 /* We may need a .plt entry if the function this reloc
1914 refers to is in a shared lib. */
1915 h
->plt
.refcount
+= 1;
1916 if (r_type
!= R_X86_64_PC32
1917 && r_type
!= R_X86_64_PC32_BND
1918 && r_type
!= R_X86_64_PC64
)
1919 h
->pointer_equality_needed
= 1;
1924 /* If we are creating a shared library, and this is a reloc
1925 against a global symbol, or a non PC relative reloc
1926 against a local symbol, then we need to copy the reloc
1927 into the shared library. However, if we are linking with
1928 -Bsymbolic, we do not need to copy a reloc against a
1929 global symbol which is defined in an object we are
1930 including in the link (i.e., DEF_REGULAR is set). At
1931 this point we have not seen all the input files, so it is
1932 possible that DEF_REGULAR is not set now but will be set
1933 later (it is never cleared). In case of a weak definition,
1934 DEF_REGULAR may be cleared later by a strong definition in
1935 a shared library. We account for that possibility below by
1936 storing information in the relocs_copied field of the hash
1937 table entry. A similar situation occurs when creating
1938 shared libraries and symbol visibility changes render the
1941 If on the other hand, we are creating an executable, we
1942 may need to keep relocations for symbols satisfied by a
1943 dynamic library if we manage to avoid copy relocs for the
1946 && (sec
->flags
& SEC_ALLOC
) != 0
1947 && (! IS_X86_64_PCREL_TYPE (r_type
)
1949 && (! SYMBOLIC_BIND (info
, h
)
1950 || h
->root
.type
== bfd_link_hash_defweak
1951 || !h
->def_regular
))))
1952 || (ELIMINATE_COPY_RELOCS
1954 && (sec
->flags
& SEC_ALLOC
) != 0
1956 && (h
->root
.type
== bfd_link_hash_defweak
1957 || !h
->def_regular
)))
1959 struct elf_dyn_relocs
*p
;
1960 struct elf_dyn_relocs
**head
;
1962 /* We must copy these reloc types into the output file.
1963 Create a reloc section in dynobj and make room for
1967 if (htab
->elf
.dynobj
== NULL
)
1968 htab
->elf
.dynobj
= abfd
;
1970 sreloc
= _bfd_elf_make_dynamic_reloc_section
1971 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
1972 abfd
, /*rela?*/ TRUE
);
1978 /* If this is a global symbol, we count the number of
1979 relocations we need for this symbol. */
1982 head
= &((struct elf_x86_64_link_hash_entry
*) h
)->dyn_relocs
;
1986 /* Track dynamic relocs needed for local syms too.
1987 We really need local syms available to do this
1992 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1997 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2001 /* Beware of type punned pointers vs strict aliasing
2003 vpp
= &(elf_section_data (s
)->local_dynrel
);
2004 head
= (struct elf_dyn_relocs
**)vpp
;
2008 if (p
== NULL
|| p
->sec
!= sec
)
2010 bfd_size_type amt
= sizeof *p
;
2012 p
= ((struct elf_dyn_relocs
*)
2013 bfd_alloc (htab
->elf
.dynobj
, amt
));
2024 /* Count size relocation as PC-relative relocation. */
2025 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2030 /* This relocation describes the C++ object vtable hierarchy.
2031 Reconstruct it for later use during GC. */
2032 case R_X86_64_GNU_VTINHERIT
:
2033 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2037 /* This relocation describes which C++ vtable entries are actually
2038 used. Record for later use during GC. */
2039 case R_X86_64_GNU_VTENTRY
:
2040 BFD_ASSERT (h
!= NULL
);
2042 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2054 /* Return the section that should be marked against GC for a given
2058 elf_x86_64_gc_mark_hook (asection
*sec
,
2059 struct bfd_link_info
*info
,
2060 Elf_Internal_Rela
*rel
,
2061 struct elf_link_hash_entry
*h
,
2062 Elf_Internal_Sym
*sym
)
2065 switch (ELF32_R_TYPE (rel
->r_info
))
2067 case R_X86_64_GNU_VTINHERIT
:
2068 case R_X86_64_GNU_VTENTRY
:
2072 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2075 /* Update the got entry reference counts for the section being removed. */
2078 elf_x86_64_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
2080 const Elf_Internal_Rela
*relocs
)
2082 struct elf_x86_64_link_hash_table
*htab
;
2083 Elf_Internal_Shdr
*symtab_hdr
;
2084 struct elf_link_hash_entry
**sym_hashes
;
2085 bfd_signed_vma
*local_got_refcounts
;
2086 const Elf_Internal_Rela
*rel
, *relend
;
2088 if (info
->relocatable
)
2091 htab
= elf_x86_64_hash_table (info
);
2095 elf_section_data (sec
)->local_dynrel
= NULL
;
2097 symtab_hdr
= &elf_symtab_hdr (abfd
);
2098 sym_hashes
= elf_sym_hashes (abfd
);
2099 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2101 htab
= elf_x86_64_hash_table (info
);
2102 relend
= relocs
+ sec
->reloc_count
;
2103 for (rel
= relocs
; rel
< relend
; rel
++)
2105 unsigned long r_symndx
;
2106 unsigned int r_type
;
2107 struct elf_link_hash_entry
*h
= NULL
;
2109 r_symndx
= htab
->r_sym (rel
->r_info
);
2110 if (r_symndx
>= symtab_hdr
->sh_info
)
2112 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2113 while (h
->root
.type
== bfd_link_hash_indirect
2114 || h
->root
.type
== bfd_link_hash_warning
)
2115 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2119 /* A local symbol. */
2120 Elf_Internal_Sym
*isym
;
2122 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2125 /* Check relocation against local STT_GNU_IFUNC symbol. */
2127 && ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2129 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
, FALSE
);
2137 struct elf_x86_64_link_hash_entry
*eh
;
2138 struct elf_dyn_relocs
**pp
;
2139 struct elf_dyn_relocs
*p
;
2141 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2143 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
2146 /* Everything must go for SEC. */
2152 r_type
= ELF32_R_TYPE (rel
->r_info
);
2153 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
2154 symtab_hdr
, sym_hashes
,
2155 &r_type
, GOT_UNKNOWN
,
2156 rel
, relend
, h
, r_symndx
))
2161 case R_X86_64_TLSLD
:
2162 if (htab
->tls_ld_got
.refcount
> 0)
2163 htab
->tls_ld_got
.refcount
-= 1;
2166 case R_X86_64_TLSGD
:
2167 case R_X86_64_GOTPC32_TLSDESC
:
2168 case R_X86_64_TLSDESC_CALL
:
2169 case R_X86_64_GOTTPOFF
:
2170 case R_X86_64_GOT32
:
2171 case R_X86_64_GOTPCREL
:
2172 case R_X86_64_GOT64
:
2173 case R_X86_64_GOTPCREL64
:
2174 case R_X86_64_GOTPLT64
:
2177 if (h
->got
.refcount
> 0)
2178 h
->got
.refcount
-= 1;
2179 if (h
->type
== STT_GNU_IFUNC
)
2181 if (h
->plt
.refcount
> 0)
2182 h
->plt
.refcount
-= 1;
2185 else if (local_got_refcounts
!= NULL
)
2187 if (local_got_refcounts
[r_symndx
] > 0)
2188 local_got_refcounts
[r_symndx
] -= 1;
2200 case R_X86_64_PC32_BND
:
2202 case R_X86_64_SIZE32
:
2203 case R_X86_64_SIZE64
:
2205 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2209 case R_X86_64_PLT32
:
2210 case R_X86_64_PLT32_BND
:
2211 case R_X86_64_PLTOFF64
:
2214 if (h
->plt
.refcount
> 0)
2215 h
->plt
.refcount
-= 1;
2227 /* Adjust a symbol defined by a dynamic object and referenced by a
2228 regular object. The current definition is in some section of the
2229 dynamic object, but we're not including those sections. We have to
2230 change the definition to something the rest of the link can
2234 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2235 struct elf_link_hash_entry
*h
)
2237 struct elf_x86_64_link_hash_table
*htab
;
2239 struct elf_x86_64_link_hash_entry
*eh
;
2240 struct elf_dyn_relocs
*p
;
2242 /* STT_GNU_IFUNC symbol must go through PLT. */
2243 if (h
->type
== STT_GNU_IFUNC
)
2245 /* All local STT_GNU_IFUNC references must be treate as local
2246 calls via local PLT. */
2248 && SYMBOL_CALLS_LOCAL (info
, h
))
2250 bfd_size_type pc_count
= 0, count
= 0;
2251 struct elf_dyn_relocs
**pp
;
2253 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2254 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2256 pc_count
+= p
->pc_count
;
2257 p
->count
-= p
->pc_count
;
2266 if (pc_count
|| count
)
2270 if (h
->plt
.refcount
<= 0)
2271 h
->plt
.refcount
= 1;
2273 h
->plt
.refcount
+= 1;
2277 if (h
->plt
.refcount
<= 0)
2279 h
->plt
.offset
= (bfd_vma
) -1;
2285 /* If this is a function, put it in the procedure linkage table. We
2286 will fill in the contents of the procedure linkage table later,
2287 when we know the address of the .got section. */
2288 if (h
->type
== STT_FUNC
2291 if (h
->plt
.refcount
<= 0
2292 || SYMBOL_CALLS_LOCAL (info
, h
)
2293 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2294 && h
->root
.type
== bfd_link_hash_undefweak
))
2296 /* This case can occur if we saw a PLT32 reloc in an input
2297 file, but the symbol was never referred to by a dynamic
2298 object, or if all references were garbage collected. In
2299 such a case, we don't actually need to build a procedure
2300 linkage table, and we can just do a PC32 reloc instead. */
2301 h
->plt
.offset
= (bfd_vma
) -1;
2308 /* It's possible that we incorrectly decided a .plt reloc was
2309 needed for an R_X86_64_PC32 reloc to a non-function sym in
2310 check_relocs. We can't decide accurately between function and
2311 non-function syms in check-relocs; Objects loaded later in
2312 the link may change h->type. So fix it now. */
2313 h
->plt
.offset
= (bfd_vma
) -1;
2315 /* If this is a weak symbol, and there is a real definition, the
2316 processor independent code will have arranged for us to see the
2317 real definition first, and we can just use the same value. */
2318 if (h
->u
.weakdef
!= NULL
)
2320 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2321 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2322 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2323 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2324 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2325 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2329 /* This is a reference to a symbol defined by a dynamic object which
2330 is not a function. */
2332 /* If we are creating a shared library, we must presume that the
2333 only references to the symbol are via the global offset table.
2334 For such cases we need not do anything here; the relocations will
2335 be handled correctly by relocate_section. */
2339 /* If there are no references to this symbol that do not use the
2340 GOT, we don't need to generate a copy reloc. */
2341 if (!h
->non_got_ref
)
2344 /* If -z nocopyreloc was given, we won't generate them either. */
2345 if (info
->nocopyreloc
)
2351 if (ELIMINATE_COPY_RELOCS
)
2353 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2354 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2356 s
= p
->sec
->output_section
;
2357 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2361 /* If we didn't find any dynamic relocs in read-only sections, then
2362 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2370 /* We must allocate the symbol in our .dynbss section, which will
2371 become part of the .bss section of the executable. There will be
2372 an entry for this symbol in the .dynsym section. The dynamic
2373 object will contain position independent code, so all references
2374 from the dynamic object to this symbol will go through the global
2375 offset table. The dynamic linker will use the .dynsym entry to
2376 determine the address it must put in the global offset table, so
2377 both the dynamic object and the regular object will refer to the
2378 same memory location for the variable. */
2380 htab
= elf_x86_64_hash_table (info
);
2384 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2385 to copy the initial value out of the dynamic object and into the
2386 runtime process image. */
2387 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2389 const struct elf_backend_data
*bed
;
2390 bed
= get_elf_backend_data (info
->output_bfd
);
2391 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2397 return _bfd_elf_adjust_dynamic_copy (h
, s
);
2400 /* Allocate space in .plt, .got and associated reloc sections for
2404 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2406 struct bfd_link_info
*info
;
2407 struct elf_x86_64_link_hash_table
*htab
;
2408 struct elf_x86_64_link_hash_entry
*eh
;
2409 struct elf_dyn_relocs
*p
;
2410 const struct elf_backend_data
*bed
;
2411 unsigned int plt_entry_size
;
2413 if (h
->root
.type
== bfd_link_hash_indirect
)
2416 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2418 info
= (struct bfd_link_info
*) inf
;
2419 htab
= elf_x86_64_hash_table (info
);
2422 bed
= get_elf_backend_data (info
->output_bfd
);
2423 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2425 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2426 here if it is defined and referenced in a non-shared object. */
2427 if (h
->type
== STT_GNU_IFUNC
2430 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2436 asection
*s
= htab
->plt_bnd
;
2437 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
2439 /* Use the .plt.bnd section if it is created. */
2440 eh
->plt_bnd
.offset
= s
->size
;
2442 /* Make room for this entry in the .plt.bnd section. */
2443 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2451 else if (htab
->elf
.dynamic_sections_created
2452 && h
->plt
.refcount
> 0)
2454 /* Make sure this symbol is output as a dynamic symbol.
2455 Undefined weak syms won't yet be marked as dynamic. */
2456 if (h
->dynindx
== -1
2457 && !h
->forced_local
)
2459 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2464 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2466 asection
*s
= htab
->elf
.splt
;
2467 asection
*bnd_s
= htab
->plt_bnd
;
2469 /* If this is the first .plt entry, make room for the special
2472 s
->size
= plt_entry_size
;
2474 h
->plt
.offset
= s
->size
;
2476 eh
->plt_bnd
.offset
= bnd_s
->size
;
2478 /* If this symbol is not defined in a regular file, and we are
2479 not generating a shared library, then set the symbol to this
2480 location in the .plt. This is required to make function
2481 pointers compare as equal between the normal executable and
2482 the shared library. */
2488 /* We need to make a call to the entry of the second
2489 PLT instead of regular PLT entry. */
2490 h
->root
.u
.def
.section
= bnd_s
;
2491 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
2495 h
->root
.u
.def
.section
= s
;
2496 h
->root
.u
.def
.value
= h
->plt
.offset
;
2500 /* Make room for this entry. */
2501 s
->size
+= plt_entry_size
;
2504 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
)
2505 == sizeof (elf_x86_64_legacy_plt2_entry
));
2506 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2509 /* We also need to make an entry in the .got.plt section, which
2510 will be placed in the .got section by the linker script. */
2511 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2513 /* We also need to make an entry in the .rela.plt section. */
2514 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2515 htab
->elf
.srelplt
->reloc_count
++;
2519 h
->plt
.offset
= (bfd_vma
) -1;
2525 h
->plt
.offset
= (bfd_vma
) -1;
2529 eh
->tlsdesc_got
= (bfd_vma
) -1;
2531 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2532 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2533 if (h
->got
.refcount
> 0
2536 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2538 h
->got
.offset
= (bfd_vma
) -1;
2540 else if (h
->got
.refcount
> 0)
2544 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2546 /* Make sure this symbol is output as a dynamic symbol.
2547 Undefined weak syms won't yet be marked as dynamic. */
2548 if (h
->dynindx
== -1
2549 && !h
->forced_local
)
2551 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2555 if (GOT_TLS_GDESC_P (tls_type
))
2557 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2558 - elf_x86_64_compute_jump_table_size (htab
);
2559 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2560 h
->got
.offset
= (bfd_vma
) -2;
2562 if (! GOT_TLS_GDESC_P (tls_type
)
2563 || GOT_TLS_GD_P (tls_type
))
2566 h
->got
.offset
= s
->size
;
2567 s
->size
+= GOT_ENTRY_SIZE
;
2568 if (GOT_TLS_GD_P (tls_type
))
2569 s
->size
+= GOT_ENTRY_SIZE
;
2571 dyn
= htab
->elf
.dynamic_sections_created
;
2572 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2574 R_X86_64_GOTTPOFF needs one dynamic relocation. */
2575 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2576 || tls_type
== GOT_TLS_IE
)
2577 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2578 else if (GOT_TLS_GD_P (tls_type
))
2579 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2580 else if (! GOT_TLS_GDESC_P (tls_type
)
2581 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2582 || h
->root
.type
!= bfd_link_hash_undefweak
)
2584 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2585 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2586 if (GOT_TLS_GDESC_P (tls_type
))
2588 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2589 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2593 h
->got
.offset
= (bfd_vma
) -1;
2595 if (eh
->dyn_relocs
== NULL
)
2598 /* In the shared -Bsymbolic case, discard space allocated for
2599 dynamic pc-relative relocs against symbols which turn out to be
2600 defined in regular objects. For the normal shared case, discard
2601 space for pc-relative relocs that have become local due to symbol
2602 visibility changes. */
2606 /* Relocs that use pc_count are those that appear on a call
2607 insn, or certain REL relocs that can generated via assembly.
2608 We want calls to protected symbols to resolve directly to the
2609 function rather than going via the plt. If people want
2610 function pointer comparisons to work as expected then they
2611 should avoid writing weird assembly. */
2612 if (SYMBOL_CALLS_LOCAL (info
, h
))
2614 struct elf_dyn_relocs
**pp
;
2616 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2618 p
->count
-= p
->pc_count
;
2627 /* Also discard relocs on undefined weak syms with non-default
2629 if (eh
->dyn_relocs
!= NULL
2630 && h
->root
.type
== bfd_link_hash_undefweak
)
2632 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2633 eh
->dyn_relocs
= NULL
;
2635 /* Make sure undefined weak symbols are output as a dynamic
2637 else if (h
->dynindx
== -1
2638 && ! h
->forced_local
2639 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2644 else if (ELIMINATE_COPY_RELOCS
)
2646 /* For the non-shared case, discard space for relocs against
2647 symbols which turn out to need copy relocs or are not
2653 || (htab
->elf
.dynamic_sections_created
2654 && (h
->root
.type
== bfd_link_hash_undefweak
2655 || h
->root
.type
== bfd_link_hash_undefined
))))
2657 /* Make sure this symbol is output as a dynamic symbol.
2658 Undefined weak syms won't yet be marked as dynamic. */
2659 if (h
->dynindx
== -1
2660 && ! h
->forced_local
2661 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2664 /* If that succeeded, we know we'll be keeping all the
2666 if (h
->dynindx
!= -1)
2670 eh
->dyn_relocs
= NULL
;
2675 /* Finally, allocate space. */
2676 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2680 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2682 BFD_ASSERT (sreloc
!= NULL
);
2684 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2690 /* Allocate space in .plt, .got and associated reloc sections for
2691 local dynamic relocs. */
2694 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
2696 struct elf_link_hash_entry
*h
2697 = (struct elf_link_hash_entry
*) *slot
;
2699 if (h
->type
!= STT_GNU_IFUNC
2703 || h
->root
.type
!= bfd_link_hash_defined
)
2706 return elf_x86_64_allocate_dynrelocs (h
, inf
);
2709 /* Find any dynamic relocs that apply to read-only sections. */
2712 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
2715 struct elf_x86_64_link_hash_entry
*eh
;
2716 struct elf_dyn_relocs
*p
;
2718 /* Skip local IFUNC symbols. */
2719 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2722 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2723 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2725 asection
*s
= p
->sec
->output_section
;
2727 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2729 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2731 info
->flags
|= DF_TEXTREL
;
2733 if (info
->warn_shared_textrel
&& info
->shared
)
2734 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2735 p
->sec
->owner
, h
->root
.root
.string
,
2738 /* Not an error, just cut short the traversal. */
2746 mov foo@GOTPCREL(%rip), %reg
2749 with the local symbol, foo. */
2752 elf_x86_64_convert_mov_to_lea (bfd
*abfd
, asection
*sec
,
2753 struct bfd_link_info
*link_info
)
2755 Elf_Internal_Shdr
*symtab_hdr
;
2756 Elf_Internal_Rela
*internal_relocs
;
2757 Elf_Internal_Rela
*irel
, *irelend
;
2759 struct elf_x86_64_link_hash_table
*htab
;
2760 bfd_boolean changed_contents
;
2761 bfd_boolean changed_relocs
;
2762 bfd_signed_vma
*local_got_refcounts
;
2764 /* Don't even try to convert non-ELF outputs. */
2765 if (!is_elf_hash_table (link_info
->hash
))
2768 /* Nothing to do if there are no codes, no relocations or no output. */
2769 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
2770 || sec
->reloc_count
== 0
2771 || bfd_is_abs_section (sec
->output_section
))
2774 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2776 /* Load the relocations for this section. */
2777 internal_relocs
= (_bfd_elf_link_read_relocs
2778 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2779 link_info
->keep_memory
));
2780 if (internal_relocs
== NULL
)
2783 htab
= elf_x86_64_hash_table (link_info
);
2784 changed_contents
= FALSE
;
2785 changed_relocs
= FALSE
;
2786 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2788 /* Get the section contents. */
2789 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2790 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2793 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2797 irelend
= internal_relocs
+ sec
->reloc_count
;
2798 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2800 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
2801 unsigned int r_symndx
= htab
->r_sym (irel
->r_info
);
2803 struct elf_link_hash_entry
*h
;
2805 if (r_type
!= R_X86_64_GOTPCREL
)
2808 /* Get the symbol referred to by the reloc. */
2809 if (r_symndx
< symtab_hdr
->sh_info
)
2811 Elf_Internal_Sym
*isym
;
2813 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2816 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. */
2817 if (ELF_ST_TYPE (isym
->st_info
) != STT_GNU_IFUNC
2818 && irel
->r_offset
>= 2
2819 && bfd_get_8 (input_bfd
,
2820 contents
+ irel
->r_offset
- 2) == 0x8b)
2822 bfd_put_8 (output_bfd
, 0x8d,
2823 contents
+ irel
->r_offset
- 2);
2824 irel
->r_info
= htab
->r_info (r_symndx
, R_X86_64_PC32
);
2825 if (local_got_refcounts
!= NULL
2826 && local_got_refcounts
[r_symndx
] > 0)
2827 local_got_refcounts
[r_symndx
] -= 1;
2828 changed_contents
= TRUE
;
2829 changed_relocs
= TRUE
;
2834 indx
= r_symndx
- symtab_hdr
->sh_info
;
2835 h
= elf_sym_hashes (abfd
)[indx
];
2836 BFD_ASSERT (h
!= NULL
);
2838 while (h
->root
.type
== bfd_link_hash_indirect
2839 || h
->root
.type
== bfd_link_hash_warning
)
2840 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2842 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. We also
2843 avoid optimizing _DYNAMIC since ld.so may use its link-time
2846 && h
->type
!= STT_GNU_IFUNC
2847 && h
!= htab
->elf
.hdynamic
2848 && SYMBOL_REFERENCES_LOCAL (link_info
, h
)
2849 && irel
->r_offset
>= 2
2850 && bfd_get_8 (input_bfd
,
2851 contents
+ irel
->r_offset
- 2) == 0x8b)
2853 bfd_put_8 (output_bfd
, 0x8d,
2854 contents
+ irel
->r_offset
- 2);
2855 irel
->r_info
= htab
->r_info (r_symndx
, R_X86_64_PC32
);
2856 if (h
->got
.refcount
> 0)
2857 h
->got
.refcount
-= 1;
2858 changed_contents
= TRUE
;
2859 changed_relocs
= TRUE
;
2863 if (contents
!= NULL
2864 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2866 if (!changed_contents
&& !link_info
->keep_memory
)
2870 /* Cache the section contents for elf_link_input_bfd. */
2871 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2875 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
2877 if (!changed_relocs
)
2878 free (internal_relocs
);
2880 elf_section_data (sec
)->relocs
= internal_relocs
;
2886 if (contents
!= NULL
2887 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2889 if (internal_relocs
!= NULL
2890 && elf_section_data (sec
)->relocs
!= internal_relocs
)
2891 free (internal_relocs
);
2895 /* Set the sizes of the dynamic sections. */
2898 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
2899 struct bfd_link_info
*info
)
2901 struct elf_x86_64_link_hash_table
*htab
;
2906 const struct elf_backend_data
*bed
;
2908 htab
= elf_x86_64_hash_table (info
);
2911 bed
= get_elf_backend_data (output_bfd
);
2913 dynobj
= htab
->elf
.dynobj
;
2917 if (htab
->elf
.dynamic_sections_created
)
2919 /* Set the contents of the .interp section to the interpreter. */
2920 if (info
->executable
)
2922 s
= bfd_get_linker_section (dynobj
, ".interp");
2925 s
->size
= htab
->dynamic_interpreter_size
;
2926 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2930 /* Set up .got offsets for local syms, and space for local dynamic
2932 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2934 bfd_signed_vma
*local_got
;
2935 bfd_signed_vma
*end_local_got
;
2936 char *local_tls_type
;
2937 bfd_vma
*local_tlsdesc_gotent
;
2938 bfd_size_type locsymcount
;
2939 Elf_Internal_Shdr
*symtab_hdr
;
2942 if (! is_x86_64_elf (ibfd
))
2945 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2947 struct elf_dyn_relocs
*p
;
2949 if (!elf_x86_64_convert_mov_to_lea (ibfd
, s
, info
))
2952 for (p
= (struct elf_dyn_relocs
*)
2953 (elf_section_data (s
)->local_dynrel
);
2957 if (!bfd_is_abs_section (p
->sec
)
2958 && bfd_is_abs_section (p
->sec
->output_section
))
2960 /* Input section has been discarded, either because
2961 it is a copy of a linkonce section or due to
2962 linker script /DISCARD/, so we'll be discarding
2965 else if (p
->count
!= 0)
2967 srel
= elf_section_data (p
->sec
)->sreloc
;
2968 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2969 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
2970 && (info
->flags
& DF_TEXTREL
) == 0)
2972 info
->flags
|= DF_TEXTREL
;
2973 if (info
->warn_shared_textrel
&& info
->shared
)
2974 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2975 p
->sec
->owner
, p
->sec
);
2981 local_got
= elf_local_got_refcounts (ibfd
);
2985 symtab_hdr
= &elf_symtab_hdr (ibfd
);
2986 locsymcount
= symtab_hdr
->sh_info
;
2987 end_local_got
= local_got
+ locsymcount
;
2988 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
2989 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
2991 srel
= htab
->elf
.srelgot
;
2992 for (; local_got
< end_local_got
;
2993 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
2995 *local_tlsdesc_gotent
= (bfd_vma
) -1;
2998 if (GOT_TLS_GDESC_P (*local_tls_type
))
3000 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3001 - elf_x86_64_compute_jump_table_size (htab
);
3002 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3003 *local_got
= (bfd_vma
) -2;
3005 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3006 || GOT_TLS_GD_P (*local_tls_type
))
3008 *local_got
= s
->size
;
3009 s
->size
+= GOT_ENTRY_SIZE
;
3010 if (GOT_TLS_GD_P (*local_tls_type
))
3011 s
->size
+= GOT_ENTRY_SIZE
;
3014 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3015 || *local_tls_type
== GOT_TLS_IE
)
3017 if (GOT_TLS_GDESC_P (*local_tls_type
))
3019 htab
->elf
.srelplt
->size
3020 += bed
->s
->sizeof_rela
;
3021 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3023 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3024 || GOT_TLS_GD_P (*local_tls_type
))
3025 srel
->size
+= bed
->s
->sizeof_rela
;
3029 *local_got
= (bfd_vma
) -1;
3033 if (htab
->tls_ld_got
.refcount
> 0)
3035 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3037 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3038 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3039 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3042 htab
->tls_ld_got
.offset
= -1;
3044 /* Allocate global sym .plt and .got entries, and space for global
3045 sym dynamic relocs. */
3046 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3049 /* Allocate .plt and .got entries, and space for local symbols. */
3050 htab_traverse (htab
->loc_hash_table
,
3051 elf_x86_64_allocate_local_dynrelocs
,
3054 /* For every jump slot reserved in the sgotplt, reloc_count is
3055 incremented. However, when we reserve space for TLS descriptors,
3056 it's not incremented, so in order to compute the space reserved
3057 for them, it suffices to multiply the reloc count by the jump
3060 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3061 so that R_X86_64_IRELATIVE entries come last. */
3062 if (htab
->elf
.srelplt
)
3064 htab
->sgotplt_jump_table_size
3065 = elf_x86_64_compute_jump_table_size (htab
);
3066 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3068 else if (htab
->elf
.irelplt
)
3069 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3071 if (htab
->tlsdesc_plt
)
3073 /* If we're not using lazy TLS relocations, don't generate the
3074 PLT and GOT entries they require. */
3075 if ((info
->flags
& DF_BIND_NOW
))
3076 htab
->tlsdesc_plt
= 0;
3079 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3080 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3081 /* Reserve room for the initial entry.
3082 FIXME: we could probably do away with it in this case. */
3083 if (htab
->elf
.splt
->size
== 0)
3084 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3085 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3086 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3090 if (htab
->elf
.sgotplt
)
3092 /* Don't allocate .got.plt section if there are no GOT nor PLT
3093 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3094 if ((htab
->elf
.hgot
== NULL
3095 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3096 && (htab
->elf
.sgotplt
->size
3097 == get_elf_backend_data (output_bfd
)->got_header_size
)
3098 && (htab
->elf
.splt
== NULL
3099 || htab
->elf
.splt
->size
== 0)
3100 && (htab
->elf
.sgot
== NULL
3101 || htab
->elf
.sgot
->size
== 0)
3102 && (htab
->elf
.iplt
== NULL
3103 || htab
->elf
.iplt
->size
== 0)
3104 && (htab
->elf
.igotplt
== NULL
3105 || htab
->elf
.igotplt
->size
== 0))
3106 htab
->elf
.sgotplt
->size
= 0;
3109 if (htab
->plt_eh_frame
!= NULL
3110 && htab
->elf
.splt
!= NULL
3111 && htab
->elf
.splt
->size
!= 0
3112 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3113 && _bfd_elf_eh_frame_present (info
))
3115 const struct elf_x86_64_backend_data
*arch_data
3116 = get_elf_x86_64_arch_data (bed
);
3117 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3120 /* We now have determined the sizes of the various dynamic sections.
3121 Allocate memory for them. */
3123 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3125 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3128 if (s
== htab
->elf
.splt
3129 || s
== htab
->elf
.sgot
3130 || s
== htab
->elf
.sgotplt
3131 || s
== htab
->elf
.iplt
3132 || s
== htab
->elf
.igotplt
3133 || s
== htab
->plt_bnd
3134 || s
== htab
->plt_eh_frame
3135 || s
== htab
->sdynbss
)
3137 /* Strip this section if we don't need it; see the
3140 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3142 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3145 /* We use the reloc_count field as a counter if we need
3146 to copy relocs into the output file. */
3147 if (s
!= htab
->elf
.srelplt
)
3152 /* It's not one of our sections, so don't allocate space. */
3158 /* If we don't need this section, strip it from the
3159 output file. This is mostly to handle .rela.bss and
3160 .rela.plt. We must create both sections in
3161 create_dynamic_sections, because they must be created
3162 before the linker maps input sections to output
3163 sections. The linker does that before
3164 adjust_dynamic_symbol is called, and it is that
3165 function which decides whether anything needs to go
3166 into these sections. */
3168 s
->flags
|= SEC_EXCLUDE
;
3172 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3175 /* Allocate memory for the section contents. We use bfd_zalloc
3176 here in case unused entries are not reclaimed before the
3177 section's contents are written out. This should not happen,
3178 but this way if it does, we get a R_X86_64_NONE reloc instead
3180 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3181 if (s
->contents
== NULL
)
3185 if (htab
->plt_eh_frame
!= NULL
3186 && htab
->plt_eh_frame
->contents
!= NULL
)
3188 const struct elf_x86_64_backend_data
*arch_data
3189 = get_elf_x86_64_arch_data (bed
);
3191 memcpy (htab
->plt_eh_frame
->contents
,
3192 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3193 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3194 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3197 if (htab
->elf
.dynamic_sections_created
)
3199 /* Add some entries to the .dynamic section. We fill in the
3200 values later, in elf_x86_64_finish_dynamic_sections, but we
3201 must add the entries now so that we get the correct size for
3202 the .dynamic section. The DT_DEBUG entry is filled in by the
3203 dynamic linker and used by the debugger. */
3204 #define add_dynamic_entry(TAG, VAL) \
3205 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3207 if (info
->executable
)
3209 if (!add_dynamic_entry (DT_DEBUG
, 0))
3213 if (htab
->elf
.splt
->size
!= 0)
3215 if (!add_dynamic_entry (DT_PLTGOT
, 0)
3216 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3217 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3218 || !add_dynamic_entry (DT_JMPREL
, 0))
3221 if (htab
->tlsdesc_plt
3222 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3223 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3229 if (!add_dynamic_entry (DT_RELA
, 0)
3230 || !add_dynamic_entry (DT_RELASZ
, 0)
3231 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3234 /* If any dynamic relocs apply to a read-only section,
3235 then we need a DT_TEXTREL entry. */
3236 if ((info
->flags
& DF_TEXTREL
) == 0)
3237 elf_link_hash_traverse (&htab
->elf
,
3238 elf_x86_64_readonly_dynrelocs
,
3241 if ((info
->flags
& DF_TEXTREL
) != 0)
3243 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3248 #undef add_dynamic_entry
3254 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3255 struct bfd_link_info
*info
)
3257 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3261 struct elf_link_hash_entry
*tlsbase
;
3263 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3264 "_TLS_MODULE_BASE_",
3265 FALSE
, FALSE
, FALSE
);
3267 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3269 struct elf_x86_64_link_hash_table
*htab
;
3270 struct bfd_link_hash_entry
*bh
= NULL
;
3271 const struct elf_backend_data
*bed
3272 = get_elf_backend_data (output_bfd
);
3274 htab
= elf_x86_64_hash_table (info
);
3278 if (!(_bfd_generic_link_add_one_symbol
3279 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3280 tls_sec
, 0, NULL
, FALSE
,
3281 bed
->collect
, &bh
)))
3284 htab
->tls_module_base
= bh
;
3286 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3287 tlsbase
->def_regular
= 1;
3288 tlsbase
->other
= STV_HIDDEN
;
3289 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3296 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3297 executables. Rather than setting it to the beginning of the TLS
3298 section, we have to set it to the end. This function may be called
3299 multiple times, it is idempotent. */
3302 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3304 struct elf_x86_64_link_hash_table
*htab
;
3305 struct bfd_link_hash_entry
*base
;
3307 if (!info
->executable
)
3310 htab
= elf_x86_64_hash_table (info
);
3314 base
= htab
->tls_module_base
;
3318 base
->u
.def
.value
= htab
->elf
.tls_size
;
3321 /* Return the base VMA address which should be subtracted from real addresses
3322 when resolving @dtpoff relocation.
3323 This is PT_TLS segment p_vaddr. */
3326 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
3328 /* If tls_sec is NULL, we should have signalled an error already. */
3329 if (elf_hash_table (info
)->tls_sec
== NULL
)
3331 return elf_hash_table (info
)->tls_sec
->vma
;
3334 /* Return the relocation value for @tpoff relocation
3335 if STT_TLS virtual address is ADDRESS. */
3338 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3340 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3341 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3342 bfd_vma static_tls_size
;
3344 /* If tls_segment is NULL, we should have signalled an error already. */
3345 if (htab
->tls_sec
== NULL
)
3348 /* Consider special static TLS alignment requirements. */
3349 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3350 return address
- static_tls_size
- htab
->tls_sec
->vma
;
3353 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3357 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
3359 /* Opcode Instruction
3362 0x0f 0x8x conditional jump */
3364 && (contents
[offset
- 1] == 0xe8
3365 || contents
[offset
- 1] == 0xe9))
3367 && contents
[offset
- 2] == 0x0f
3368 && (contents
[offset
- 1] & 0xf0) == 0x80));
3371 /* Relocate an x86_64 ELF section. */
3374 elf_x86_64_relocate_section (bfd
*output_bfd
,
3375 struct bfd_link_info
*info
,
3377 asection
*input_section
,
3379 Elf_Internal_Rela
*relocs
,
3380 Elf_Internal_Sym
*local_syms
,
3381 asection
**local_sections
)
3383 struct elf_x86_64_link_hash_table
*htab
;
3384 Elf_Internal_Shdr
*symtab_hdr
;
3385 struct elf_link_hash_entry
**sym_hashes
;
3386 bfd_vma
*local_got_offsets
;
3387 bfd_vma
*local_tlsdesc_gotents
;
3388 Elf_Internal_Rela
*rel
;
3389 Elf_Internal_Rela
*relend
;
3390 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3392 BFD_ASSERT (is_x86_64_elf (input_bfd
));
3394 htab
= elf_x86_64_hash_table (info
);
3397 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3398 sym_hashes
= elf_sym_hashes (input_bfd
);
3399 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3400 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
3402 elf_x86_64_set_tls_module_base (info
);
3405 relend
= relocs
+ input_section
->reloc_count
;
3406 for (; rel
< relend
; rel
++)
3408 unsigned int r_type
;
3409 reloc_howto_type
*howto
;
3410 unsigned long r_symndx
;
3411 struct elf_link_hash_entry
*h
;
3412 struct elf_x86_64_link_hash_entry
*eh
;
3413 Elf_Internal_Sym
*sym
;
3415 bfd_vma off
, offplt
, plt_offset
;
3417 bfd_boolean unresolved_reloc
;
3418 bfd_reloc_status_type r
;
3420 asection
*base_got
, *resolved_plt
;
3423 r_type
= ELF32_R_TYPE (rel
->r_info
);
3424 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
3425 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
3428 if (r_type
>= (int) R_X86_64_standard
)
3430 (*_bfd_error_handler
)
3431 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3432 input_bfd
, input_section
, r_type
);
3433 bfd_set_error (bfd_error_bad_value
);
3437 if (r_type
!= (int) R_X86_64_32
3438 || ABI_64_P (output_bfd
))
3439 howto
= x86_64_elf_howto_table
+ r_type
;
3441 howto
= (x86_64_elf_howto_table
3442 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
3443 r_symndx
= htab
->r_sym (rel
->r_info
);
3447 unresolved_reloc
= FALSE
;
3448 if (r_symndx
< symtab_hdr
->sh_info
)
3450 sym
= local_syms
+ r_symndx
;
3451 sec
= local_sections
[r_symndx
];
3453 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
3455 st_size
= sym
->st_size
;
3457 /* Relocate against local STT_GNU_IFUNC symbol. */
3458 if (!info
->relocatable
3459 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3461 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
3466 /* Set STT_GNU_IFUNC symbol value. */
3467 h
->root
.u
.def
.value
= sym
->st_value
;
3468 h
->root
.u
.def
.section
= sec
;
3473 bfd_boolean warned ATTRIBUTE_UNUSED
;
3474 bfd_boolean ignored ATTRIBUTE_UNUSED
;
3476 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3477 r_symndx
, symtab_hdr
, sym_hashes
,
3479 unresolved_reloc
, warned
, ignored
);
3483 if (sec
!= NULL
&& discarded_section (sec
))
3484 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3485 rel
, 1, relend
, howto
, 0, contents
);
3487 if (info
->relocatable
)
3490 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
3492 if (r_type
== R_X86_64_64
)
3494 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
3495 zero-extend it to 64bit if addend is zero. */
3496 r_type
= R_X86_64_32
;
3497 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3499 else if (r_type
== R_X86_64_SIZE64
)
3501 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
3502 zero-extend it to 64bit if addend is zero. */
3503 r_type
= R_X86_64_SIZE32
;
3504 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3508 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3510 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3511 it here if it is defined in a non-shared object. */
3513 && h
->type
== STT_GNU_IFUNC
3519 if ((input_section
->flags
& SEC_ALLOC
) == 0
3520 || h
->plt
.offset
== (bfd_vma
) -1)
3523 /* STT_GNU_IFUNC symbol must go through PLT. */
3524 if (htab
->elf
.splt
!= NULL
)
3526 if (htab
->plt_bnd
!= NULL
)
3528 resolved_plt
= htab
->plt_bnd
;
3529 plt_offset
= eh
->plt_bnd
.offset
;
3533 resolved_plt
= htab
->elf
.splt
;
3534 plt_offset
= h
->plt
.offset
;
3539 resolved_plt
= htab
->elf
.iplt
;
3540 plt_offset
= h
->plt
.offset
;
3543 relocation
= (resolved_plt
->output_section
->vma
3544 + resolved_plt
->output_offset
+ plt_offset
);
3549 if (h
->root
.root
.string
)
3550 name
= h
->root
.root
.string
;
3552 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3554 (*_bfd_error_handler
)
3555 (_("%B: relocation %s against STT_GNU_IFUNC "
3556 "symbol `%s' isn't handled by %s"), input_bfd
,
3557 x86_64_elf_howto_table
[r_type
].name
,
3558 name
, __FUNCTION__
);
3559 bfd_set_error (bfd_error_bad_value
);
3568 if (ABI_64_P (output_bfd
))
3572 if (rel
->r_addend
!= 0)
3574 if (h
->root
.root
.string
)
3575 name
= h
->root
.root
.string
;
3577 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
3579 (*_bfd_error_handler
)
3580 (_("%B: relocation %s against STT_GNU_IFUNC "
3581 "symbol `%s' has non-zero addend: %d"),
3582 input_bfd
, x86_64_elf_howto_table
[r_type
].name
,
3583 name
, rel
->r_addend
);
3584 bfd_set_error (bfd_error_bad_value
);
3588 /* Generate dynamic relcoation only when there is a
3589 non-GOT reference in a shared object. */
3590 if (info
->shared
&& h
->non_got_ref
)
3592 Elf_Internal_Rela outrel
;
3595 /* Need a dynamic relocation to get the real function
3597 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
3601 if (outrel
.r_offset
== (bfd_vma
) -1
3602 || outrel
.r_offset
== (bfd_vma
) -2)
3605 outrel
.r_offset
+= (input_section
->output_section
->vma
3606 + input_section
->output_offset
);
3608 if (h
->dynindx
== -1
3610 || info
->executable
)
3612 /* This symbol is resolved locally. */
3613 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
3614 outrel
.r_addend
= (h
->root
.u
.def
.value
3615 + h
->root
.u
.def
.section
->output_section
->vma
3616 + h
->root
.u
.def
.section
->output_offset
);
3620 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3621 outrel
.r_addend
= 0;
3624 sreloc
= htab
->elf
.irelifunc
;
3625 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3627 /* If this reloc is against an external symbol, we
3628 do not want to fiddle with the addend. Otherwise,
3629 we need to include the symbol value so that it
3630 becomes an addend for the dynamic reloc. For an
3631 internal symbol, we have updated addend. */
3636 case R_X86_64_PC32_BND
:
3638 case R_X86_64_PLT32
:
3639 case R_X86_64_PLT32_BND
:
3642 case R_X86_64_GOTPCREL
:
3643 case R_X86_64_GOTPCREL64
:
3644 base_got
= htab
->elf
.sgot
;
3645 off
= h
->got
.offset
;
3647 if (base_got
== NULL
)
3650 if (off
== (bfd_vma
) -1)
3652 /* We can't use h->got.offset here to save state, or
3653 even just remember the offset, as finish_dynamic_symbol
3654 would use that as offset into .got. */
3656 if (htab
->elf
.splt
!= NULL
)
3658 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3659 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3660 base_got
= htab
->elf
.sgotplt
;
3664 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3665 off
= plt_index
* GOT_ENTRY_SIZE
;
3666 base_got
= htab
->elf
.igotplt
;
3669 if (h
->dynindx
== -1
3673 /* This references the local defitionion. We must
3674 initialize this entry in the global offset table.
3675 Since the offset must always be a multiple of 8,
3676 we use the least significant bit to record
3677 whether we have initialized it already.
3679 When doing a dynamic link, we create a .rela.got
3680 relocation entry to initialize the value. This
3681 is done in the finish_dynamic_symbol routine. */
3686 bfd_put_64 (output_bfd
, relocation
,
3687 base_got
->contents
+ off
);
3688 /* Note that this is harmless for the GOTPLT64
3689 case, as -1 | 1 still is -1. */
3695 relocation
= (base_got
->output_section
->vma
3696 + base_got
->output_offset
+ off
);
3702 /* When generating a shared object, the relocations handled here are
3703 copied into the output file to be resolved at run time. */
3706 case R_X86_64_GOT32
:
3707 case R_X86_64_GOT64
:
3708 /* Relocation is to the entry for this symbol in the global
3710 case R_X86_64_GOTPCREL
:
3711 case R_X86_64_GOTPCREL64
:
3712 /* Use global offset table entry as symbol value. */
3713 case R_X86_64_GOTPLT64
:
3714 /* This is obsolete and treated the the same as GOT64. */
3715 base_got
= htab
->elf
.sgot
;
3717 if (htab
->elf
.sgot
== NULL
)
3724 off
= h
->got
.offset
;
3726 && h
->plt
.offset
!= (bfd_vma
)-1
3727 && off
== (bfd_vma
)-1)
3729 /* We can't use h->got.offset here to save
3730 state, or even just remember the offset, as
3731 finish_dynamic_symbol would use that as offset into
3733 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3734 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3735 base_got
= htab
->elf
.sgotplt
;
3738 dyn
= htab
->elf
.dynamic_sections_created
;
3740 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
3742 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3743 || (ELF_ST_VISIBILITY (h
->other
)
3744 && h
->root
.type
== bfd_link_hash_undefweak
))
3746 /* This is actually a static link, or it is a -Bsymbolic
3747 link and the symbol is defined locally, or the symbol
3748 was forced to be local because of a version file. We
3749 must initialize this entry in the global offset table.
3750 Since the offset must always be a multiple of 8, we
3751 use the least significant bit to record whether we
3752 have initialized it already.
3754 When doing a dynamic link, we create a .rela.got
3755 relocation entry to initialize the value. This is
3756 done in the finish_dynamic_symbol routine. */
3761 bfd_put_64 (output_bfd
, relocation
,
3762 base_got
->contents
+ off
);
3763 /* Note that this is harmless for the GOTPLT64 case,
3764 as -1 | 1 still is -1. */
3769 unresolved_reloc
= FALSE
;
3773 if (local_got_offsets
== NULL
)
3776 off
= local_got_offsets
[r_symndx
];
3778 /* The offset must always be a multiple of 8. We use
3779 the least significant bit to record whether we have
3780 already generated the necessary reloc. */
3785 bfd_put_64 (output_bfd
, relocation
,
3786 base_got
->contents
+ off
);
3791 Elf_Internal_Rela outrel
;
3793 /* We need to generate a R_X86_64_RELATIVE reloc
3794 for the dynamic linker. */
3795 s
= htab
->elf
.srelgot
;
3799 outrel
.r_offset
= (base_got
->output_section
->vma
3800 + base_got
->output_offset
3802 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3803 outrel
.r_addend
= relocation
;
3804 elf_append_rela (output_bfd
, s
, &outrel
);
3807 local_got_offsets
[r_symndx
] |= 1;
3811 if (off
>= (bfd_vma
) -2)
3814 relocation
= base_got
->output_section
->vma
3815 + base_got
->output_offset
+ off
;
3816 if (r_type
!= R_X86_64_GOTPCREL
&& r_type
!= R_X86_64_GOTPCREL64
)
3817 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3818 - htab
->elf
.sgotplt
->output_offset
;
3822 case R_X86_64_GOTOFF64
:
3823 /* Relocation is relative to the start of the global offset
3826 /* Check to make sure it isn't a protected function symbol
3827 for shared library since it may not be local when used
3828 as function address. */
3829 if (!info
->executable
3831 && !SYMBOLIC_BIND (info
, h
)
3833 && h
->type
== STT_FUNC
3834 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
3836 (*_bfd_error_handler
)
3837 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3838 input_bfd
, h
->root
.root
.string
);
3839 bfd_set_error (bfd_error_bad_value
);
3843 /* Note that sgot is not involved in this
3844 calculation. We always want the start of .got.plt. If we
3845 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3846 permitted by the ABI, we might have to change this
3848 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3849 + htab
->elf
.sgotplt
->output_offset
;
3852 case R_X86_64_GOTPC32
:
3853 case R_X86_64_GOTPC64
:
3854 /* Use global offset table as symbol value. */
3855 relocation
= htab
->elf
.sgotplt
->output_section
->vma
3856 + htab
->elf
.sgotplt
->output_offset
;
3857 unresolved_reloc
= FALSE
;
3860 case R_X86_64_PLTOFF64
:
3861 /* Relocation is PLT entry relative to GOT. For local
3862 symbols it's the symbol itself relative to GOT. */
3864 /* See PLT32 handling. */
3865 && h
->plt
.offset
!= (bfd_vma
) -1
3866 && htab
->elf
.splt
!= NULL
)
3868 if (htab
->plt_bnd
!= NULL
)
3870 resolved_plt
= htab
->plt_bnd
;
3871 plt_offset
= eh
->plt_bnd
.offset
;
3875 resolved_plt
= htab
->elf
.splt
;
3876 plt_offset
= h
->plt
.offset
;
3879 relocation
= (resolved_plt
->output_section
->vma
3880 + resolved_plt
->output_offset
3882 unresolved_reloc
= FALSE
;
3885 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3886 + htab
->elf
.sgotplt
->output_offset
;
3889 case R_X86_64_PLT32
:
3890 case R_X86_64_PLT32_BND
:
3891 /* Relocation is to the entry for this symbol in the
3892 procedure linkage table. */
3894 /* Resolve a PLT32 reloc against a local symbol directly,
3895 without using the procedure linkage table. */
3899 if (h
->plt
.offset
== (bfd_vma
) -1
3900 || htab
->elf
.splt
== NULL
)
3902 /* We didn't make a PLT entry for this symbol. This
3903 happens when statically linking PIC code, or when
3904 using -Bsymbolic. */
3908 if (htab
->plt_bnd
!= NULL
)
3910 resolved_plt
= htab
->plt_bnd
;
3911 plt_offset
= eh
->plt_bnd
.offset
;
3915 resolved_plt
= htab
->elf
.splt
;
3916 plt_offset
= h
->plt
.offset
;
3919 relocation
= (resolved_plt
->output_section
->vma
3920 + resolved_plt
->output_offset
3922 unresolved_reloc
= FALSE
;
3925 case R_X86_64_SIZE32
:
3926 case R_X86_64_SIZE64
:
3927 /* Set to symbol size. */
3928 relocation
= st_size
;
3934 case R_X86_64_PC32_BND
:
3936 && (input_section
->flags
& SEC_ALLOC
) != 0
3937 && (input_section
->flags
& SEC_READONLY
) != 0
3940 bfd_boolean fail
= FALSE
;
3942 = ((r_type
== R_X86_64_PC32
3943 || r_type
== R_X86_64_PC32_BND
)
3944 && is_32bit_relative_branch (contents
, rel
->r_offset
));
3946 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
3948 /* Symbol is referenced locally. Make sure it is
3949 defined locally or for a branch. */
3950 fail
= !h
->def_regular
&& !branch
;
3954 /* Symbol isn't referenced locally. We only allow
3955 branch to symbol with non-default visibility. */
3957 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
3964 const char *pic
= "";
3966 switch (ELF_ST_VISIBILITY (h
->other
))
3969 v
= _("hidden symbol");
3972 v
= _("internal symbol");
3975 v
= _("protected symbol");
3979 pic
= _("; recompile with -fPIC");
3984 fmt
= _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3986 fmt
= _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3988 (*_bfd_error_handler
) (fmt
, input_bfd
,
3989 x86_64_elf_howto_table
[r_type
].name
,
3990 v
, h
->root
.root
.string
, pic
);
3991 bfd_set_error (bfd_error_bad_value
);
4002 /* FIXME: The ABI says the linker should make sure the value is
4003 the same when it's zeroextended to 64 bit. */
4006 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4011 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4012 || h
->root
.type
!= bfd_link_hash_undefweak
)
4013 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4014 && r_type
!= R_X86_64_SIZE32
4015 && r_type
!= R_X86_64_SIZE64
)
4016 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4017 || (ELIMINATE_COPY_RELOCS
4024 || h
->root
.type
== bfd_link_hash_undefweak
4025 || h
->root
.type
== bfd_link_hash_undefined
)))
4027 Elf_Internal_Rela outrel
;
4028 bfd_boolean skip
, relocate
;
4031 /* When generating a shared object, these relocations
4032 are copied into the output file to be resolved at run
4038 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4040 if (outrel
.r_offset
== (bfd_vma
) -1)
4042 else if (outrel
.r_offset
== (bfd_vma
) -2)
4043 skip
= TRUE
, relocate
= TRUE
;
4045 outrel
.r_offset
+= (input_section
->output_section
->vma
4046 + input_section
->output_offset
);
4049 memset (&outrel
, 0, sizeof outrel
);
4051 /* h->dynindx may be -1 if this symbol was marked to
4055 && (IS_X86_64_PCREL_TYPE (r_type
)
4057 || ! SYMBOLIC_BIND (info
, h
)
4058 || ! h
->def_regular
))
4060 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4061 outrel
.r_addend
= rel
->r_addend
;
4065 /* This symbol is local, or marked to become local. */
4066 if (r_type
== htab
->pointer_r_type
)
4069 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4070 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4072 else if (r_type
== R_X86_64_64
4073 && !ABI_64_P (output_bfd
))
4076 outrel
.r_info
= htab
->r_info (0,
4077 R_X86_64_RELATIVE64
);
4078 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4079 /* Check addend overflow. */
4080 if ((outrel
.r_addend
& 0x80000000)
4081 != (rel
->r_addend
& 0x80000000))
4084 int addend
= rel
->r_addend
;
4085 if (h
&& h
->root
.root
.string
)
4086 name
= h
->root
.root
.string
;
4088 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4091 (*_bfd_error_handler
)
4092 (_("%B: addend -0x%x in relocation %s against "
4093 "symbol `%s' at 0x%lx in section `%A' is "
4095 input_bfd
, input_section
, addend
,
4096 x86_64_elf_howto_table
[r_type
].name
,
4097 name
, (unsigned long) rel
->r_offset
);
4099 (*_bfd_error_handler
)
4100 (_("%B: addend 0x%x in relocation %s against "
4101 "symbol `%s' at 0x%lx in section `%A' is "
4103 input_bfd
, input_section
, addend
,
4104 x86_64_elf_howto_table
[r_type
].name
,
4105 name
, (unsigned long) rel
->r_offset
);
4106 bfd_set_error (bfd_error_bad_value
);
4114 if (bfd_is_abs_section (sec
))
4116 else if (sec
== NULL
|| sec
->owner
== NULL
)
4118 bfd_set_error (bfd_error_bad_value
);
4125 /* We are turning this relocation into one
4126 against a section symbol. It would be
4127 proper to subtract the symbol's value,
4128 osec->vma, from the emitted reloc addend,
4129 but ld.so expects buggy relocs. */
4130 osec
= sec
->output_section
;
4131 sindx
= elf_section_data (osec
)->dynindx
;
4134 asection
*oi
= htab
->elf
.text_index_section
;
4135 sindx
= elf_section_data (oi
)->dynindx
;
4137 BFD_ASSERT (sindx
!= 0);
4140 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4141 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4145 sreloc
= elf_section_data (input_section
)->sreloc
;
4147 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4149 r
= bfd_reloc_notsupported
;
4150 goto check_relocation_error
;
4153 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4155 /* If this reloc is against an external symbol, we do
4156 not want to fiddle with the addend. Otherwise, we
4157 need to include the symbol value so that it becomes
4158 an addend for the dynamic reloc. */
4165 case R_X86_64_TLSGD
:
4166 case R_X86_64_GOTPC32_TLSDESC
:
4167 case R_X86_64_TLSDESC_CALL
:
4168 case R_X86_64_GOTTPOFF
:
4169 tls_type
= GOT_UNKNOWN
;
4170 if (h
== NULL
&& local_got_offsets
)
4171 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4173 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4175 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4176 input_section
, contents
,
4177 symtab_hdr
, sym_hashes
,
4178 &r_type
, tls_type
, rel
,
4179 relend
, h
, r_symndx
))
4182 if (r_type
== R_X86_64_TPOFF32
)
4184 bfd_vma roff
= rel
->r_offset
;
4186 BFD_ASSERT (! unresolved_reloc
);
4188 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4190 /* GD->LE transition. For 64bit, change
4191 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4192 .word 0x6666; rex64; call __tls_get_addr
4195 leaq foo@tpoff(%rax), %rax
4197 leaq foo@tlsgd(%rip), %rdi
4198 .word 0x6666; rex64; call __tls_get_addr
4201 leaq foo@tpoff(%rax), %rax
4202 For largepic, change:
4203 leaq foo@tlsgd(%rip), %rdi
4204 movabsq $__tls_get_addr@pltoff, %rax
4209 leaq foo@tpoff(%rax), %rax
4210 nopw 0x0(%rax,%rax,1) */
4212 if (ABI_64_P (output_bfd
)
4213 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4215 memcpy (contents
+ roff
- 3,
4216 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4217 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4220 else if (ABI_64_P (output_bfd
))
4221 memcpy (contents
+ roff
- 4,
4222 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4225 memcpy (contents
+ roff
- 3,
4226 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4228 bfd_put_32 (output_bfd
,
4229 elf_x86_64_tpoff (info
, relocation
),
4230 contents
+ roff
+ 8 + largepic
);
4231 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4235 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4237 /* GDesc -> LE transition.
4238 It's originally something like:
4239 leaq x@tlsdesc(%rip), %rax
4242 movl $x@tpoff, %rax. */
4244 unsigned int val
, type
;
4246 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4247 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4248 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
4249 contents
+ roff
- 3);
4250 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
4251 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4252 contents
+ roff
- 1);
4253 bfd_put_32 (output_bfd
,
4254 elf_x86_64_tpoff (info
, relocation
),
4258 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4260 /* GDesc -> LE transition.
4265 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4266 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4269 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
4271 /* IE->LE transition:
4272 For 64bit, originally it can be one of:
4273 movq foo@gottpoff(%rip), %reg
4274 addq foo@gottpoff(%rip), %reg
4277 leaq foo(%reg), %reg
4279 For 32bit, originally it can be one of:
4280 movq foo@gottpoff(%rip), %reg
4281 addl foo@gottpoff(%rip), %reg
4284 leal foo(%reg), %reg
4287 unsigned int val
, type
, reg
;
4290 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4293 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
4294 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4300 bfd_put_8 (output_bfd
, 0x49,
4301 contents
+ roff
- 3);
4302 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4303 bfd_put_8 (output_bfd
, 0x41,
4304 contents
+ roff
- 3);
4305 bfd_put_8 (output_bfd
, 0xc7,
4306 contents
+ roff
- 2);
4307 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4308 contents
+ roff
- 1);
4312 /* addq/addl -> addq/addl - addressing with %rsp/%r12
4315 bfd_put_8 (output_bfd
, 0x49,
4316 contents
+ roff
- 3);
4317 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4318 bfd_put_8 (output_bfd
, 0x41,
4319 contents
+ roff
- 3);
4320 bfd_put_8 (output_bfd
, 0x81,
4321 contents
+ roff
- 2);
4322 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4323 contents
+ roff
- 1);
4327 /* addq/addl -> leaq/leal */
4329 bfd_put_8 (output_bfd
, 0x4d,
4330 contents
+ roff
- 3);
4331 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4332 bfd_put_8 (output_bfd
, 0x45,
4333 contents
+ roff
- 3);
4334 bfd_put_8 (output_bfd
, 0x8d,
4335 contents
+ roff
- 2);
4336 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
4337 contents
+ roff
- 1);
4339 bfd_put_32 (output_bfd
,
4340 elf_x86_64_tpoff (info
, relocation
),
4348 if (htab
->elf
.sgot
== NULL
)
4353 off
= h
->got
.offset
;
4354 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
4358 if (local_got_offsets
== NULL
)
4361 off
= local_got_offsets
[r_symndx
];
4362 offplt
= local_tlsdesc_gotents
[r_symndx
];
4369 Elf_Internal_Rela outrel
;
4373 if (htab
->elf
.srelgot
== NULL
)
4376 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4378 if (GOT_TLS_GDESC_P (tls_type
))
4380 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
4381 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
4382 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
4383 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4384 + htab
->elf
.sgotplt
->output_offset
4386 + htab
->sgotplt_jump_table_size
);
4387 sreloc
= htab
->elf
.srelplt
;
4389 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
4391 outrel
.r_addend
= 0;
4392 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4395 sreloc
= htab
->elf
.srelgot
;
4397 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4398 + htab
->elf
.sgot
->output_offset
+ off
);
4400 if (GOT_TLS_GD_P (tls_type
))
4401 dr_type
= R_X86_64_DTPMOD64
;
4402 else if (GOT_TLS_GDESC_P (tls_type
))
4405 dr_type
= R_X86_64_TPOFF64
;
4407 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
4408 outrel
.r_addend
= 0;
4409 if ((dr_type
== R_X86_64_TPOFF64
4410 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
4411 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
4412 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
4414 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4416 if (GOT_TLS_GD_P (tls_type
))
4420 BFD_ASSERT (! unresolved_reloc
);
4421 bfd_put_64 (output_bfd
,
4422 relocation
- elf_x86_64_dtpoff_base (info
),
4423 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4427 bfd_put_64 (output_bfd
, 0,
4428 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4429 outrel
.r_info
= htab
->r_info (indx
,
4431 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
4432 elf_append_rela (output_bfd
, sreloc
,
4441 local_got_offsets
[r_symndx
] |= 1;
4444 if (off
>= (bfd_vma
) -2
4445 && ! GOT_TLS_GDESC_P (tls_type
))
4447 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4449 if (r_type
== R_X86_64_GOTPC32_TLSDESC
4450 || r_type
== R_X86_64_TLSDESC_CALL
)
4451 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4452 + htab
->elf
.sgotplt
->output_offset
4453 + offplt
+ htab
->sgotplt_jump_table_size
;
4455 relocation
= htab
->elf
.sgot
->output_section
->vma
4456 + htab
->elf
.sgot
->output_offset
+ off
;
4457 unresolved_reloc
= FALSE
;
4461 bfd_vma roff
= rel
->r_offset
;
4463 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4465 /* GD->IE transition. For 64bit, change
4466 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4467 .word 0x6666; rex64; call __tls_get_addr@plt
4470 addq foo@gottpoff(%rip), %rax
4472 leaq foo@tlsgd(%rip), %rdi
4473 .word 0x6666; rex64; call __tls_get_addr@plt
4476 addq foo@gottpoff(%rip), %rax
4477 For largepic, change:
4478 leaq foo@tlsgd(%rip), %rdi
4479 movabsq $__tls_get_addr@pltoff, %rax
4484 addq foo@gottpoff(%rax), %rax
4485 nopw 0x0(%rax,%rax,1) */
4487 if (ABI_64_P (output_bfd
)
4488 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4490 memcpy (contents
+ roff
- 3,
4491 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
4492 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4495 else if (ABI_64_P (output_bfd
))
4496 memcpy (contents
+ roff
- 4,
4497 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4500 memcpy (contents
+ roff
- 3,
4501 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4504 relocation
= (htab
->elf
.sgot
->output_section
->vma
4505 + htab
->elf
.sgot
->output_offset
+ off
4508 - input_section
->output_section
->vma
4509 - input_section
->output_offset
4511 bfd_put_32 (output_bfd
, relocation
,
4512 contents
+ roff
+ 8 + largepic
);
4513 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4517 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4519 /* GDesc -> IE transition.
4520 It's originally something like:
4521 leaq x@tlsdesc(%rip), %rax
4524 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
4526 /* Now modify the instruction as appropriate. To
4527 turn a leaq into a movq in the form we use it, it
4528 suffices to change the second byte from 0x8d to
4530 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4532 bfd_put_32 (output_bfd
,
4533 htab
->elf
.sgot
->output_section
->vma
4534 + htab
->elf
.sgot
->output_offset
+ off
4536 - input_section
->output_section
->vma
4537 - input_section
->output_offset
4542 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4544 /* GDesc -> IE transition.
4551 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4552 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4560 case R_X86_64_TLSLD
:
4561 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4562 input_section
, contents
,
4563 symtab_hdr
, sym_hashes
,
4564 &r_type
, GOT_UNKNOWN
,
4565 rel
, relend
, h
, r_symndx
))
4568 if (r_type
!= R_X86_64_TLSLD
)
4570 /* LD->LE transition:
4571 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4572 For 64bit, we change it into:
4573 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4574 For 32bit, we change it into:
4575 nopl 0x0(%rax); movl %fs:0, %eax.
4576 For largepic, change:
4577 leaq foo@tlsgd(%rip), %rdi
4578 movabsq $__tls_get_addr@pltoff, %rax
4582 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
4585 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
4586 if (ABI_64_P (output_bfd
)
4587 && contents
[rel
->r_offset
+ 5] == (bfd_byte
) '\xb8')
4588 memcpy (contents
+ rel
->r_offset
- 3,
4589 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
4590 "\x64\x48\x8b\x04\x25\0\0\0", 22);
4591 else if (ABI_64_P (output_bfd
))
4592 memcpy (contents
+ rel
->r_offset
- 3,
4593 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4595 memcpy (contents
+ rel
->r_offset
- 3,
4596 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4597 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4602 if (htab
->elf
.sgot
== NULL
)
4605 off
= htab
->tls_ld_got
.offset
;
4610 Elf_Internal_Rela outrel
;
4612 if (htab
->elf
.srelgot
== NULL
)
4615 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4616 + htab
->elf
.sgot
->output_offset
+ off
);
4618 bfd_put_64 (output_bfd
, 0,
4619 htab
->elf
.sgot
->contents
+ off
);
4620 bfd_put_64 (output_bfd
, 0,
4621 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4622 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
4623 outrel
.r_addend
= 0;
4624 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
4626 htab
->tls_ld_got
.offset
|= 1;
4628 relocation
= htab
->elf
.sgot
->output_section
->vma
4629 + htab
->elf
.sgot
->output_offset
+ off
;
4630 unresolved_reloc
= FALSE
;
4633 case R_X86_64_DTPOFF32
:
4634 if (!info
->executable
|| (input_section
->flags
& SEC_CODE
) == 0)
4635 relocation
-= elf_x86_64_dtpoff_base (info
);
4637 relocation
= elf_x86_64_tpoff (info
, relocation
);
4640 case R_X86_64_TPOFF32
:
4641 case R_X86_64_TPOFF64
:
4642 BFD_ASSERT (info
->executable
);
4643 relocation
= elf_x86_64_tpoff (info
, relocation
);
4646 case R_X86_64_DTPOFF64
:
4647 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
4648 relocation
-= elf_x86_64_dtpoff_base (info
);
4655 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4656 because such sections are not SEC_ALLOC and thus ld.so will
4657 not process them. */
4658 if (unresolved_reloc
4659 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
4661 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4662 rel
->r_offset
) != (bfd_vma
) -1)
4664 (*_bfd_error_handler
)
4665 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4668 (long) rel
->r_offset
,
4670 h
->root
.root
.string
);
4675 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4676 contents
, rel
->r_offset
,
4677 relocation
, rel
->r_addend
);
4679 check_relocation_error
:
4680 if (r
!= bfd_reloc_ok
)
4685 name
= h
->root
.root
.string
;
4688 name
= bfd_elf_string_from_elf_section (input_bfd
,
4689 symtab_hdr
->sh_link
,
4694 name
= bfd_section_name (input_bfd
, sec
);
4697 if (r
== bfd_reloc_overflow
)
4699 if (! ((*info
->callbacks
->reloc_overflow
)
4700 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4701 (bfd_vma
) 0, input_bfd
, input_section
,
4707 (*_bfd_error_handler
)
4708 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4709 input_bfd
, input_section
,
4710 (long) rel
->r_offset
, name
, (int) r
);
4719 /* Finish up dynamic symbol handling. We set the contents of various
4720 dynamic sections here. */
4723 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
4724 struct bfd_link_info
*info
,
4725 struct elf_link_hash_entry
*h
,
4726 Elf_Internal_Sym
*sym ATTRIBUTE_UNUSED
)
4728 struct elf_x86_64_link_hash_table
*htab
;
4729 const struct elf_x86_64_backend_data
*abed
;
4730 bfd_boolean use_plt_bnd
;
4732 htab
= elf_x86_64_hash_table (info
);
4736 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
4737 section only if there is .plt section. */
4738 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
4740 ? &elf_x86_64_bnd_arch_bed
4741 : get_elf_x86_64_backend_data (output_bfd
));
4743 if (h
->plt
.offset
!= (bfd_vma
) -1)
4746 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
4747 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
4748 Elf_Internal_Rela rela
;
4750 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
4751 const struct elf_backend_data
*bed
;
4752 bfd_vma plt_got_pcrel_offset
;
4754 /* When building a static executable, use .iplt, .igot.plt and
4755 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4756 if (htab
->elf
.splt
!= NULL
)
4758 plt
= htab
->elf
.splt
;
4759 gotplt
= htab
->elf
.sgotplt
;
4760 relplt
= htab
->elf
.srelplt
;
4764 plt
= htab
->elf
.iplt
;
4765 gotplt
= htab
->elf
.igotplt
;
4766 relplt
= htab
->elf
.irelplt
;
4769 /* This symbol has an entry in the procedure linkage table. Set
4771 if ((h
->dynindx
== -1
4772 && !((h
->forced_local
|| info
->executable
)
4774 && h
->type
== STT_GNU_IFUNC
))
4780 /* Get the index in the procedure linkage table which
4781 corresponds to this symbol. This is the index of this symbol
4782 in all the symbols for which we are making plt entries. The
4783 first entry in the procedure linkage table is reserved.
4785 Get the offset into the .got table of the entry that
4786 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
4787 bytes. The first three are reserved for the dynamic linker.
4789 For static executables, we don't reserve anything. */
4791 if (plt
== htab
->elf
.splt
)
4793 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
4794 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
4798 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
4799 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
4802 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
4803 plt_plt_offset
= abed
->plt_plt_offset
;
4804 plt_got_insn_size
= abed
->plt_got_insn_size
;
4805 plt_got_offset
= abed
->plt_got_offset
;
4808 /* Use the second PLT with BND relocations. */
4809 const bfd_byte
*plt_entry
, *plt2_entry
;
4810 struct elf_x86_64_link_hash_entry
*eh
4811 = (struct elf_x86_64_link_hash_entry
*) h
;
4813 if (eh
->has_bnd_reloc
)
4815 plt_entry
= elf_x86_64_bnd_plt_entry
;
4816 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
4820 plt_entry
= elf_x86_64_legacy_plt_entry
;
4821 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
4823 /* Subtract 1 since there is no BND prefix. */
4824 plt_plt_insn_end
-= 1;
4825 plt_plt_offset
-= 1;
4826 plt_got_insn_size
-= 1;
4827 plt_got_offset
-= 1;
4830 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
4831 == sizeof (elf_x86_64_legacy_plt_entry
));
4833 /* Fill in the entry in the procedure linkage table. */
4834 memcpy (plt
->contents
+ h
->plt
.offset
,
4835 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
4836 /* Fill in the entry in the second PLT. */
4837 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
4838 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
4840 resolved_plt
= htab
->plt_bnd
;
4841 plt_offset
= eh
->plt_bnd
.offset
;
4845 /* Fill in the entry in the procedure linkage table. */
4846 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
4847 abed
->plt_entry_size
);
4850 plt_offset
= h
->plt
.offset
;
4853 /* Insert the relocation positions of the plt section. */
4855 /* Put offset the PC-relative instruction referring to the GOT entry,
4856 subtracting the size of that instruction. */
4857 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
4858 + gotplt
->output_offset
4860 - resolved_plt
->output_section
->vma
4861 - resolved_plt
->output_offset
4863 - plt_got_insn_size
);
4865 /* Check PC-relative offset overflow in PLT entry. */
4866 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
4867 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
4868 output_bfd
, h
->root
.root
.string
);
4870 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
4871 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
4873 /* Fill in the entry in the global offset table, initially this
4874 points to the second part of the PLT entry. */
4875 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4876 + plt
->output_offset
4877 + h
->plt
.offset
+ abed
->plt_lazy_offset
),
4878 gotplt
->contents
+ got_offset
);
4880 /* Fill in the entry in the .rela.plt section. */
4881 rela
.r_offset
= (gotplt
->output_section
->vma
4882 + gotplt
->output_offset
4884 if (h
->dynindx
== -1
4885 || ((info
->executable
4886 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
4888 && h
->type
== STT_GNU_IFUNC
))
4890 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4891 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4892 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4893 rela
.r_addend
= (h
->root
.u
.def
.value
4894 + h
->root
.u
.def
.section
->output_section
->vma
4895 + h
->root
.u
.def
.section
->output_offset
);
4896 /* R_X86_64_IRELATIVE comes last. */
4897 plt_index
= htab
->next_irelative_index
--;
4901 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
4903 plt_index
= htab
->next_jump_slot_index
++;
4906 /* Don't fill PLT entry for static executables. */
4907 if (plt
== htab
->elf
.splt
)
4909 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
4911 /* Put relocation index. */
4912 bfd_put_32 (output_bfd
, plt_index
,
4913 plt
->contents
+ h
->plt
.offset
+ abed
->plt_reloc_offset
);
4915 /* Put offset for jmp .PLT0 and check for overflow. We don't
4916 check relocation index for overflow since branch displacement
4917 will overflow first. */
4918 if (plt0_offset
> 0x80000000)
4919 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
4920 output_bfd
, h
->root
.root
.string
);
4921 bfd_put_32 (output_bfd
, - plt0_offset
,
4922 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
4925 bed
= get_elf_backend_data (output_bfd
);
4926 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
4927 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
4929 if (!h
->def_regular
)
4931 /* Mark the symbol as undefined, rather than as defined in
4932 the .plt section. Leave the value if there were any
4933 relocations where pointer equality matters (this is a clue
4934 for the dynamic linker, to make function pointer
4935 comparisons work between an application and shared
4936 library), otherwise set it to zero. If a function is only
4937 called from a binary, there is no need to slow down
4938 shared libraries because of that. */
4939 sym
->st_shndx
= SHN_UNDEF
;
4940 if (!h
->pointer_equality_needed
)
4945 if (h
->got
.offset
!= (bfd_vma
) -1
4946 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
4947 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
)
4949 Elf_Internal_Rela rela
;
4951 /* This symbol has an entry in the global offset table. Set it
4953 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
4956 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4957 + htab
->elf
.sgot
->output_offset
4958 + (h
->got
.offset
&~ (bfd_vma
) 1));
4960 /* If this is a static link, or it is a -Bsymbolic link and the
4961 symbol is defined locally or was forced to be local because
4962 of a version file, we just want to emit a RELATIVE reloc.
4963 The entry in the global offset table will already have been
4964 initialized in the relocate_section function. */
4966 && h
->type
== STT_GNU_IFUNC
)
4970 /* Generate R_X86_64_GLOB_DAT. */
4977 if (!h
->pointer_equality_needed
)
4980 /* For non-shared object, we can't use .got.plt, which
4981 contains the real function addres if we need pointer
4982 equality. We load the GOT entry with the PLT entry. */
4983 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
4984 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4985 + plt
->output_offset
4987 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4991 else if (info
->shared
4992 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4994 if (!h
->def_regular
)
4996 BFD_ASSERT((h
->got
.offset
& 1) != 0);
4997 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4998 rela
.r_addend
= (h
->root
.u
.def
.value
4999 + h
->root
.u
.def
.section
->output_section
->vma
5000 + h
->root
.u
.def
.section
->output_offset
);
5004 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5006 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5007 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5008 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
5012 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5017 Elf_Internal_Rela rela
;
5019 /* This symbol needs a copy reloc. Set it up. */
5021 if (h
->dynindx
== -1
5022 || (h
->root
.type
!= bfd_link_hash_defined
5023 && h
->root
.type
!= bfd_link_hash_defweak
)
5024 || htab
->srelbss
== NULL
)
5027 rela
.r_offset
= (h
->root
.u
.def
.value
5028 + h
->root
.u
.def
.section
->output_section
->vma
5029 + h
->root
.u
.def
.section
->output_offset
);
5030 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5032 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5038 /* Finish up local dynamic symbol handling. We set the contents of
5039 various dynamic sections here. */
5042 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5044 struct elf_link_hash_entry
*h
5045 = (struct elf_link_hash_entry
*) *slot
;
5046 struct bfd_link_info
*info
5047 = (struct bfd_link_info
*) inf
;
5049 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5053 /* Used to decide how to sort relocs in an optimal manner for the
5054 dynamic linker, before writing them out. */
5056 static enum elf_reloc_type_class
5057 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5058 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5059 const Elf_Internal_Rela
*rela
)
5061 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5063 case R_X86_64_RELATIVE
:
5064 case R_X86_64_RELATIVE64
:
5065 return reloc_class_relative
;
5066 case R_X86_64_JUMP_SLOT
:
5067 return reloc_class_plt
;
5069 return reloc_class_copy
;
5071 return reloc_class_normal
;
5075 /* Finish up the dynamic sections. */
5078 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
5079 struct bfd_link_info
*info
)
5081 struct elf_x86_64_link_hash_table
*htab
;
5084 const struct elf_x86_64_backend_data
*abed
;
5086 htab
= elf_x86_64_hash_table (info
);
5090 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5091 section only if there is .plt section. */
5092 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
5093 ? &elf_x86_64_bnd_arch_bed
5094 : get_elf_x86_64_backend_data (output_bfd
));
5096 dynobj
= htab
->elf
.dynobj
;
5097 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5099 if (htab
->elf
.dynamic_sections_created
)
5101 bfd_byte
*dyncon
, *dynconend
;
5102 const struct elf_backend_data
*bed
;
5103 bfd_size_type sizeof_dyn
;
5105 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5108 bed
= get_elf_backend_data (dynobj
);
5109 sizeof_dyn
= bed
->s
->sizeof_dyn
;
5110 dyncon
= sdyn
->contents
;
5111 dynconend
= sdyn
->contents
+ sdyn
->size
;
5112 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
5114 Elf_Internal_Dyn dyn
;
5117 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
5125 s
= htab
->elf
.sgotplt
;
5126 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5130 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
5134 s
= htab
->elf
.srelplt
->output_section
;
5135 dyn
.d_un
.d_val
= s
->size
;
5139 /* The procedure linkage table relocs (DT_JMPREL) should
5140 not be included in the overall relocs (DT_RELA).
5141 Therefore, we override the DT_RELASZ entry here to
5142 make it not include the JMPREL relocs. Since the
5143 linker script arranges for .rela.plt to follow all
5144 other relocation sections, we don't have to worry
5145 about changing the DT_RELA entry. */
5146 if (htab
->elf
.srelplt
!= NULL
)
5148 s
= htab
->elf
.srelplt
->output_section
;
5149 dyn
.d_un
.d_val
-= s
->size
;
5153 case DT_TLSDESC_PLT
:
5155 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5156 + htab
->tlsdesc_plt
;
5159 case DT_TLSDESC_GOT
:
5161 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5162 + htab
->tlsdesc_got
;
5166 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
5169 /* Fill in the special first entry in the procedure linkage table. */
5170 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5172 /* Fill in the first entry in the procedure linkage table. */
5173 memcpy (htab
->elf
.splt
->contents
,
5174 abed
->plt0_entry
, abed
->plt_entry_size
);
5175 /* Add offset for pushq GOT+8(%rip), since the instruction
5176 uses 6 bytes subtract this value. */
5177 bfd_put_32 (output_bfd
,
5178 (htab
->elf
.sgotplt
->output_section
->vma
5179 + htab
->elf
.sgotplt
->output_offset
5181 - htab
->elf
.splt
->output_section
->vma
5182 - htab
->elf
.splt
->output_offset
5184 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
5185 /* Add offset for the PC-relative instruction accessing GOT+16,
5186 subtracting the offset to the end of that instruction. */
5187 bfd_put_32 (output_bfd
,
5188 (htab
->elf
.sgotplt
->output_section
->vma
5189 + htab
->elf
.sgotplt
->output_offset
5191 - htab
->elf
.splt
->output_section
->vma
5192 - htab
->elf
.splt
->output_offset
5193 - abed
->plt0_got2_insn_end
),
5194 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
5196 elf_section_data (htab
->elf
.splt
->output_section
)
5197 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
5199 if (htab
->tlsdesc_plt
)
5201 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5202 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
5204 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
5205 abed
->plt0_entry
, abed
->plt_entry_size
);
5207 /* Add offset for pushq GOT+8(%rip), since the
5208 instruction uses 6 bytes subtract this value. */
5209 bfd_put_32 (output_bfd
,
5210 (htab
->elf
.sgotplt
->output_section
->vma
5211 + htab
->elf
.sgotplt
->output_offset
5213 - htab
->elf
.splt
->output_section
->vma
5214 - htab
->elf
.splt
->output_offset
5217 htab
->elf
.splt
->contents
5218 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
5219 /* Add offset for the PC-relative instruction accessing GOT+TDG,
5220 where TGD stands for htab->tlsdesc_got, subtracting the offset
5221 to the end of that instruction. */
5222 bfd_put_32 (output_bfd
,
5223 (htab
->elf
.sgot
->output_section
->vma
5224 + htab
->elf
.sgot
->output_offset
5226 - htab
->elf
.splt
->output_section
->vma
5227 - htab
->elf
.splt
->output_offset
5229 - abed
->plt0_got2_insn_end
),
5230 htab
->elf
.splt
->contents
5231 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
5236 if (htab
->plt_bnd
!= NULL
)
5237 elf_section_data (htab
->plt_bnd
->output_section
)
5238 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
5240 if (htab
->elf
.sgotplt
)
5242 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
5244 (*_bfd_error_handler
)
5245 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
5249 /* Fill in the first three entries in the global offset table. */
5250 if (htab
->elf
.sgotplt
->size
> 0)
5252 /* Set the first entry in the global offset table to the address of
5253 the dynamic section. */
5255 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
5257 bfd_put_64 (output_bfd
,
5258 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
5259 htab
->elf
.sgotplt
->contents
);
5260 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
5261 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
5262 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
5265 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
5269 /* Adjust .eh_frame for .plt section. */
5270 if (htab
->plt_eh_frame
!= NULL
5271 && htab
->plt_eh_frame
->contents
!= NULL
)
5273 if (htab
->elf
.splt
!= NULL
5274 && htab
->elf
.splt
->size
!= 0
5275 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
5276 && htab
->elf
.splt
->output_section
!= NULL
5277 && htab
->plt_eh_frame
->output_section
!= NULL
)
5279 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
5280 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
5281 + htab
->plt_eh_frame
->output_offset
5282 + PLT_FDE_START_OFFSET
;
5283 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5284 htab
->plt_eh_frame
->contents
5285 + PLT_FDE_START_OFFSET
);
5287 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
5289 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5291 htab
->plt_eh_frame
->contents
))
5296 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
5297 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
5300 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5301 htab_traverse (htab
->loc_hash_table
,
5302 elf_x86_64_finish_local_dynamic_symbol
,
5308 /* Return address in section PLT for the Ith GOTPLT relocation, for
5309 relocation REL or (bfd_vma) -1 if it should not be included. */
5312 elf_x86_64_plt_sym_val (bfd_vma i
, const asection
*plt
,
5316 const struct elf_x86_64_backend_data
*bed
;
5319 /* Only match R_X86_64_JUMP_SLOT and R_X86_64_IRELATIVE. */
5320 if (rel
->howto
->type
!= R_X86_64_JUMP_SLOT
5321 && rel
->howto
->type
!= R_X86_64_IRELATIVE
)
5322 return (bfd_vma
) -1;
5325 bed
= get_elf_x86_64_backend_data (abfd
);
5326 plt_offset
= bed
->plt_entry_size
;
5328 if (elf_elfheader (abfd
)->e_ident
[EI_OSABI
] != ELFOSABI_GNU
)
5329 return plt
->vma
+ (i
+ 1) * plt_offset
;
5331 while (plt_offset
< plt
->size
)
5333 bfd_vma reloc_index
;
5334 bfd_byte reloc_index_raw
[4];
5336 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
5338 plt_offset
+ bed
->plt_reloc_offset
,
5339 sizeof (reloc_index_raw
)))
5340 return (bfd_vma
) -1;
5342 reloc_index
= H_GET_32 (abfd
, reloc_index_raw
);
5343 if (reloc_index
== i
)
5344 return plt
->vma
+ plt_offset
;
5345 plt_offset
+= bed
->plt_entry_size
;
5351 /* Return offset in .plt.bnd section for the Ith GOTPLT relocation with
5352 PLT section, or (bfd_vma) -1 if it should not be included. */
5355 elf_x86_64_plt_sym_val_offset_plt_bnd (bfd_vma i
, const asection
*plt
)
5357 const struct elf_x86_64_backend_data
*bed
= &elf_x86_64_bnd_arch_bed
;
5358 bfd
*abfd
= plt
->owner
;
5359 bfd_vma plt_offset
= bed
->plt_entry_size
;
5361 if (elf_elfheader (abfd
)->e_ident
[EI_OSABI
] != ELFOSABI_GNU
)
5362 return i
* sizeof (elf_x86_64_legacy_plt2_entry
);
5364 while (plt_offset
< plt
->size
)
5366 bfd_vma reloc_index
;
5367 bfd_byte reloc_index_raw
[4];
5369 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
5371 plt_offset
+ bed
->plt_reloc_offset
,
5372 sizeof (reloc_index_raw
)))
5373 return (bfd_vma
) -1;
5375 reloc_index
= H_GET_32 (abfd
, reloc_index_raw
);
5376 if (reloc_index
== i
)
5378 /* This is the index in .plt section. */
5379 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
5380 /* Return the offset in .plt.bnd section. */
5381 return (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
);
5383 plt_offset
+= bed
->plt_entry_size
;
5389 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
5393 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
5400 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5403 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
5407 Elf_Internal_Shdr
*hdr
;
5409 asection
*plt
, *plt_push
;
5411 plt_push
= bfd_get_section_by_name (abfd
, ".plt");
5412 if (plt_push
== NULL
)
5415 plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
5416 /* Use the generic ELF version if there is no .plt.bnd section. */
5418 return _bfd_elf_get_synthetic_symtab (abfd
, symcount
, syms
,
5419 dynsymcount
, dynsyms
, ret
);
5423 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
5426 if (dynsymcount
<= 0)
5429 relplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
5433 hdr
= &elf_section_data (relplt
)->this_hdr
;
5434 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
5435 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
5438 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5439 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
5442 count
= relplt
->size
/ hdr
->sh_entsize
;
5443 size
= count
* sizeof (asymbol
);
5444 p
= relplt
->relocation
;
5445 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
5447 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
5449 size
+= sizeof ("+0x") - 1 + 8 + 8;
5452 s
= *ret
= (asymbol
*) bfd_malloc (size
);
5456 names
= (char *) (s
+ count
);
5457 p
= relplt
->relocation
;
5459 for (i
= 0; i
< count
; i
++, p
++)
5464 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
5465 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
5468 offset
= elf_x86_64_plt_sym_val_offset_plt_bnd (i
, plt_push
);
5470 *s
= **p
->sym_ptr_ptr
;
5471 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
5472 we are defining a symbol, ensure one of them is set. */
5473 if ((s
->flags
& BSF_LOCAL
) == 0)
5474 s
->flags
|= BSF_GLOBAL
;
5475 s
->flags
|= BSF_SYNTHETIC
;
5480 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
5481 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
5487 memcpy (names
, "+0x", sizeof ("+0x") - 1);
5488 names
+= sizeof ("+0x") - 1;
5489 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
5490 for (a
= buf
; *a
== '0'; ++a
)
5493 memcpy (names
, a
, len
);
5496 memcpy (names
, "@plt", sizeof ("@plt"));
5497 names
+= sizeof ("@plt");
5504 /* Handle an x86-64 specific section when reading an object file. This
5505 is called when elfcode.h finds a section with an unknown type. */
5508 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
5509 const char *name
, int shindex
)
5511 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
5514 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
5520 /* Hook called by the linker routine which adds symbols from an object
5521 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
5525 elf_x86_64_add_symbol_hook (bfd
*abfd
,
5526 struct bfd_link_info
*info
,
5527 Elf_Internal_Sym
*sym
,
5528 const char **namep ATTRIBUTE_UNUSED
,
5529 flagword
*flagsp ATTRIBUTE_UNUSED
,
5535 switch (sym
->st_shndx
)
5537 case SHN_X86_64_LCOMMON
:
5538 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
5541 lcomm
= bfd_make_section_with_flags (abfd
,
5545 | SEC_LINKER_CREATED
));
5548 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
5551 *valp
= sym
->st_size
;
5555 if ((ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
5556 || ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
)
5557 && (abfd
->flags
& DYNAMIC
) == 0
5558 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
5559 elf_tdata (info
->output_bfd
)->has_gnu_symbols
= TRUE
;
5565 /* Given a BFD section, try to locate the corresponding ELF section
5569 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
5570 asection
*sec
, int *index_return
)
5572 if (sec
== &_bfd_elf_large_com_section
)
5574 *index_return
= SHN_X86_64_LCOMMON
;
5580 /* Process a symbol. */
5583 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
5586 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
5588 switch (elfsym
->internal_elf_sym
.st_shndx
)
5590 case SHN_X86_64_LCOMMON
:
5591 asym
->section
= &_bfd_elf_large_com_section
;
5592 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
5593 /* Common symbol doesn't set BSF_GLOBAL. */
5594 asym
->flags
&= ~BSF_GLOBAL
;
5600 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
5602 return (sym
->st_shndx
== SHN_COMMON
5603 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
5607 elf_x86_64_common_section_index (asection
*sec
)
5609 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5612 return SHN_X86_64_LCOMMON
;
5616 elf_x86_64_common_section (asection
*sec
)
5618 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5619 return bfd_com_section_ptr
;
5621 return &_bfd_elf_large_com_section
;
5625 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
5626 const Elf_Internal_Sym
*sym
,
5631 const asection
*oldsec
)
5633 /* A normal common symbol and a large common symbol result in a
5634 normal common symbol. We turn the large common symbol into a
5637 && h
->root
.type
== bfd_link_hash_common
5639 && bfd_is_com_section (*psec
)
5642 if (sym
->st_shndx
== SHN_COMMON
5643 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
5645 h
->root
.u
.c
.p
->section
5646 = bfd_make_section_old_way (oldbfd
, "COMMON");
5647 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
5649 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
5650 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
5651 *psec
= bfd_com_section_ptr
;
5658 elf_x86_64_additional_program_headers (bfd
*abfd
,
5659 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
5664 /* Check to see if we need a large readonly segment. */
5665 s
= bfd_get_section_by_name (abfd
, ".lrodata");
5666 if (s
&& (s
->flags
& SEC_LOAD
))
5669 /* Check to see if we need a large data segment. Since .lbss sections
5670 is placed right after the .bss section, there should be no need for
5671 a large data segment just because of .lbss. */
5672 s
= bfd_get_section_by_name (abfd
, ".ldata");
5673 if (s
&& (s
->flags
& SEC_LOAD
))
5679 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5682 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
5684 if (h
->plt
.offset
!= (bfd_vma
) -1
5686 && !h
->pointer_equality_needed
)
5689 return _bfd_elf_hash_symbol (h
);
5692 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
5695 elf_x86_64_relocs_compatible (const bfd_target
*input
,
5696 const bfd_target
*output
)
5698 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
5699 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
5700 && _bfd_elf_relocs_compatible (input
, output
));
5703 static const struct bfd_elf_special_section
5704 elf_x86_64_special_sections
[]=
5706 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5707 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5708 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
5709 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5710 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5711 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5712 { NULL
, 0, 0, 0, 0 }
5715 #define TARGET_LITTLE_SYM x86_64_elf64_vec
5716 #define TARGET_LITTLE_NAME "elf64-x86-64"
5717 #define ELF_ARCH bfd_arch_i386
5718 #define ELF_TARGET_ID X86_64_ELF_DATA
5719 #define ELF_MACHINE_CODE EM_X86_64
5720 #define ELF_MAXPAGESIZE 0x200000
5721 #define ELF_MINPAGESIZE 0x1000
5722 #define ELF_COMMONPAGESIZE 0x1000
5724 #define elf_backend_can_gc_sections 1
5725 #define elf_backend_can_refcount 1
5726 #define elf_backend_want_got_plt 1
5727 #define elf_backend_plt_readonly 1
5728 #define elf_backend_want_plt_sym 0
5729 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
5730 #define elf_backend_rela_normal 1
5731 #define elf_backend_plt_alignment 4
5733 #define elf_info_to_howto elf_x86_64_info_to_howto
5735 #define bfd_elf64_bfd_link_hash_table_create \
5736 elf_x86_64_link_hash_table_create
5737 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
5738 #define bfd_elf64_bfd_reloc_name_lookup \
5739 elf_x86_64_reloc_name_lookup
5741 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
5742 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
5743 #define elf_backend_check_relocs elf_x86_64_check_relocs
5744 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
5745 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
5746 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5747 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
5748 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
5749 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
5750 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
5751 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
5753 #define elf_backend_write_core_note elf_x86_64_write_core_note
5755 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
5756 #define elf_backend_relocate_section elf_x86_64_relocate_section
5757 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
5758 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
5759 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5760 #define elf_backend_plt_sym_val elf_x86_64_plt_sym_val
5761 #define elf_backend_object_p elf64_x86_64_elf_object_p
5762 #define bfd_elf64_mkobject elf_x86_64_mkobject
5763 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
5765 #define elf_backend_section_from_shdr \
5766 elf_x86_64_section_from_shdr
5768 #define elf_backend_section_from_bfd_section \
5769 elf_x86_64_elf_section_from_bfd_section
5770 #define elf_backend_add_symbol_hook \
5771 elf_x86_64_add_symbol_hook
5772 #define elf_backend_symbol_processing \
5773 elf_x86_64_symbol_processing
5774 #define elf_backend_common_section_index \
5775 elf_x86_64_common_section_index
5776 #define elf_backend_common_section \
5777 elf_x86_64_common_section
5778 #define elf_backend_common_definition \
5779 elf_x86_64_common_definition
5780 #define elf_backend_merge_symbol \
5781 elf_x86_64_merge_symbol
5782 #define elf_backend_special_sections \
5783 elf_x86_64_special_sections
5784 #define elf_backend_additional_program_headers \
5785 elf_x86_64_additional_program_headers
5786 #define elf_backend_hash_symbol \
5787 elf_x86_64_hash_symbol
5789 #include "elf64-target.h"
5791 /* FreeBSD support. */
5793 #undef TARGET_LITTLE_SYM
5794 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
5795 #undef TARGET_LITTLE_NAME
5796 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
5799 #define ELF_OSABI ELFOSABI_FREEBSD
5802 #define elf64_bed elf64_x86_64_fbsd_bed
5804 #include "elf64-target.h"
5806 /* Solaris 2 support. */
5808 #undef TARGET_LITTLE_SYM
5809 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
5810 #undef TARGET_LITTLE_NAME
5811 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5813 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5814 objects won't be recognized. */
5818 #define elf64_bed elf64_x86_64_sol2_bed
5820 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5822 #undef elf_backend_static_tls_alignment
5823 #define elf_backend_static_tls_alignment 16
5825 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5827 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5829 #undef elf_backend_want_plt_sym
5830 #define elf_backend_want_plt_sym 1
5832 #include "elf64-target.h"
5834 #undef bfd_elf64_get_synthetic_symtab
5836 /* Native Client support. */
5839 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
5841 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
5842 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
5846 #undef TARGET_LITTLE_SYM
5847 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
5848 #undef TARGET_LITTLE_NAME
5849 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
5851 #define elf64_bed elf64_x86_64_nacl_bed
5853 #undef ELF_MAXPAGESIZE
5854 #undef ELF_MINPAGESIZE
5855 #undef ELF_COMMONPAGESIZE
5856 #define ELF_MAXPAGESIZE 0x10000
5857 #define ELF_MINPAGESIZE 0x10000
5858 #define ELF_COMMONPAGESIZE 0x10000
5860 /* Restore defaults. */
5862 #undef elf_backend_static_tls_alignment
5863 #undef elf_backend_want_plt_sym
5864 #define elf_backend_want_plt_sym 0
5866 /* NaCl uses substantially different PLT entries for the same effects. */
5868 #undef elf_backend_plt_alignment
5869 #define elf_backend_plt_alignment 5
5870 #define NACL_PLT_ENTRY_SIZE 64
5871 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
5873 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
5875 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
5876 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
5877 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
5878 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5879 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5881 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
5882 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
5884 /* 32 bytes of nop to pad out to the standard size. */
5885 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5886 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5887 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5888 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5889 0x66, /* excess data32 prefix */
5893 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
5895 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
5896 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
5897 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5898 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5900 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
5901 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5902 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5904 /* Lazy GOT entries point here (32-byte aligned). */
5905 0x68, /* pushq immediate */
5906 0, 0, 0, 0, /* replaced with index into relocation table. */
5907 0xe9, /* jmp relative */
5908 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
5910 /* 22 bytes of nop to pad out to the standard size. */
5911 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5912 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5913 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
5916 /* .eh_frame covering the .plt section. */
5918 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
5920 #if (PLT_CIE_LENGTH != 20 \
5921 || PLT_FDE_LENGTH != 36 \
5922 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
5923 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5924 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
5926 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
5927 0, 0, 0, 0, /* CIE ID */
5928 1, /* CIE version */
5929 'z', 'R', 0, /* Augmentation string */
5930 1, /* Code alignment factor */
5931 0x78, /* Data alignment factor */
5932 16, /* Return address column */
5933 1, /* Augmentation size */
5934 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
5935 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5936 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
5937 DW_CFA_nop
, DW_CFA_nop
,
5939 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
5940 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
5941 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
5942 0, 0, 0, 0, /* .plt size goes here */
5943 0, /* Augmentation size */
5944 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
5945 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5946 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
5947 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5948 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
5949 13, /* Block length */
5950 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
5951 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
5952 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
5953 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
5954 DW_CFA_nop
, DW_CFA_nop
5957 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
5959 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
5960 elf_x86_64_nacl_plt_entry
, /* plt_entry */
5961 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
5962 2, /* plt0_got1_offset */
5963 9, /* plt0_got2_offset */
5964 13, /* plt0_got2_insn_end */
5965 3, /* plt_got_offset */
5966 33, /* plt_reloc_offset */
5967 38, /* plt_plt_offset */
5968 7, /* plt_got_insn_size */
5969 42, /* plt_plt_insn_end */
5970 32, /* plt_lazy_offset */
5971 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
5972 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
5975 #undef elf_backend_arch_data
5976 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
5978 #undef elf_backend_object_p
5979 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
5980 #undef elf_backend_modify_segment_map
5981 #define elf_backend_modify_segment_map nacl_modify_segment_map
5982 #undef elf_backend_modify_program_headers
5983 #define elf_backend_modify_program_headers nacl_modify_program_headers
5984 #undef elf_backend_final_write_processing
5985 #define elf_backend_final_write_processing nacl_final_write_processing
5987 #include "elf64-target.h"
5989 /* Native Client x32 support. */
5992 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
5994 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
5995 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
5999 #undef TARGET_LITTLE_SYM
6000 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6001 #undef TARGET_LITTLE_NAME
6002 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6004 #define elf32_bed elf32_x86_64_nacl_bed
6006 #define bfd_elf32_bfd_link_hash_table_create \
6007 elf_x86_64_link_hash_table_create
6008 #define bfd_elf32_bfd_reloc_type_lookup \
6009 elf_x86_64_reloc_type_lookup
6010 #define bfd_elf32_bfd_reloc_name_lookup \
6011 elf_x86_64_reloc_name_lookup
6012 #define bfd_elf32_mkobject \
6015 #undef elf_backend_object_p
6016 #define elf_backend_object_p \
6017 elf32_x86_64_nacl_elf_object_p
6019 #undef elf_backend_bfd_from_remote_memory
6020 #define elf_backend_bfd_from_remote_memory \
6021 _bfd_elf32_bfd_from_remote_memory
6023 #undef elf_backend_size_info
6024 #define elf_backend_size_info \
6025 _bfd_elf32_size_info
6027 #include "elf32-target.h"
6029 /* Restore defaults. */
6030 #undef elf_backend_object_p
6031 #define elf_backend_object_p elf64_x86_64_elf_object_p
6032 #undef elf_backend_bfd_from_remote_memory
6033 #undef elf_backend_size_info
6034 #undef elf_backend_modify_segment_map
6035 #undef elf_backend_modify_program_headers
6036 #undef elf_backend_final_write_processing
6038 /* Intel L1OM support. */
6041 elf64_l1om_elf_object_p (bfd
*abfd
)
6043 /* Set the right machine number for an L1OM elf64 file. */
6044 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6048 #undef TARGET_LITTLE_SYM
6049 #define TARGET_LITTLE_SYM l1om_elf64_vec
6050 #undef TARGET_LITTLE_NAME
6051 #define TARGET_LITTLE_NAME "elf64-l1om"
6053 #define ELF_ARCH bfd_arch_l1om
6055 #undef ELF_MACHINE_CODE
6056 #define ELF_MACHINE_CODE EM_L1OM
6061 #define elf64_bed elf64_l1om_bed
6063 #undef elf_backend_object_p
6064 #define elf_backend_object_p elf64_l1om_elf_object_p
6066 /* Restore defaults. */
6067 #undef ELF_MAXPAGESIZE
6068 #undef ELF_MINPAGESIZE
6069 #undef ELF_COMMONPAGESIZE
6070 #define ELF_MAXPAGESIZE 0x200000
6071 #define ELF_MINPAGESIZE 0x1000
6072 #define ELF_COMMONPAGESIZE 0x1000
6073 #undef elf_backend_plt_alignment
6074 #define elf_backend_plt_alignment 4
6075 #undef elf_backend_arch_data
6076 #define elf_backend_arch_data &elf_x86_64_arch_bed
6078 #include "elf64-target.h"
6080 /* FreeBSD L1OM support. */
6082 #undef TARGET_LITTLE_SYM
6083 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6084 #undef TARGET_LITTLE_NAME
6085 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6088 #define ELF_OSABI ELFOSABI_FREEBSD
6091 #define elf64_bed elf64_l1om_fbsd_bed
6093 #include "elf64-target.h"
6095 /* Intel K1OM support. */
6098 elf64_k1om_elf_object_p (bfd
*abfd
)
6100 /* Set the right machine number for an K1OM elf64 file. */
6101 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
6105 #undef TARGET_LITTLE_SYM
6106 #define TARGET_LITTLE_SYM k1om_elf64_vec
6107 #undef TARGET_LITTLE_NAME
6108 #define TARGET_LITTLE_NAME "elf64-k1om"
6110 #define ELF_ARCH bfd_arch_k1om
6112 #undef ELF_MACHINE_CODE
6113 #define ELF_MACHINE_CODE EM_K1OM
6118 #define elf64_bed elf64_k1om_bed
6120 #undef elf_backend_object_p
6121 #define elf_backend_object_p elf64_k1om_elf_object_p
6123 #undef elf_backend_static_tls_alignment
6125 #undef elf_backend_want_plt_sym
6126 #define elf_backend_want_plt_sym 0
6128 #include "elf64-target.h"
6130 /* FreeBSD K1OM support. */
6132 #undef TARGET_LITTLE_SYM
6133 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
6134 #undef TARGET_LITTLE_NAME
6135 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
6138 #define ELF_OSABI ELFOSABI_FREEBSD
6141 #define elf64_bed elf64_k1om_fbsd_bed
6143 #include "elf64-target.h"
6145 /* 32bit x86-64 support. */
6147 #undef TARGET_LITTLE_SYM
6148 #define TARGET_LITTLE_SYM x86_64_elf32_vec
6149 #undef TARGET_LITTLE_NAME
6150 #define TARGET_LITTLE_NAME "elf32-x86-64"
6154 #define ELF_ARCH bfd_arch_i386
6156 #undef ELF_MACHINE_CODE
6157 #define ELF_MACHINE_CODE EM_X86_64
6161 #undef elf_backend_object_p
6162 #define elf_backend_object_p \
6163 elf32_x86_64_elf_object_p
6165 #undef elf_backend_bfd_from_remote_memory
6166 #define elf_backend_bfd_from_remote_memory \
6167 _bfd_elf32_bfd_from_remote_memory
6169 #undef elf_backend_size_info
6170 #define elf_backend_size_info \
6171 _bfd_elf32_size_info
6173 #include "elf32-target.h"