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 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
) == 8
1653 && (sizeof (elf_x86_64_bnd_plt2_entry
)
1654 == sizeof (elf_x86_64_legacy_plt2_entry
)));
1657 if (htab
->elf
.dynobj
== NULL
)
1658 htab
->elf
.dynobj
= abfd
;
1660 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
1662 (bed
->dynamic_sec_flags
1667 if (htab
->plt_bnd
== NULL
1668 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
1677 case R_X86_64_GOTPCREL
:
1678 case R_X86_64_GOTPCREL64
:
1679 if (htab
->elf
.dynobj
== NULL
)
1680 htab
->elf
.dynobj
= abfd
;
1681 if (!_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
1686 /* It is referenced by a non-shared object. */
1688 h
->root
.non_ir_ref
= 1;
1691 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1692 symtab_hdr
, sym_hashes
,
1693 &r_type
, GOT_UNKNOWN
,
1694 rel
, rel_end
, h
, r_symndx
))
1699 case R_X86_64_TLSLD
:
1700 htab
->tls_ld_got
.refcount
+= 1;
1703 case R_X86_64_TPOFF32
:
1704 if (!info
->executable
&& ABI_64_P (abfd
))
1707 name
= h
->root
.root
.string
;
1709 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1711 (*_bfd_error_handler
)
1712 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1714 x86_64_elf_howto_table
[r_type
].name
, name
);
1715 bfd_set_error (bfd_error_bad_value
);
1720 case R_X86_64_GOTTPOFF
:
1721 if (!info
->executable
)
1722 info
->flags
|= DF_STATIC_TLS
;
1725 case R_X86_64_GOT32
:
1726 case R_X86_64_GOTPCREL
:
1727 case R_X86_64_TLSGD
:
1728 case R_X86_64_GOT64
:
1729 case R_X86_64_GOTPCREL64
:
1730 case R_X86_64_GOTPLT64
:
1731 case R_X86_64_GOTPC32_TLSDESC
:
1732 case R_X86_64_TLSDESC_CALL
:
1733 /* This symbol requires a global offset table entry. */
1735 int tls_type
, old_tls_type
;
1739 default: tls_type
= GOT_NORMAL
; break;
1740 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1741 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1742 case R_X86_64_GOTPC32_TLSDESC
:
1743 case R_X86_64_TLSDESC_CALL
:
1744 tls_type
= GOT_TLS_GDESC
; break;
1749 h
->got
.refcount
+= 1;
1750 old_tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
1754 bfd_signed_vma
*local_got_refcounts
;
1756 /* This is a global offset table entry for a local symbol. */
1757 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1758 if (local_got_refcounts
== NULL
)
1762 size
= symtab_hdr
->sh_info
;
1763 size
*= sizeof (bfd_signed_vma
)
1764 + sizeof (bfd_vma
) + sizeof (char);
1765 local_got_refcounts
= ((bfd_signed_vma
*)
1766 bfd_zalloc (abfd
, size
));
1767 if (local_got_refcounts
== NULL
)
1769 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1770 elf_x86_64_local_tlsdesc_gotent (abfd
)
1771 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1772 elf_x86_64_local_got_tls_type (abfd
)
1773 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1775 local_got_refcounts
[r_symndx
] += 1;
1777 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1780 /* If a TLS symbol is accessed using IE at least once,
1781 there is no point to use dynamic model for it. */
1782 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1783 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1784 || tls_type
!= GOT_TLS_IE
))
1786 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1787 tls_type
= old_tls_type
;
1788 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1789 && GOT_TLS_GD_ANY_P (tls_type
))
1790 tls_type
|= old_tls_type
;
1794 name
= h
->root
.root
.string
;
1796 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1798 (*_bfd_error_handler
)
1799 (_("%B: '%s' accessed both as normal and thread local symbol"),
1801 bfd_set_error (bfd_error_bad_value
);
1806 if (old_tls_type
!= tls_type
)
1809 elf_x86_64_hash_entry (h
)->tls_type
= tls_type
;
1811 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1816 case R_X86_64_GOTOFF64
:
1817 case R_X86_64_GOTPC32
:
1818 case R_X86_64_GOTPC64
:
1820 if (htab
->elf
.sgot
== NULL
)
1822 if (htab
->elf
.dynobj
== NULL
)
1823 htab
->elf
.dynobj
= abfd
;
1824 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1830 case R_X86_64_PLT32
:
1831 case R_X86_64_PLT32_BND
:
1832 /* This symbol requires a procedure linkage table entry. We
1833 actually build the entry in adjust_dynamic_symbol,
1834 because this might be a case of linking PIC code which is
1835 never referenced by a dynamic object, in which case we
1836 don't need to generate a procedure linkage table entry
1839 /* If this is a local symbol, we resolve it directly without
1840 creating a procedure linkage table entry. */
1845 h
->plt
.refcount
+= 1;
1848 case R_X86_64_PLTOFF64
:
1849 /* This tries to form the 'address' of a function relative
1850 to GOT. For global symbols we need a PLT entry. */
1854 h
->plt
.refcount
+= 1;
1858 case R_X86_64_SIZE32
:
1859 case R_X86_64_SIZE64
:
1864 if (!ABI_64_P (abfd
))
1869 /* Let's help debug shared library creation. These relocs
1870 cannot be used in shared libs. Don't error out for
1871 sections we don't care about, such as debug sections or
1872 non-constant sections. */
1874 && (sec
->flags
& SEC_ALLOC
) != 0
1875 && (sec
->flags
& SEC_READONLY
) != 0)
1878 name
= h
->root
.root
.string
;
1880 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1881 (*_bfd_error_handler
)
1882 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1883 abfd
, x86_64_elf_howto_table
[r_type
].name
, name
);
1884 bfd_set_error (bfd_error_bad_value
);
1892 case R_X86_64_PC32_BND
:
1896 if (h
!= NULL
&& info
->executable
)
1898 /* If this reloc is in a read-only section, we might
1899 need a copy reloc. We can't check reliably at this
1900 stage whether the section is read-only, as input
1901 sections have not yet been mapped to output sections.
1902 Tentatively set the flag for now, and correct in
1903 adjust_dynamic_symbol. */
1906 /* We may need a .plt entry if the function this reloc
1907 refers to is in a shared lib. */
1908 h
->plt
.refcount
+= 1;
1909 if (r_type
!= R_X86_64_PC32
1910 && r_type
!= R_X86_64_PC32_BND
1911 && r_type
!= R_X86_64_PC64
)
1912 h
->pointer_equality_needed
= 1;
1917 /* If we are creating a shared library, and this is a reloc
1918 against a global symbol, or a non PC relative reloc
1919 against a local symbol, then we need to copy the reloc
1920 into the shared library. However, if we are linking with
1921 -Bsymbolic, we do not need to copy a reloc against a
1922 global symbol which is defined in an object we are
1923 including in the link (i.e., DEF_REGULAR is set). At
1924 this point we have not seen all the input files, so it is
1925 possible that DEF_REGULAR is not set now but will be set
1926 later (it is never cleared). In case of a weak definition,
1927 DEF_REGULAR may be cleared later by a strong definition in
1928 a shared library. We account for that possibility below by
1929 storing information in the relocs_copied field of the hash
1930 table entry. A similar situation occurs when creating
1931 shared libraries and symbol visibility changes render the
1934 If on the other hand, we are creating an executable, we
1935 may need to keep relocations for symbols satisfied by a
1936 dynamic library if we manage to avoid copy relocs for the
1939 && (sec
->flags
& SEC_ALLOC
) != 0
1940 && (! IS_X86_64_PCREL_TYPE (r_type
)
1942 && (! SYMBOLIC_BIND (info
, h
)
1943 || h
->root
.type
== bfd_link_hash_defweak
1944 || !h
->def_regular
))))
1945 || (ELIMINATE_COPY_RELOCS
1947 && (sec
->flags
& SEC_ALLOC
) != 0
1949 && (h
->root
.type
== bfd_link_hash_defweak
1950 || !h
->def_regular
)))
1952 struct elf_dyn_relocs
*p
;
1953 struct elf_dyn_relocs
**head
;
1955 /* We must copy these reloc types into the output file.
1956 Create a reloc section in dynobj and make room for
1960 if (htab
->elf
.dynobj
== NULL
)
1961 htab
->elf
.dynobj
= abfd
;
1963 sreloc
= _bfd_elf_make_dynamic_reloc_section
1964 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
1965 abfd
, /*rela?*/ TRUE
);
1971 /* If this is a global symbol, we count the number of
1972 relocations we need for this symbol. */
1975 head
= &((struct elf_x86_64_link_hash_entry
*) h
)->dyn_relocs
;
1979 /* Track dynamic relocs needed for local syms too.
1980 We really need local syms available to do this
1985 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1990 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1994 /* Beware of type punned pointers vs strict aliasing
1996 vpp
= &(elf_section_data (s
)->local_dynrel
);
1997 head
= (struct elf_dyn_relocs
**)vpp
;
2001 if (p
== NULL
|| p
->sec
!= sec
)
2003 bfd_size_type amt
= sizeof *p
;
2005 p
= ((struct elf_dyn_relocs
*)
2006 bfd_alloc (htab
->elf
.dynobj
, amt
));
2017 /* Count size relocation as PC-relative relocation. */
2018 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2023 /* This relocation describes the C++ object vtable hierarchy.
2024 Reconstruct it for later use during GC. */
2025 case R_X86_64_GNU_VTINHERIT
:
2026 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2030 /* This relocation describes which C++ vtable entries are actually
2031 used. Record for later use during GC. */
2032 case R_X86_64_GNU_VTENTRY
:
2033 BFD_ASSERT (h
!= NULL
);
2035 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2047 /* Return the section that should be marked against GC for a given
2051 elf_x86_64_gc_mark_hook (asection
*sec
,
2052 struct bfd_link_info
*info
,
2053 Elf_Internal_Rela
*rel
,
2054 struct elf_link_hash_entry
*h
,
2055 Elf_Internal_Sym
*sym
)
2058 switch (ELF32_R_TYPE (rel
->r_info
))
2060 case R_X86_64_GNU_VTINHERIT
:
2061 case R_X86_64_GNU_VTENTRY
:
2065 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2068 /* Update the got entry reference counts for the section being removed. */
2071 elf_x86_64_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
2073 const Elf_Internal_Rela
*relocs
)
2075 struct elf_x86_64_link_hash_table
*htab
;
2076 Elf_Internal_Shdr
*symtab_hdr
;
2077 struct elf_link_hash_entry
**sym_hashes
;
2078 bfd_signed_vma
*local_got_refcounts
;
2079 const Elf_Internal_Rela
*rel
, *relend
;
2081 if (info
->relocatable
)
2084 htab
= elf_x86_64_hash_table (info
);
2088 elf_section_data (sec
)->local_dynrel
= NULL
;
2090 symtab_hdr
= &elf_symtab_hdr (abfd
);
2091 sym_hashes
= elf_sym_hashes (abfd
);
2092 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2094 htab
= elf_x86_64_hash_table (info
);
2095 relend
= relocs
+ sec
->reloc_count
;
2096 for (rel
= relocs
; rel
< relend
; rel
++)
2098 unsigned long r_symndx
;
2099 unsigned int r_type
;
2100 struct elf_link_hash_entry
*h
= NULL
;
2102 r_symndx
= htab
->r_sym (rel
->r_info
);
2103 if (r_symndx
>= symtab_hdr
->sh_info
)
2105 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2106 while (h
->root
.type
== bfd_link_hash_indirect
2107 || h
->root
.type
== bfd_link_hash_warning
)
2108 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2112 /* A local symbol. */
2113 Elf_Internal_Sym
*isym
;
2115 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2118 /* Check relocation against local STT_GNU_IFUNC symbol. */
2120 && ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2122 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
, FALSE
);
2130 struct elf_x86_64_link_hash_entry
*eh
;
2131 struct elf_dyn_relocs
**pp
;
2132 struct elf_dyn_relocs
*p
;
2134 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2136 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
2139 /* Everything must go for SEC. */
2145 r_type
= ELF32_R_TYPE (rel
->r_info
);
2146 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
2147 symtab_hdr
, sym_hashes
,
2148 &r_type
, GOT_UNKNOWN
,
2149 rel
, relend
, h
, r_symndx
))
2154 case R_X86_64_TLSLD
:
2155 if (htab
->tls_ld_got
.refcount
> 0)
2156 htab
->tls_ld_got
.refcount
-= 1;
2159 case R_X86_64_TLSGD
:
2160 case R_X86_64_GOTPC32_TLSDESC
:
2161 case R_X86_64_TLSDESC_CALL
:
2162 case R_X86_64_GOTTPOFF
:
2163 case R_X86_64_GOT32
:
2164 case R_X86_64_GOTPCREL
:
2165 case R_X86_64_GOT64
:
2166 case R_X86_64_GOTPCREL64
:
2167 case R_X86_64_GOTPLT64
:
2170 if (h
->got
.refcount
> 0)
2171 h
->got
.refcount
-= 1;
2172 if (h
->type
== STT_GNU_IFUNC
)
2174 if (h
->plt
.refcount
> 0)
2175 h
->plt
.refcount
-= 1;
2178 else if (local_got_refcounts
!= NULL
)
2180 if (local_got_refcounts
[r_symndx
] > 0)
2181 local_got_refcounts
[r_symndx
] -= 1;
2193 case R_X86_64_PC32_BND
:
2195 case R_X86_64_SIZE32
:
2196 case R_X86_64_SIZE64
:
2198 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2202 case R_X86_64_PLT32
:
2203 case R_X86_64_PLT32_BND
:
2204 case R_X86_64_PLTOFF64
:
2207 if (h
->plt
.refcount
> 0)
2208 h
->plt
.refcount
-= 1;
2220 /* Adjust a symbol defined by a dynamic object and referenced by a
2221 regular object. The current definition is in some section of the
2222 dynamic object, but we're not including those sections. We have to
2223 change the definition to something the rest of the link can
2227 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2228 struct elf_link_hash_entry
*h
)
2230 struct elf_x86_64_link_hash_table
*htab
;
2232 struct elf_x86_64_link_hash_entry
*eh
;
2233 struct elf_dyn_relocs
*p
;
2235 /* STT_GNU_IFUNC symbol must go through PLT. */
2236 if (h
->type
== STT_GNU_IFUNC
)
2238 /* All local STT_GNU_IFUNC references must be treate as local
2239 calls via local PLT. */
2241 && SYMBOL_CALLS_LOCAL (info
, h
))
2243 bfd_size_type pc_count
= 0, count
= 0;
2244 struct elf_dyn_relocs
**pp
;
2246 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2247 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2249 pc_count
+= p
->pc_count
;
2250 p
->count
-= p
->pc_count
;
2259 if (pc_count
|| count
)
2263 if (h
->plt
.refcount
<= 0)
2264 h
->plt
.refcount
= 1;
2266 h
->plt
.refcount
+= 1;
2270 if (h
->plt
.refcount
<= 0)
2272 h
->plt
.offset
= (bfd_vma
) -1;
2278 /* If this is a function, put it in the procedure linkage table. We
2279 will fill in the contents of the procedure linkage table later,
2280 when we know the address of the .got section. */
2281 if (h
->type
== STT_FUNC
2284 if (h
->plt
.refcount
<= 0
2285 || SYMBOL_CALLS_LOCAL (info
, h
)
2286 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2287 && h
->root
.type
== bfd_link_hash_undefweak
))
2289 /* This case can occur if we saw a PLT32 reloc in an input
2290 file, but the symbol was never referred to by a dynamic
2291 object, or if all references were garbage collected. In
2292 such a case, we don't actually need to build a procedure
2293 linkage table, and we can just do a PC32 reloc instead. */
2294 h
->plt
.offset
= (bfd_vma
) -1;
2301 /* It's possible that we incorrectly decided a .plt reloc was
2302 needed for an R_X86_64_PC32 reloc to a non-function sym in
2303 check_relocs. We can't decide accurately between function and
2304 non-function syms in check-relocs; Objects loaded later in
2305 the link may change h->type. So fix it now. */
2306 h
->plt
.offset
= (bfd_vma
) -1;
2308 /* If this is a weak symbol, and there is a real definition, the
2309 processor independent code will have arranged for us to see the
2310 real definition first, and we can just use the same value. */
2311 if (h
->u
.weakdef
!= NULL
)
2313 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2314 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2315 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2316 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2317 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2318 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2322 /* This is a reference to a symbol defined by a dynamic object which
2323 is not a function. */
2325 /* If we are creating a shared library, we must presume that the
2326 only references to the symbol are via the global offset table.
2327 For such cases we need not do anything here; the relocations will
2328 be handled correctly by relocate_section. */
2332 /* If there are no references to this symbol that do not use the
2333 GOT, we don't need to generate a copy reloc. */
2334 if (!h
->non_got_ref
)
2337 /* If -z nocopyreloc was given, we won't generate them either. */
2338 if (info
->nocopyreloc
)
2344 if (ELIMINATE_COPY_RELOCS
)
2346 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2347 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2349 s
= p
->sec
->output_section
;
2350 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2354 /* If we didn't find any dynamic relocs in read-only sections, then
2355 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2363 /* We must allocate the symbol in our .dynbss section, which will
2364 become part of the .bss section of the executable. There will be
2365 an entry for this symbol in the .dynsym section. The dynamic
2366 object will contain position independent code, so all references
2367 from the dynamic object to this symbol will go through the global
2368 offset table. The dynamic linker will use the .dynsym entry to
2369 determine the address it must put in the global offset table, so
2370 both the dynamic object and the regular object will refer to the
2371 same memory location for the variable. */
2373 htab
= elf_x86_64_hash_table (info
);
2377 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2378 to copy the initial value out of the dynamic object and into the
2379 runtime process image. */
2380 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2382 const struct elf_backend_data
*bed
;
2383 bed
= get_elf_backend_data (info
->output_bfd
);
2384 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2390 return _bfd_elf_adjust_dynamic_copy (h
, s
);
2393 /* Allocate space in .plt, .got and associated reloc sections for
2397 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2399 struct bfd_link_info
*info
;
2400 struct elf_x86_64_link_hash_table
*htab
;
2401 struct elf_x86_64_link_hash_entry
*eh
;
2402 struct elf_dyn_relocs
*p
;
2403 const struct elf_backend_data
*bed
;
2404 unsigned int plt_entry_size
;
2406 if (h
->root
.type
== bfd_link_hash_indirect
)
2409 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2411 info
= (struct bfd_link_info
*) inf
;
2412 htab
= elf_x86_64_hash_table (info
);
2415 bed
= get_elf_backend_data (info
->output_bfd
);
2416 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2418 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2419 here if it is defined and referenced in a non-shared object. */
2420 if (h
->type
== STT_GNU_IFUNC
2423 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2429 asection
*s
= htab
->plt_bnd
;
2430 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
2432 /* Use the .plt.bnd section if it is created. */
2433 eh
->plt_bnd
.offset
= s
->size
;
2435 /* Make room for this entry in the .plt.bnd section. */
2436 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2444 else if (htab
->elf
.dynamic_sections_created
2445 && h
->plt
.refcount
> 0)
2447 /* Make sure this symbol is output as a dynamic symbol.
2448 Undefined weak syms won't yet be marked as dynamic. */
2449 if (h
->dynindx
== -1
2450 && !h
->forced_local
)
2452 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2457 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2459 asection
*s
= htab
->elf
.splt
;
2460 asection
*bnd_s
= htab
->plt_bnd
;
2462 /* If this is the first .plt entry, make room for the special
2465 s
->size
= plt_entry_size
;
2467 h
->plt
.offset
= s
->size
;
2469 eh
->plt_bnd
.offset
= bnd_s
->size
;
2471 /* If this symbol is not defined in a regular file, and we are
2472 not generating a shared library, then set the symbol to this
2473 location in the .plt. This is required to make function
2474 pointers compare as equal between the normal executable and
2475 the shared library. */
2481 /* We need to make a call to the entry of the second
2482 PLT instead of regular PLT entry. */
2483 h
->root
.u
.def
.section
= bnd_s
;
2484 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
2488 h
->root
.u
.def
.section
= s
;
2489 h
->root
.u
.def
.value
= h
->plt
.offset
;
2493 /* Make room for this entry. */
2494 s
->size
+= plt_entry_size
;
2496 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2498 /* We also need to make an entry in the .got.plt section, which
2499 will be placed in the .got section by the linker script. */
2500 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2502 /* We also need to make an entry in the .rela.plt section. */
2503 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2504 htab
->elf
.srelplt
->reloc_count
++;
2508 h
->plt
.offset
= (bfd_vma
) -1;
2514 h
->plt
.offset
= (bfd_vma
) -1;
2518 eh
->tlsdesc_got
= (bfd_vma
) -1;
2520 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2521 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2522 if (h
->got
.refcount
> 0
2525 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2527 h
->got
.offset
= (bfd_vma
) -1;
2529 else if (h
->got
.refcount
> 0)
2533 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2535 /* Make sure this symbol is output as a dynamic symbol.
2536 Undefined weak syms won't yet be marked as dynamic. */
2537 if (h
->dynindx
== -1
2538 && !h
->forced_local
)
2540 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2544 if (GOT_TLS_GDESC_P (tls_type
))
2546 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2547 - elf_x86_64_compute_jump_table_size (htab
);
2548 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2549 h
->got
.offset
= (bfd_vma
) -2;
2551 if (! GOT_TLS_GDESC_P (tls_type
)
2552 || GOT_TLS_GD_P (tls_type
))
2555 h
->got
.offset
= s
->size
;
2556 s
->size
+= GOT_ENTRY_SIZE
;
2557 if (GOT_TLS_GD_P (tls_type
))
2558 s
->size
+= GOT_ENTRY_SIZE
;
2560 dyn
= htab
->elf
.dynamic_sections_created
;
2561 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2563 R_X86_64_GOTTPOFF needs one dynamic relocation. */
2564 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2565 || tls_type
== GOT_TLS_IE
)
2566 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2567 else if (GOT_TLS_GD_P (tls_type
))
2568 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2569 else if (! GOT_TLS_GDESC_P (tls_type
)
2570 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2571 || h
->root
.type
!= bfd_link_hash_undefweak
)
2573 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2574 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2575 if (GOT_TLS_GDESC_P (tls_type
))
2577 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2578 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2582 h
->got
.offset
= (bfd_vma
) -1;
2584 if (eh
->dyn_relocs
== NULL
)
2587 /* In the shared -Bsymbolic case, discard space allocated for
2588 dynamic pc-relative relocs against symbols which turn out to be
2589 defined in regular objects. For the normal shared case, discard
2590 space for pc-relative relocs that have become local due to symbol
2591 visibility changes. */
2595 /* Relocs that use pc_count are those that appear on a call
2596 insn, or certain REL relocs that can generated via assembly.
2597 We want calls to protected symbols to resolve directly to the
2598 function rather than going via the plt. If people want
2599 function pointer comparisons to work as expected then they
2600 should avoid writing weird assembly. */
2601 if (SYMBOL_CALLS_LOCAL (info
, h
))
2603 struct elf_dyn_relocs
**pp
;
2605 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2607 p
->count
-= p
->pc_count
;
2616 /* Also discard relocs on undefined weak syms with non-default
2618 if (eh
->dyn_relocs
!= NULL
2619 && h
->root
.type
== bfd_link_hash_undefweak
)
2621 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2622 eh
->dyn_relocs
= NULL
;
2624 /* Make sure undefined weak symbols are output as a dynamic
2626 else if (h
->dynindx
== -1
2627 && ! h
->forced_local
2628 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2633 else if (ELIMINATE_COPY_RELOCS
)
2635 /* For the non-shared case, discard space for relocs against
2636 symbols which turn out to need copy relocs or are not
2642 || (htab
->elf
.dynamic_sections_created
2643 && (h
->root
.type
== bfd_link_hash_undefweak
2644 || h
->root
.type
== bfd_link_hash_undefined
))))
2646 /* Make sure this symbol is output as a dynamic symbol.
2647 Undefined weak syms won't yet be marked as dynamic. */
2648 if (h
->dynindx
== -1
2649 && ! h
->forced_local
2650 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2653 /* If that succeeded, we know we'll be keeping all the
2655 if (h
->dynindx
!= -1)
2659 eh
->dyn_relocs
= NULL
;
2664 /* Finally, allocate space. */
2665 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2669 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2671 BFD_ASSERT (sreloc
!= NULL
);
2673 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2679 /* Allocate space in .plt, .got and associated reloc sections for
2680 local dynamic relocs. */
2683 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
2685 struct elf_link_hash_entry
*h
2686 = (struct elf_link_hash_entry
*) *slot
;
2688 if (h
->type
!= STT_GNU_IFUNC
2692 || h
->root
.type
!= bfd_link_hash_defined
)
2695 return elf_x86_64_allocate_dynrelocs (h
, inf
);
2698 /* Find any dynamic relocs that apply to read-only sections. */
2701 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
2704 struct elf_x86_64_link_hash_entry
*eh
;
2705 struct elf_dyn_relocs
*p
;
2707 /* Skip local IFUNC symbols. */
2708 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2711 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2712 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2714 asection
*s
= p
->sec
->output_section
;
2716 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2718 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2720 info
->flags
|= DF_TEXTREL
;
2722 if (info
->warn_shared_textrel
&& info
->shared
)
2723 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2724 p
->sec
->owner
, h
->root
.root
.string
,
2727 /* Not an error, just cut short the traversal. */
2735 mov foo@GOTPCREL(%rip), %reg
2738 with the local symbol, foo. */
2741 elf_x86_64_convert_mov_to_lea (bfd
*abfd
, asection
*sec
,
2742 struct bfd_link_info
*link_info
)
2744 Elf_Internal_Shdr
*symtab_hdr
;
2745 Elf_Internal_Rela
*internal_relocs
;
2746 Elf_Internal_Rela
*irel
, *irelend
;
2748 struct elf_x86_64_link_hash_table
*htab
;
2749 bfd_boolean changed_contents
;
2750 bfd_boolean changed_relocs
;
2751 bfd_signed_vma
*local_got_refcounts
;
2753 /* Don't even try to convert non-ELF outputs. */
2754 if (!is_elf_hash_table (link_info
->hash
))
2757 /* Nothing to do if there are no codes, no relocations or no output. */
2758 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
2759 || sec
->reloc_count
== 0
2760 || bfd_is_abs_section (sec
->output_section
))
2763 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2765 /* Load the relocations for this section. */
2766 internal_relocs
= (_bfd_elf_link_read_relocs
2767 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2768 link_info
->keep_memory
));
2769 if (internal_relocs
== NULL
)
2772 htab
= elf_x86_64_hash_table (link_info
);
2773 changed_contents
= FALSE
;
2774 changed_relocs
= FALSE
;
2775 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2777 /* Get the section contents. */
2778 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2779 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2782 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2786 irelend
= internal_relocs
+ sec
->reloc_count
;
2787 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2789 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
2790 unsigned int r_symndx
= htab
->r_sym (irel
->r_info
);
2792 struct elf_link_hash_entry
*h
;
2794 if (r_type
!= R_X86_64_GOTPCREL
)
2797 /* Get the symbol referred to by the reloc. */
2798 if (r_symndx
< symtab_hdr
->sh_info
)
2800 Elf_Internal_Sym
*isym
;
2802 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2805 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. */
2806 if (ELF_ST_TYPE (isym
->st_info
) != STT_GNU_IFUNC
2807 && irel
->r_offset
>= 2
2808 && bfd_get_8 (input_bfd
,
2809 contents
+ irel
->r_offset
- 2) == 0x8b)
2811 bfd_put_8 (output_bfd
, 0x8d,
2812 contents
+ irel
->r_offset
- 2);
2813 irel
->r_info
= htab
->r_info (r_symndx
, R_X86_64_PC32
);
2814 if (local_got_refcounts
!= NULL
2815 && local_got_refcounts
[r_symndx
] > 0)
2816 local_got_refcounts
[r_symndx
] -= 1;
2817 changed_contents
= TRUE
;
2818 changed_relocs
= TRUE
;
2823 indx
= r_symndx
- symtab_hdr
->sh_info
;
2824 h
= elf_sym_hashes (abfd
)[indx
];
2825 BFD_ASSERT (h
!= NULL
);
2827 while (h
->root
.type
== bfd_link_hash_indirect
2828 || h
->root
.type
== bfd_link_hash_warning
)
2829 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2831 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. We also
2832 avoid optimizing _DYNAMIC since ld.so may use its link-time
2835 && h
->type
!= STT_GNU_IFUNC
2836 && h
!= htab
->elf
.hdynamic
2837 && SYMBOL_REFERENCES_LOCAL (link_info
, h
)
2838 && irel
->r_offset
>= 2
2839 && bfd_get_8 (input_bfd
,
2840 contents
+ irel
->r_offset
- 2) == 0x8b)
2842 bfd_put_8 (output_bfd
, 0x8d,
2843 contents
+ irel
->r_offset
- 2);
2844 irel
->r_info
= htab
->r_info (r_symndx
, R_X86_64_PC32
);
2845 if (h
->got
.refcount
> 0)
2846 h
->got
.refcount
-= 1;
2847 changed_contents
= TRUE
;
2848 changed_relocs
= TRUE
;
2852 if (contents
!= NULL
2853 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2855 if (!changed_contents
&& !link_info
->keep_memory
)
2859 /* Cache the section contents for elf_link_input_bfd. */
2860 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2864 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
2866 if (!changed_relocs
)
2867 free (internal_relocs
);
2869 elf_section_data (sec
)->relocs
= internal_relocs
;
2875 if (contents
!= NULL
2876 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2878 if (internal_relocs
!= NULL
2879 && elf_section_data (sec
)->relocs
!= internal_relocs
)
2880 free (internal_relocs
);
2884 /* Set the sizes of the dynamic sections. */
2887 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
2888 struct bfd_link_info
*info
)
2890 struct elf_x86_64_link_hash_table
*htab
;
2895 const struct elf_backend_data
*bed
;
2897 htab
= elf_x86_64_hash_table (info
);
2900 bed
= get_elf_backend_data (output_bfd
);
2902 dynobj
= htab
->elf
.dynobj
;
2906 if (htab
->elf
.dynamic_sections_created
)
2908 /* Set the contents of the .interp section to the interpreter. */
2909 if (info
->executable
)
2911 s
= bfd_get_linker_section (dynobj
, ".interp");
2914 s
->size
= htab
->dynamic_interpreter_size
;
2915 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2919 /* Set up .got offsets for local syms, and space for local dynamic
2921 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2923 bfd_signed_vma
*local_got
;
2924 bfd_signed_vma
*end_local_got
;
2925 char *local_tls_type
;
2926 bfd_vma
*local_tlsdesc_gotent
;
2927 bfd_size_type locsymcount
;
2928 Elf_Internal_Shdr
*symtab_hdr
;
2931 if (! is_x86_64_elf (ibfd
))
2934 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2936 struct elf_dyn_relocs
*p
;
2938 if (!elf_x86_64_convert_mov_to_lea (ibfd
, s
, info
))
2941 for (p
= (struct elf_dyn_relocs
*)
2942 (elf_section_data (s
)->local_dynrel
);
2946 if (!bfd_is_abs_section (p
->sec
)
2947 && bfd_is_abs_section (p
->sec
->output_section
))
2949 /* Input section has been discarded, either because
2950 it is a copy of a linkonce section or due to
2951 linker script /DISCARD/, so we'll be discarding
2954 else if (p
->count
!= 0)
2956 srel
= elf_section_data (p
->sec
)->sreloc
;
2957 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2958 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
2959 && (info
->flags
& DF_TEXTREL
) == 0)
2961 info
->flags
|= DF_TEXTREL
;
2962 if (info
->warn_shared_textrel
&& info
->shared
)
2963 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2964 p
->sec
->owner
, p
->sec
);
2970 local_got
= elf_local_got_refcounts (ibfd
);
2974 symtab_hdr
= &elf_symtab_hdr (ibfd
);
2975 locsymcount
= symtab_hdr
->sh_info
;
2976 end_local_got
= local_got
+ locsymcount
;
2977 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
2978 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
2980 srel
= htab
->elf
.srelgot
;
2981 for (; local_got
< end_local_got
;
2982 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
2984 *local_tlsdesc_gotent
= (bfd_vma
) -1;
2987 if (GOT_TLS_GDESC_P (*local_tls_type
))
2989 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
2990 - elf_x86_64_compute_jump_table_size (htab
);
2991 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2992 *local_got
= (bfd_vma
) -2;
2994 if (! GOT_TLS_GDESC_P (*local_tls_type
)
2995 || GOT_TLS_GD_P (*local_tls_type
))
2997 *local_got
= s
->size
;
2998 s
->size
+= GOT_ENTRY_SIZE
;
2999 if (GOT_TLS_GD_P (*local_tls_type
))
3000 s
->size
+= GOT_ENTRY_SIZE
;
3003 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3004 || *local_tls_type
== GOT_TLS_IE
)
3006 if (GOT_TLS_GDESC_P (*local_tls_type
))
3008 htab
->elf
.srelplt
->size
3009 += bed
->s
->sizeof_rela
;
3010 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3012 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3013 || GOT_TLS_GD_P (*local_tls_type
))
3014 srel
->size
+= bed
->s
->sizeof_rela
;
3018 *local_got
= (bfd_vma
) -1;
3022 if (htab
->tls_ld_got
.refcount
> 0)
3024 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3026 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3027 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3028 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3031 htab
->tls_ld_got
.offset
= -1;
3033 /* Allocate global sym .plt and .got entries, and space for global
3034 sym dynamic relocs. */
3035 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3038 /* Allocate .plt and .got entries, and space for local symbols. */
3039 htab_traverse (htab
->loc_hash_table
,
3040 elf_x86_64_allocate_local_dynrelocs
,
3043 /* For every jump slot reserved in the sgotplt, reloc_count is
3044 incremented. However, when we reserve space for TLS descriptors,
3045 it's not incremented, so in order to compute the space reserved
3046 for them, it suffices to multiply the reloc count by the jump
3049 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3050 so that R_X86_64_IRELATIVE entries come last. */
3051 if (htab
->elf
.srelplt
)
3053 htab
->sgotplt_jump_table_size
3054 = elf_x86_64_compute_jump_table_size (htab
);
3055 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3057 else if (htab
->elf
.irelplt
)
3058 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3060 if (htab
->tlsdesc_plt
)
3062 /* If we're not using lazy TLS relocations, don't generate the
3063 PLT and GOT entries they require. */
3064 if ((info
->flags
& DF_BIND_NOW
))
3065 htab
->tlsdesc_plt
= 0;
3068 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3069 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3070 /* Reserve room for the initial entry.
3071 FIXME: we could probably do away with it in this case. */
3072 if (htab
->elf
.splt
->size
== 0)
3073 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3074 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3075 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3079 if (htab
->elf
.sgotplt
)
3081 /* Don't allocate .got.plt section if there are no GOT nor PLT
3082 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3083 if ((htab
->elf
.hgot
== NULL
3084 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3085 && (htab
->elf
.sgotplt
->size
3086 == get_elf_backend_data (output_bfd
)->got_header_size
)
3087 && (htab
->elf
.splt
== NULL
3088 || htab
->elf
.splt
->size
== 0)
3089 && (htab
->elf
.sgot
== NULL
3090 || htab
->elf
.sgot
->size
== 0)
3091 && (htab
->elf
.iplt
== NULL
3092 || htab
->elf
.iplt
->size
== 0)
3093 && (htab
->elf
.igotplt
== NULL
3094 || htab
->elf
.igotplt
->size
== 0))
3095 htab
->elf
.sgotplt
->size
= 0;
3098 if (htab
->plt_eh_frame
!= NULL
3099 && htab
->elf
.splt
!= NULL
3100 && htab
->elf
.splt
->size
!= 0
3101 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3102 && _bfd_elf_eh_frame_present (info
))
3104 const struct elf_x86_64_backend_data
*arch_data
3105 = get_elf_x86_64_arch_data (bed
);
3106 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3109 /* We now have determined the sizes of the various dynamic sections.
3110 Allocate memory for them. */
3112 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3114 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3117 if (s
== htab
->elf
.splt
3118 || s
== htab
->elf
.sgot
3119 || s
== htab
->elf
.sgotplt
3120 || s
== htab
->elf
.iplt
3121 || s
== htab
->elf
.igotplt
3122 || s
== htab
->plt_bnd
3123 || s
== htab
->plt_eh_frame
3124 || s
== htab
->sdynbss
)
3126 /* Strip this section if we don't need it; see the
3129 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3131 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3134 /* We use the reloc_count field as a counter if we need
3135 to copy relocs into the output file. */
3136 if (s
!= htab
->elf
.srelplt
)
3141 /* It's not one of our sections, so don't allocate space. */
3147 /* If we don't need this section, strip it from the
3148 output file. This is mostly to handle .rela.bss and
3149 .rela.plt. We must create both sections in
3150 create_dynamic_sections, because they must be created
3151 before the linker maps input sections to output
3152 sections. The linker does that before
3153 adjust_dynamic_symbol is called, and it is that
3154 function which decides whether anything needs to go
3155 into these sections. */
3157 s
->flags
|= SEC_EXCLUDE
;
3161 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3164 /* Allocate memory for the section contents. We use bfd_zalloc
3165 here in case unused entries are not reclaimed before the
3166 section's contents are written out. This should not happen,
3167 but this way if it does, we get a R_X86_64_NONE reloc instead
3169 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3170 if (s
->contents
== NULL
)
3174 if (htab
->plt_eh_frame
!= NULL
3175 && htab
->plt_eh_frame
->contents
!= NULL
)
3177 const struct elf_x86_64_backend_data
*arch_data
3178 = get_elf_x86_64_arch_data (bed
);
3180 memcpy (htab
->plt_eh_frame
->contents
,
3181 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3182 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3183 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3186 if (htab
->elf
.dynamic_sections_created
)
3188 /* Add some entries to the .dynamic section. We fill in the
3189 values later, in elf_x86_64_finish_dynamic_sections, but we
3190 must add the entries now so that we get the correct size for
3191 the .dynamic section. The DT_DEBUG entry is filled in by the
3192 dynamic linker and used by the debugger. */
3193 #define add_dynamic_entry(TAG, VAL) \
3194 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3196 if (info
->executable
)
3198 if (!add_dynamic_entry (DT_DEBUG
, 0))
3202 if (htab
->elf
.splt
->size
!= 0)
3204 if (!add_dynamic_entry (DT_PLTGOT
, 0)
3205 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3206 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3207 || !add_dynamic_entry (DT_JMPREL
, 0))
3210 if (htab
->tlsdesc_plt
3211 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3212 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3218 if (!add_dynamic_entry (DT_RELA
, 0)
3219 || !add_dynamic_entry (DT_RELASZ
, 0)
3220 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3223 /* If any dynamic relocs apply to a read-only section,
3224 then we need a DT_TEXTREL entry. */
3225 if ((info
->flags
& DF_TEXTREL
) == 0)
3226 elf_link_hash_traverse (&htab
->elf
,
3227 elf_x86_64_readonly_dynrelocs
,
3230 if ((info
->flags
& DF_TEXTREL
) != 0)
3232 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3237 #undef add_dynamic_entry
3243 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3244 struct bfd_link_info
*info
)
3246 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3250 struct elf_link_hash_entry
*tlsbase
;
3252 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3253 "_TLS_MODULE_BASE_",
3254 FALSE
, FALSE
, FALSE
);
3256 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3258 struct elf_x86_64_link_hash_table
*htab
;
3259 struct bfd_link_hash_entry
*bh
= NULL
;
3260 const struct elf_backend_data
*bed
3261 = get_elf_backend_data (output_bfd
);
3263 htab
= elf_x86_64_hash_table (info
);
3267 if (!(_bfd_generic_link_add_one_symbol
3268 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3269 tls_sec
, 0, NULL
, FALSE
,
3270 bed
->collect
, &bh
)))
3273 htab
->tls_module_base
= bh
;
3275 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3276 tlsbase
->def_regular
= 1;
3277 tlsbase
->other
= STV_HIDDEN
;
3278 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3285 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3286 executables. Rather than setting it to the beginning of the TLS
3287 section, we have to set it to the end. This function may be called
3288 multiple times, it is idempotent. */
3291 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3293 struct elf_x86_64_link_hash_table
*htab
;
3294 struct bfd_link_hash_entry
*base
;
3296 if (!info
->executable
)
3299 htab
= elf_x86_64_hash_table (info
);
3303 base
= htab
->tls_module_base
;
3307 base
->u
.def
.value
= htab
->elf
.tls_size
;
3310 /* Return the base VMA address which should be subtracted from real addresses
3311 when resolving @dtpoff relocation.
3312 This is PT_TLS segment p_vaddr. */
3315 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
3317 /* If tls_sec is NULL, we should have signalled an error already. */
3318 if (elf_hash_table (info
)->tls_sec
== NULL
)
3320 return elf_hash_table (info
)->tls_sec
->vma
;
3323 /* Return the relocation value for @tpoff relocation
3324 if STT_TLS virtual address is ADDRESS. */
3327 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3329 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3330 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3331 bfd_vma static_tls_size
;
3333 /* If tls_segment is NULL, we should have signalled an error already. */
3334 if (htab
->tls_sec
== NULL
)
3337 /* Consider special static TLS alignment requirements. */
3338 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3339 return address
- static_tls_size
- htab
->tls_sec
->vma
;
3342 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3346 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
3348 /* Opcode Instruction
3351 0x0f 0x8x conditional jump */
3353 && (contents
[offset
- 1] == 0xe8
3354 || contents
[offset
- 1] == 0xe9))
3356 && contents
[offset
- 2] == 0x0f
3357 && (contents
[offset
- 1] & 0xf0) == 0x80));
3360 /* Relocate an x86_64 ELF section. */
3363 elf_x86_64_relocate_section (bfd
*output_bfd
,
3364 struct bfd_link_info
*info
,
3366 asection
*input_section
,
3368 Elf_Internal_Rela
*relocs
,
3369 Elf_Internal_Sym
*local_syms
,
3370 asection
**local_sections
)
3372 struct elf_x86_64_link_hash_table
*htab
;
3373 Elf_Internal_Shdr
*symtab_hdr
;
3374 struct elf_link_hash_entry
**sym_hashes
;
3375 bfd_vma
*local_got_offsets
;
3376 bfd_vma
*local_tlsdesc_gotents
;
3377 Elf_Internal_Rela
*rel
;
3378 Elf_Internal_Rela
*relend
;
3379 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3381 BFD_ASSERT (is_x86_64_elf (input_bfd
));
3383 htab
= elf_x86_64_hash_table (info
);
3386 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3387 sym_hashes
= elf_sym_hashes (input_bfd
);
3388 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3389 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
3391 elf_x86_64_set_tls_module_base (info
);
3394 relend
= relocs
+ input_section
->reloc_count
;
3395 for (; rel
< relend
; rel
++)
3397 unsigned int r_type
;
3398 reloc_howto_type
*howto
;
3399 unsigned long r_symndx
;
3400 struct elf_link_hash_entry
*h
;
3401 struct elf_x86_64_link_hash_entry
*eh
;
3402 Elf_Internal_Sym
*sym
;
3404 bfd_vma off
, offplt
, plt_offset
;
3406 bfd_boolean unresolved_reloc
;
3407 bfd_reloc_status_type r
;
3409 asection
*base_got
, *resolved_plt
;
3412 r_type
= ELF32_R_TYPE (rel
->r_info
);
3413 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
3414 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
3417 if (r_type
>= (int) R_X86_64_standard
)
3419 (*_bfd_error_handler
)
3420 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3421 input_bfd
, input_section
, r_type
);
3422 bfd_set_error (bfd_error_bad_value
);
3426 if (r_type
!= (int) R_X86_64_32
3427 || ABI_64_P (output_bfd
))
3428 howto
= x86_64_elf_howto_table
+ r_type
;
3430 howto
= (x86_64_elf_howto_table
3431 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
3432 r_symndx
= htab
->r_sym (rel
->r_info
);
3436 unresolved_reloc
= FALSE
;
3437 if (r_symndx
< symtab_hdr
->sh_info
)
3439 sym
= local_syms
+ r_symndx
;
3440 sec
= local_sections
[r_symndx
];
3442 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
3444 st_size
= sym
->st_size
;
3446 /* Relocate against local STT_GNU_IFUNC symbol. */
3447 if (!info
->relocatable
3448 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3450 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
3455 /* Set STT_GNU_IFUNC symbol value. */
3456 h
->root
.u
.def
.value
= sym
->st_value
;
3457 h
->root
.u
.def
.section
= sec
;
3462 bfd_boolean warned ATTRIBUTE_UNUSED
;
3463 bfd_boolean ignored ATTRIBUTE_UNUSED
;
3465 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3466 r_symndx
, symtab_hdr
, sym_hashes
,
3468 unresolved_reloc
, warned
, ignored
);
3472 if (sec
!= NULL
&& discarded_section (sec
))
3473 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3474 rel
, 1, relend
, howto
, 0, contents
);
3476 if (info
->relocatable
)
3479 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
3481 if (r_type
== R_X86_64_64
)
3483 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
3484 zero-extend it to 64bit if addend is zero. */
3485 r_type
= R_X86_64_32
;
3486 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3488 else if (r_type
== R_X86_64_SIZE64
)
3490 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
3491 zero-extend it to 64bit if addend is zero. */
3492 r_type
= R_X86_64_SIZE32
;
3493 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3497 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3499 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3500 it here if it is defined in a non-shared object. */
3502 && h
->type
== STT_GNU_IFUNC
3508 if ((input_section
->flags
& SEC_ALLOC
) == 0
3509 || h
->plt
.offset
== (bfd_vma
) -1)
3512 /* STT_GNU_IFUNC symbol must go through PLT. */
3513 if (htab
->elf
.splt
!= NULL
)
3515 if (htab
->plt_bnd
!= NULL
)
3517 resolved_plt
= htab
->plt_bnd
;
3518 plt_offset
= eh
->plt_bnd
.offset
;
3522 resolved_plt
= htab
->elf
.splt
;
3523 plt_offset
= h
->plt
.offset
;
3528 resolved_plt
= htab
->elf
.iplt
;
3529 plt_offset
= h
->plt
.offset
;
3532 relocation
= (resolved_plt
->output_section
->vma
3533 + resolved_plt
->output_offset
+ plt_offset
);
3538 if (h
->root
.root
.string
)
3539 name
= h
->root
.root
.string
;
3541 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3543 (*_bfd_error_handler
)
3544 (_("%B: relocation %s against STT_GNU_IFUNC "
3545 "symbol `%s' isn't handled by %s"), input_bfd
,
3546 x86_64_elf_howto_table
[r_type
].name
,
3547 name
, __FUNCTION__
);
3548 bfd_set_error (bfd_error_bad_value
);
3557 if (ABI_64_P (output_bfd
))
3561 if (rel
->r_addend
!= 0)
3563 if (h
->root
.root
.string
)
3564 name
= h
->root
.root
.string
;
3566 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
3568 (*_bfd_error_handler
)
3569 (_("%B: relocation %s against STT_GNU_IFUNC "
3570 "symbol `%s' has non-zero addend: %d"),
3571 input_bfd
, x86_64_elf_howto_table
[r_type
].name
,
3572 name
, rel
->r_addend
);
3573 bfd_set_error (bfd_error_bad_value
);
3577 /* Generate dynamic relcoation only when there is a
3578 non-GOT reference in a shared object. */
3579 if (info
->shared
&& h
->non_got_ref
)
3581 Elf_Internal_Rela outrel
;
3584 /* Need a dynamic relocation to get the real function
3586 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
3590 if (outrel
.r_offset
== (bfd_vma
) -1
3591 || outrel
.r_offset
== (bfd_vma
) -2)
3594 outrel
.r_offset
+= (input_section
->output_section
->vma
3595 + input_section
->output_offset
);
3597 if (h
->dynindx
== -1
3599 || info
->executable
)
3601 /* This symbol is resolved locally. */
3602 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
3603 outrel
.r_addend
= (h
->root
.u
.def
.value
3604 + h
->root
.u
.def
.section
->output_section
->vma
3605 + h
->root
.u
.def
.section
->output_offset
);
3609 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3610 outrel
.r_addend
= 0;
3613 sreloc
= htab
->elf
.irelifunc
;
3614 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3616 /* If this reloc is against an external symbol, we
3617 do not want to fiddle with the addend. Otherwise,
3618 we need to include the symbol value so that it
3619 becomes an addend for the dynamic reloc. For an
3620 internal symbol, we have updated addend. */
3625 case R_X86_64_PC32_BND
:
3627 case R_X86_64_PLT32
:
3628 case R_X86_64_PLT32_BND
:
3631 case R_X86_64_GOTPCREL
:
3632 case R_X86_64_GOTPCREL64
:
3633 base_got
= htab
->elf
.sgot
;
3634 off
= h
->got
.offset
;
3636 if (base_got
== NULL
)
3639 if (off
== (bfd_vma
) -1)
3641 /* We can't use h->got.offset here to save state, or
3642 even just remember the offset, as finish_dynamic_symbol
3643 would use that as offset into .got. */
3645 if (htab
->elf
.splt
!= NULL
)
3647 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3648 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3649 base_got
= htab
->elf
.sgotplt
;
3653 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3654 off
= plt_index
* GOT_ENTRY_SIZE
;
3655 base_got
= htab
->elf
.igotplt
;
3658 if (h
->dynindx
== -1
3662 /* This references the local defitionion. We must
3663 initialize this entry in the global offset table.
3664 Since the offset must always be a multiple of 8,
3665 we use the least significant bit to record
3666 whether we have initialized it already.
3668 When doing a dynamic link, we create a .rela.got
3669 relocation entry to initialize the value. This
3670 is done in the finish_dynamic_symbol routine. */
3675 bfd_put_64 (output_bfd
, relocation
,
3676 base_got
->contents
+ off
);
3677 /* Note that this is harmless for the GOTPLT64
3678 case, as -1 | 1 still is -1. */
3684 relocation
= (base_got
->output_section
->vma
3685 + base_got
->output_offset
+ off
);
3691 /* When generating a shared object, the relocations handled here are
3692 copied into the output file to be resolved at run time. */
3695 case R_X86_64_GOT32
:
3696 case R_X86_64_GOT64
:
3697 /* Relocation is to the entry for this symbol in the global
3699 case R_X86_64_GOTPCREL
:
3700 case R_X86_64_GOTPCREL64
:
3701 /* Use global offset table entry as symbol value. */
3702 case R_X86_64_GOTPLT64
:
3703 /* This is obsolete and treated the the same as GOT64. */
3704 base_got
= htab
->elf
.sgot
;
3706 if (htab
->elf
.sgot
== NULL
)
3713 off
= h
->got
.offset
;
3715 && h
->plt
.offset
!= (bfd_vma
)-1
3716 && off
== (bfd_vma
)-1)
3718 /* We can't use h->got.offset here to save
3719 state, or even just remember the offset, as
3720 finish_dynamic_symbol would use that as offset into
3722 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
3723 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3724 base_got
= htab
->elf
.sgotplt
;
3727 dyn
= htab
->elf
.dynamic_sections_created
;
3729 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
3731 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3732 || (ELF_ST_VISIBILITY (h
->other
)
3733 && h
->root
.type
== bfd_link_hash_undefweak
))
3735 /* This is actually a static link, or it is a -Bsymbolic
3736 link and the symbol is defined locally, or the symbol
3737 was forced to be local because of a version file. We
3738 must initialize this entry in the global offset table.
3739 Since the offset must always be a multiple of 8, we
3740 use the least significant bit to record whether we
3741 have initialized it already.
3743 When doing a dynamic link, we create a .rela.got
3744 relocation entry to initialize the value. This is
3745 done in the finish_dynamic_symbol routine. */
3750 bfd_put_64 (output_bfd
, relocation
,
3751 base_got
->contents
+ off
);
3752 /* Note that this is harmless for the GOTPLT64 case,
3753 as -1 | 1 still is -1. */
3758 unresolved_reloc
= FALSE
;
3762 if (local_got_offsets
== NULL
)
3765 off
= local_got_offsets
[r_symndx
];
3767 /* The offset must always be a multiple of 8. We use
3768 the least significant bit to record whether we have
3769 already generated the necessary reloc. */
3774 bfd_put_64 (output_bfd
, relocation
,
3775 base_got
->contents
+ off
);
3780 Elf_Internal_Rela outrel
;
3782 /* We need to generate a R_X86_64_RELATIVE reloc
3783 for the dynamic linker. */
3784 s
= htab
->elf
.srelgot
;
3788 outrel
.r_offset
= (base_got
->output_section
->vma
3789 + base_got
->output_offset
3791 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3792 outrel
.r_addend
= relocation
;
3793 elf_append_rela (output_bfd
, s
, &outrel
);
3796 local_got_offsets
[r_symndx
] |= 1;
3800 if (off
>= (bfd_vma
) -2)
3803 relocation
= base_got
->output_section
->vma
3804 + base_got
->output_offset
+ off
;
3805 if (r_type
!= R_X86_64_GOTPCREL
&& r_type
!= R_X86_64_GOTPCREL64
)
3806 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3807 - htab
->elf
.sgotplt
->output_offset
;
3811 case R_X86_64_GOTOFF64
:
3812 /* Relocation is relative to the start of the global offset
3815 /* Check to make sure it isn't a protected function symbol
3816 for shared library since it may not be local when used
3817 as function address. */
3818 if (!info
->executable
3820 && !SYMBOLIC_BIND (info
, h
)
3822 && h
->type
== STT_FUNC
3823 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
3825 (*_bfd_error_handler
)
3826 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3827 input_bfd
, h
->root
.root
.string
);
3828 bfd_set_error (bfd_error_bad_value
);
3832 /* Note that sgot is not involved in this
3833 calculation. We always want the start of .got.plt. If we
3834 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3835 permitted by the ABI, we might have to change this
3837 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3838 + htab
->elf
.sgotplt
->output_offset
;
3841 case R_X86_64_GOTPC32
:
3842 case R_X86_64_GOTPC64
:
3843 /* Use global offset table as symbol value. */
3844 relocation
= htab
->elf
.sgotplt
->output_section
->vma
3845 + htab
->elf
.sgotplt
->output_offset
;
3846 unresolved_reloc
= FALSE
;
3849 case R_X86_64_PLTOFF64
:
3850 /* Relocation is PLT entry relative to GOT. For local
3851 symbols it's the symbol itself relative to GOT. */
3853 /* See PLT32 handling. */
3854 && h
->plt
.offset
!= (bfd_vma
) -1
3855 && htab
->elf
.splt
!= NULL
)
3857 if (htab
->plt_bnd
!= NULL
)
3859 resolved_plt
= htab
->plt_bnd
;
3860 plt_offset
= eh
->plt_bnd
.offset
;
3864 resolved_plt
= htab
->elf
.splt
;
3865 plt_offset
= h
->plt
.offset
;
3868 relocation
= (resolved_plt
->output_section
->vma
3869 + resolved_plt
->output_offset
3871 unresolved_reloc
= FALSE
;
3874 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3875 + htab
->elf
.sgotplt
->output_offset
;
3878 case R_X86_64_PLT32
:
3879 case R_X86_64_PLT32_BND
:
3880 /* Relocation is to the entry for this symbol in the
3881 procedure linkage table. */
3883 /* Resolve a PLT32 reloc against a local symbol directly,
3884 without using the procedure linkage table. */
3888 if (h
->plt
.offset
== (bfd_vma
) -1
3889 || htab
->elf
.splt
== NULL
)
3891 /* We didn't make a PLT entry for this symbol. This
3892 happens when statically linking PIC code, or when
3893 using -Bsymbolic. */
3897 if (htab
->plt_bnd
!= NULL
)
3899 resolved_plt
= htab
->plt_bnd
;
3900 plt_offset
= eh
->plt_bnd
.offset
;
3904 resolved_plt
= htab
->elf
.splt
;
3905 plt_offset
= h
->plt
.offset
;
3908 relocation
= (resolved_plt
->output_section
->vma
3909 + resolved_plt
->output_offset
3911 unresolved_reloc
= FALSE
;
3914 case R_X86_64_SIZE32
:
3915 case R_X86_64_SIZE64
:
3916 /* Set to symbol size. */
3917 relocation
= st_size
;
3923 case R_X86_64_PC32_BND
:
3925 && (input_section
->flags
& SEC_ALLOC
) != 0
3926 && (input_section
->flags
& SEC_READONLY
) != 0
3929 bfd_boolean fail
= FALSE
;
3931 = ((r_type
== R_X86_64_PC32
3932 || r_type
== R_X86_64_PC32_BND
)
3933 && is_32bit_relative_branch (contents
, rel
->r_offset
));
3935 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
3937 /* Symbol is referenced locally. Make sure it is
3938 defined locally or for a branch. */
3939 fail
= !h
->def_regular
&& !branch
;
3943 /* Symbol isn't referenced locally. We only allow
3944 branch to symbol with non-default visibility. */
3946 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
3953 const char *pic
= "";
3955 switch (ELF_ST_VISIBILITY (h
->other
))
3958 v
= _("hidden symbol");
3961 v
= _("internal symbol");
3964 v
= _("protected symbol");
3968 pic
= _("; recompile with -fPIC");
3973 fmt
= _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3975 fmt
= _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3977 (*_bfd_error_handler
) (fmt
, input_bfd
,
3978 x86_64_elf_howto_table
[r_type
].name
,
3979 v
, h
->root
.root
.string
, pic
);
3980 bfd_set_error (bfd_error_bad_value
);
3991 /* FIXME: The ABI says the linker should make sure the value is
3992 the same when it's zeroextended to 64 bit. */
3995 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4000 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4001 || h
->root
.type
!= bfd_link_hash_undefweak
)
4002 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4003 && r_type
!= R_X86_64_SIZE32
4004 && r_type
!= R_X86_64_SIZE64
)
4005 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4006 || (ELIMINATE_COPY_RELOCS
4013 || h
->root
.type
== bfd_link_hash_undefweak
4014 || h
->root
.type
== bfd_link_hash_undefined
)))
4016 Elf_Internal_Rela outrel
;
4017 bfd_boolean skip
, relocate
;
4020 /* When generating a shared object, these relocations
4021 are copied into the output file to be resolved at run
4027 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4029 if (outrel
.r_offset
== (bfd_vma
) -1)
4031 else if (outrel
.r_offset
== (bfd_vma
) -2)
4032 skip
= TRUE
, relocate
= TRUE
;
4034 outrel
.r_offset
+= (input_section
->output_section
->vma
4035 + input_section
->output_offset
);
4038 memset (&outrel
, 0, sizeof outrel
);
4040 /* h->dynindx may be -1 if this symbol was marked to
4044 && (IS_X86_64_PCREL_TYPE (r_type
)
4046 || ! SYMBOLIC_BIND (info
, h
)
4047 || ! h
->def_regular
))
4049 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4050 outrel
.r_addend
= rel
->r_addend
;
4054 /* This symbol is local, or marked to become local. */
4055 if (r_type
== htab
->pointer_r_type
)
4058 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4059 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4061 else if (r_type
== R_X86_64_64
4062 && !ABI_64_P (output_bfd
))
4065 outrel
.r_info
= htab
->r_info (0,
4066 R_X86_64_RELATIVE64
);
4067 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4068 /* Check addend overflow. */
4069 if ((outrel
.r_addend
& 0x80000000)
4070 != (rel
->r_addend
& 0x80000000))
4073 int addend
= rel
->r_addend
;
4074 if (h
&& h
->root
.root
.string
)
4075 name
= h
->root
.root
.string
;
4077 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4080 (*_bfd_error_handler
)
4081 (_("%B: addend -0x%x in relocation %s against "
4082 "symbol `%s' at 0x%lx in section `%A' is "
4084 input_bfd
, input_section
, addend
,
4085 x86_64_elf_howto_table
[r_type
].name
,
4086 name
, (unsigned long) rel
->r_offset
);
4088 (*_bfd_error_handler
)
4089 (_("%B: addend 0x%x in relocation %s against "
4090 "symbol `%s' at 0x%lx in section `%A' is "
4092 input_bfd
, input_section
, addend
,
4093 x86_64_elf_howto_table
[r_type
].name
,
4094 name
, (unsigned long) rel
->r_offset
);
4095 bfd_set_error (bfd_error_bad_value
);
4103 if (bfd_is_abs_section (sec
))
4105 else if (sec
== NULL
|| sec
->owner
== NULL
)
4107 bfd_set_error (bfd_error_bad_value
);
4114 /* We are turning this relocation into one
4115 against a section symbol. It would be
4116 proper to subtract the symbol's value,
4117 osec->vma, from the emitted reloc addend,
4118 but ld.so expects buggy relocs. */
4119 osec
= sec
->output_section
;
4120 sindx
= elf_section_data (osec
)->dynindx
;
4123 asection
*oi
= htab
->elf
.text_index_section
;
4124 sindx
= elf_section_data (oi
)->dynindx
;
4126 BFD_ASSERT (sindx
!= 0);
4129 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4130 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4134 sreloc
= elf_section_data (input_section
)->sreloc
;
4136 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4138 r
= bfd_reloc_notsupported
;
4139 goto check_relocation_error
;
4142 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4144 /* If this reloc is against an external symbol, we do
4145 not want to fiddle with the addend. Otherwise, we
4146 need to include the symbol value so that it becomes
4147 an addend for the dynamic reloc. */
4154 case R_X86_64_TLSGD
:
4155 case R_X86_64_GOTPC32_TLSDESC
:
4156 case R_X86_64_TLSDESC_CALL
:
4157 case R_X86_64_GOTTPOFF
:
4158 tls_type
= GOT_UNKNOWN
;
4159 if (h
== NULL
&& local_got_offsets
)
4160 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4162 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4164 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4165 input_section
, contents
,
4166 symtab_hdr
, sym_hashes
,
4167 &r_type
, tls_type
, rel
,
4168 relend
, h
, r_symndx
))
4171 if (r_type
== R_X86_64_TPOFF32
)
4173 bfd_vma roff
= rel
->r_offset
;
4175 BFD_ASSERT (! unresolved_reloc
);
4177 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4179 /* GD->LE transition. For 64bit, change
4180 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4181 .word 0x6666; rex64; call __tls_get_addr
4184 leaq foo@tpoff(%rax), %rax
4186 leaq foo@tlsgd(%rip), %rdi
4187 .word 0x6666; rex64; call __tls_get_addr
4190 leaq foo@tpoff(%rax), %rax
4191 For largepic, change:
4192 leaq foo@tlsgd(%rip), %rdi
4193 movabsq $__tls_get_addr@pltoff, %rax
4198 leaq foo@tpoff(%rax), %rax
4199 nopw 0x0(%rax,%rax,1) */
4201 if (ABI_64_P (output_bfd
)
4202 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4204 memcpy (contents
+ roff
- 3,
4205 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4206 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4209 else if (ABI_64_P (output_bfd
))
4210 memcpy (contents
+ roff
- 4,
4211 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4214 memcpy (contents
+ roff
- 3,
4215 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4217 bfd_put_32 (output_bfd
,
4218 elf_x86_64_tpoff (info
, relocation
),
4219 contents
+ roff
+ 8 + largepic
);
4220 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4224 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4226 /* GDesc -> LE transition.
4227 It's originally something like:
4228 leaq x@tlsdesc(%rip), %rax
4231 movl $x@tpoff, %rax. */
4233 unsigned int val
, type
;
4235 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4236 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4237 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
4238 contents
+ roff
- 3);
4239 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
4240 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4241 contents
+ roff
- 1);
4242 bfd_put_32 (output_bfd
,
4243 elf_x86_64_tpoff (info
, relocation
),
4247 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4249 /* GDesc -> LE transition.
4254 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4255 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4258 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
4260 /* IE->LE transition:
4261 For 64bit, originally it can be one of:
4262 movq foo@gottpoff(%rip), %reg
4263 addq foo@gottpoff(%rip), %reg
4266 leaq foo(%reg), %reg
4268 For 32bit, originally it can be one of:
4269 movq foo@gottpoff(%rip), %reg
4270 addl foo@gottpoff(%rip), %reg
4273 leal foo(%reg), %reg
4276 unsigned int val
, type
, reg
;
4279 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4282 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
4283 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4289 bfd_put_8 (output_bfd
, 0x49,
4290 contents
+ roff
- 3);
4291 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4292 bfd_put_8 (output_bfd
, 0x41,
4293 contents
+ roff
- 3);
4294 bfd_put_8 (output_bfd
, 0xc7,
4295 contents
+ roff
- 2);
4296 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4297 contents
+ roff
- 1);
4301 /* addq/addl -> addq/addl - addressing with %rsp/%r12
4304 bfd_put_8 (output_bfd
, 0x49,
4305 contents
+ roff
- 3);
4306 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4307 bfd_put_8 (output_bfd
, 0x41,
4308 contents
+ roff
- 3);
4309 bfd_put_8 (output_bfd
, 0x81,
4310 contents
+ roff
- 2);
4311 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4312 contents
+ roff
- 1);
4316 /* addq/addl -> leaq/leal */
4318 bfd_put_8 (output_bfd
, 0x4d,
4319 contents
+ roff
- 3);
4320 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4321 bfd_put_8 (output_bfd
, 0x45,
4322 contents
+ roff
- 3);
4323 bfd_put_8 (output_bfd
, 0x8d,
4324 contents
+ roff
- 2);
4325 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
4326 contents
+ roff
- 1);
4328 bfd_put_32 (output_bfd
,
4329 elf_x86_64_tpoff (info
, relocation
),
4337 if (htab
->elf
.sgot
== NULL
)
4342 off
= h
->got
.offset
;
4343 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
4347 if (local_got_offsets
== NULL
)
4350 off
= local_got_offsets
[r_symndx
];
4351 offplt
= local_tlsdesc_gotents
[r_symndx
];
4358 Elf_Internal_Rela outrel
;
4362 if (htab
->elf
.srelgot
== NULL
)
4365 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4367 if (GOT_TLS_GDESC_P (tls_type
))
4369 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
4370 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
4371 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
4372 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4373 + htab
->elf
.sgotplt
->output_offset
4375 + htab
->sgotplt_jump_table_size
);
4376 sreloc
= htab
->elf
.srelplt
;
4378 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
4380 outrel
.r_addend
= 0;
4381 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4384 sreloc
= htab
->elf
.srelgot
;
4386 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4387 + htab
->elf
.sgot
->output_offset
+ off
);
4389 if (GOT_TLS_GD_P (tls_type
))
4390 dr_type
= R_X86_64_DTPMOD64
;
4391 else if (GOT_TLS_GDESC_P (tls_type
))
4394 dr_type
= R_X86_64_TPOFF64
;
4396 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
4397 outrel
.r_addend
= 0;
4398 if ((dr_type
== R_X86_64_TPOFF64
4399 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
4400 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
4401 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
4403 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4405 if (GOT_TLS_GD_P (tls_type
))
4409 BFD_ASSERT (! unresolved_reloc
);
4410 bfd_put_64 (output_bfd
,
4411 relocation
- elf_x86_64_dtpoff_base (info
),
4412 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4416 bfd_put_64 (output_bfd
, 0,
4417 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4418 outrel
.r_info
= htab
->r_info (indx
,
4420 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
4421 elf_append_rela (output_bfd
, sreloc
,
4430 local_got_offsets
[r_symndx
] |= 1;
4433 if (off
>= (bfd_vma
) -2
4434 && ! GOT_TLS_GDESC_P (tls_type
))
4436 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4438 if (r_type
== R_X86_64_GOTPC32_TLSDESC
4439 || r_type
== R_X86_64_TLSDESC_CALL
)
4440 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4441 + htab
->elf
.sgotplt
->output_offset
4442 + offplt
+ htab
->sgotplt_jump_table_size
;
4444 relocation
= htab
->elf
.sgot
->output_section
->vma
4445 + htab
->elf
.sgot
->output_offset
+ off
;
4446 unresolved_reloc
= FALSE
;
4450 bfd_vma roff
= rel
->r_offset
;
4452 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4454 /* GD->IE transition. For 64bit, change
4455 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4456 .word 0x6666; rex64; call __tls_get_addr@plt
4459 addq foo@gottpoff(%rip), %rax
4461 leaq foo@tlsgd(%rip), %rdi
4462 .word 0x6666; rex64; call __tls_get_addr@plt
4465 addq foo@gottpoff(%rip), %rax
4466 For largepic, change:
4467 leaq foo@tlsgd(%rip), %rdi
4468 movabsq $__tls_get_addr@pltoff, %rax
4473 addq foo@gottpoff(%rax), %rax
4474 nopw 0x0(%rax,%rax,1) */
4476 if (ABI_64_P (output_bfd
)
4477 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4479 memcpy (contents
+ roff
- 3,
4480 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
4481 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4484 else if (ABI_64_P (output_bfd
))
4485 memcpy (contents
+ roff
- 4,
4486 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4489 memcpy (contents
+ roff
- 3,
4490 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4493 relocation
= (htab
->elf
.sgot
->output_section
->vma
4494 + htab
->elf
.sgot
->output_offset
+ off
4497 - input_section
->output_section
->vma
4498 - input_section
->output_offset
4500 bfd_put_32 (output_bfd
, relocation
,
4501 contents
+ roff
+ 8 + largepic
);
4502 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4506 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4508 /* GDesc -> IE transition.
4509 It's originally something like:
4510 leaq x@tlsdesc(%rip), %rax
4513 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
4515 /* Now modify the instruction as appropriate. To
4516 turn a leaq into a movq in the form we use it, it
4517 suffices to change the second byte from 0x8d to
4519 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4521 bfd_put_32 (output_bfd
,
4522 htab
->elf
.sgot
->output_section
->vma
4523 + htab
->elf
.sgot
->output_offset
+ off
4525 - input_section
->output_section
->vma
4526 - input_section
->output_offset
4531 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4533 /* GDesc -> IE transition.
4540 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4541 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4549 case R_X86_64_TLSLD
:
4550 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4551 input_section
, contents
,
4552 symtab_hdr
, sym_hashes
,
4553 &r_type
, GOT_UNKNOWN
,
4554 rel
, relend
, h
, r_symndx
))
4557 if (r_type
!= R_X86_64_TLSLD
)
4559 /* LD->LE transition:
4560 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4561 For 64bit, we change it into:
4562 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4563 For 32bit, we change it into:
4564 nopl 0x0(%rax); movl %fs:0, %eax.
4565 For largepic, change:
4566 leaq foo@tlsgd(%rip), %rdi
4567 movabsq $__tls_get_addr@pltoff, %rax
4571 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
4574 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
4575 if (ABI_64_P (output_bfd
)
4576 && contents
[rel
->r_offset
+ 5] == (bfd_byte
) '\xb8')
4577 memcpy (contents
+ rel
->r_offset
- 3,
4578 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
4579 "\x64\x48\x8b\x04\x25\0\0\0", 22);
4580 else if (ABI_64_P (output_bfd
))
4581 memcpy (contents
+ rel
->r_offset
- 3,
4582 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4584 memcpy (contents
+ rel
->r_offset
- 3,
4585 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4586 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4591 if (htab
->elf
.sgot
== NULL
)
4594 off
= htab
->tls_ld_got
.offset
;
4599 Elf_Internal_Rela outrel
;
4601 if (htab
->elf
.srelgot
== NULL
)
4604 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4605 + htab
->elf
.sgot
->output_offset
+ off
);
4607 bfd_put_64 (output_bfd
, 0,
4608 htab
->elf
.sgot
->contents
+ off
);
4609 bfd_put_64 (output_bfd
, 0,
4610 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4611 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
4612 outrel
.r_addend
= 0;
4613 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
4615 htab
->tls_ld_got
.offset
|= 1;
4617 relocation
= htab
->elf
.sgot
->output_section
->vma
4618 + htab
->elf
.sgot
->output_offset
+ off
;
4619 unresolved_reloc
= FALSE
;
4622 case R_X86_64_DTPOFF32
:
4623 if (!info
->executable
|| (input_section
->flags
& SEC_CODE
) == 0)
4624 relocation
-= elf_x86_64_dtpoff_base (info
);
4626 relocation
= elf_x86_64_tpoff (info
, relocation
);
4629 case R_X86_64_TPOFF32
:
4630 case R_X86_64_TPOFF64
:
4631 BFD_ASSERT (info
->executable
);
4632 relocation
= elf_x86_64_tpoff (info
, relocation
);
4635 case R_X86_64_DTPOFF64
:
4636 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
4637 relocation
-= elf_x86_64_dtpoff_base (info
);
4644 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4645 because such sections are not SEC_ALLOC and thus ld.so will
4646 not process them. */
4647 if (unresolved_reloc
4648 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
4650 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4651 rel
->r_offset
) != (bfd_vma
) -1)
4653 (*_bfd_error_handler
)
4654 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4657 (long) rel
->r_offset
,
4659 h
->root
.root
.string
);
4664 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4665 contents
, rel
->r_offset
,
4666 relocation
, rel
->r_addend
);
4668 check_relocation_error
:
4669 if (r
!= bfd_reloc_ok
)
4674 name
= h
->root
.root
.string
;
4677 name
= bfd_elf_string_from_elf_section (input_bfd
,
4678 symtab_hdr
->sh_link
,
4683 name
= bfd_section_name (input_bfd
, sec
);
4686 if (r
== bfd_reloc_overflow
)
4688 if (! ((*info
->callbacks
->reloc_overflow
)
4689 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4690 (bfd_vma
) 0, input_bfd
, input_section
,
4696 (*_bfd_error_handler
)
4697 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4698 input_bfd
, input_section
,
4699 (long) rel
->r_offset
, name
, (int) r
);
4708 /* Finish up dynamic symbol handling. We set the contents of various
4709 dynamic sections here. */
4712 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
4713 struct bfd_link_info
*info
,
4714 struct elf_link_hash_entry
*h
,
4715 Elf_Internal_Sym
*sym ATTRIBUTE_UNUSED
)
4717 struct elf_x86_64_link_hash_table
*htab
;
4718 const struct elf_x86_64_backend_data
*abed
;
4719 bfd_boolean use_plt_bnd
;
4721 htab
= elf_x86_64_hash_table (info
);
4725 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
4726 section only if there is .plt section. */
4727 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
4729 ? &elf_x86_64_bnd_arch_bed
4730 : get_elf_x86_64_backend_data (output_bfd
));
4732 if (h
->plt
.offset
!= (bfd_vma
) -1)
4735 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
4736 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
4737 Elf_Internal_Rela rela
;
4739 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
4740 const struct elf_backend_data
*bed
;
4741 bfd_vma plt_got_pcrel_offset
;
4743 /* When building a static executable, use .iplt, .igot.plt and
4744 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4745 if (htab
->elf
.splt
!= NULL
)
4747 plt
= htab
->elf
.splt
;
4748 gotplt
= htab
->elf
.sgotplt
;
4749 relplt
= htab
->elf
.srelplt
;
4753 plt
= htab
->elf
.iplt
;
4754 gotplt
= htab
->elf
.igotplt
;
4755 relplt
= htab
->elf
.irelplt
;
4758 /* This symbol has an entry in the procedure linkage table. Set
4760 if ((h
->dynindx
== -1
4761 && !((h
->forced_local
|| info
->executable
)
4763 && h
->type
== STT_GNU_IFUNC
))
4769 /* Get the index in the procedure linkage table which
4770 corresponds to this symbol. This is the index of this symbol
4771 in all the symbols for which we are making plt entries. The
4772 first entry in the procedure linkage table is reserved.
4774 Get the offset into the .got table of the entry that
4775 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
4776 bytes. The first three are reserved for the dynamic linker.
4778 For static executables, we don't reserve anything. */
4780 if (plt
== htab
->elf
.splt
)
4782 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
4783 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
4787 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
4788 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
4791 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
4792 plt_plt_offset
= abed
->plt_plt_offset
;
4793 plt_got_insn_size
= abed
->plt_got_insn_size
;
4794 plt_got_offset
= abed
->plt_got_offset
;
4797 /* Use the second PLT with BND relocations. */
4798 const bfd_byte
*plt_entry
, *plt2_entry
;
4799 struct elf_x86_64_link_hash_entry
*eh
4800 = (struct elf_x86_64_link_hash_entry
*) h
;
4802 if (eh
->has_bnd_reloc
)
4804 plt_entry
= elf_x86_64_bnd_plt_entry
;
4805 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
4809 plt_entry
= elf_x86_64_legacy_plt_entry
;
4810 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
4812 /* Subtract 1 since there is no BND prefix. */
4813 plt_plt_insn_end
-= 1;
4814 plt_plt_offset
-= 1;
4815 plt_got_insn_size
-= 1;
4816 plt_got_offset
-= 1;
4819 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
4820 == sizeof (elf_x86_64_legacy_plt_entry
));
4822 /* Fill in the entry in the procedure linkage table. */
4823 memcpy (plt
->contents
+ h
->plt
.offset
,
4824 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
4825 /* Fill in the entry in the second PLT. */
4826 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
4827 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
4829 resolved_plt
= htab
->plt_bnd
;
4830 plt_offset
= eh
->plt_bnd
.offset
;
4834 /* Fill in the entry in the procedure linkage table. */
4835 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
4836 abed
->plt_entry_size
);
4839 plt_offset
= h
->plt
.offset
;
4842 /* Insert the relocation positions of the plt section. */
4844 /* Put offset the PC-relative instruction referring to the GOT entry,
4845 subtracting the size of that instruction. */
4846 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
4847 + gotplt
->output_offset
4849 - resolved_plt
->output_section
->vma
4850 - resolved_plt
->output_offset
4852 - plt_got_insn_size
);
4854 /* Check PC-relative offset overflow in PLT entry. */
4855 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
4856 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
4857 output_bfd
, h
->root
.root
.string
);
4859 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
4860 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
4862 /* Fill in the entry in the global offset table, initially this
4863 points to the second part of the PLT entry. */
4864 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4865 + plt
->output_offset
4866 + h
->plt
.offset
+ abed
->plt_lazy_offset
),
4867 gotplt
->contents
+ got_offset
);
4869 /* Fill in the entry in the .rela.plt section. */
4870 rela
.r_offset
= (gotplt
->output_section
->vma
4871 + gotplt
->output_offset
4873 if (h
->dynindx
== -1
4874 || ((info
->executable
4875 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
4877 && h
->type
== STT_GNU_IFUNC
))
4879 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4880 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4881 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4882 rela
.r_addend
= (h
->root
.u
.def
.value
4883 + h
->root
.u
.def
.section
->output_section
->vma
4884 + h
->root
.u
.def
.section
->output_offset
);
4885 /* R_X86_64_IRELATIVE comes last. */
4886 plt_index
= htab
->next_irelative_index
--;
4890 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
4892 plt_index
= htab
->next_jump_slot_index
++;
4895 /* Don't fill PLT entry for static executables. */
4896 if (plt
== htab
->elf
.splt
)
4898 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
4900 /* Put relocation index. */
4901 bfd_put_32 (output_bfd
, plt_index
,
4902 plt
->contents
+ h
->plt
.offset
+ abed
->plt_reloc_offset
);
4904 /* Put offset for jmp .PLT0 and check for overflow. We don't
4905 check relocation index for overflow since branch displacement
4906 will overflow first. */
4907 if (plt0_offset
> 0x80000000)
4908 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
4909 output_bfd
, h
->root
.root
.string
);
4910 bfd_put_32 (output_bfd
, - plt0_offset
,
4911 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
4914 bed
= get_elf_backend_data (output_bfd
);
4915 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
4916 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
4918 if (!h
->def_regular
)
4920 /* Mark the symbol as undefined, rather than as defined in
4921 the .plt section. Leave the value if there were any
4922 relocations where pointer equality matters (this is a clue
4923 for the dynamic linker, to make function pointer
4924 comparisons work between an application and shared
4925 library), otherwise set it to zero. If a function is only
4926 called from a binary, there is no need to slow down
4927 shared libraries because of that. */
4928 sym
->st_shndx
= SHN_UNDEF
;
4929 if (!h
->pointer_equality_needed
)
4934 if (h
->got
.offset
!= (bfd_vma
) -1
4935 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
4936 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
)
4938 Elf_Internal_Rela rela
;
4940 /* This symbol has an entry in the global offset table. Set it
4942 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
4945 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4946 + htab
->elf
.sgot
->output_offset
4947 + (h
->got
.offset
&~ (bfd_vma
) 1));
4949 /* If this is a static link, or it is a -Bsymbolic link and the
4950 symbol is defined locally or was forced to be local because
4951 of a version file, we just want to emit a RELATIVE reloc.
4952 The entry in the global offset table will already have been
4953 initialized in the relocate_section function. */
4955 && h
->type
== STT_GNU_IFUNC
)
4959 /* Generate R_X86_64_GLOB_DAT. */
4966 if (!h
->pointer_equality_needed
)
4969 /* For non-shared object, we can't use .got.plt, which
4970 contains the real function addres if we need pointer
4971 equality. We load the GOT entry with the PLT entry. */
4972 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
4973 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4974 + plt
->output_offset
4976 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4980 else if (info
->shared
4981 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4983 if (!h
->def_regular
)
4985 BFD_ASSERT((h
->got
.offset
& 1) != 0);
4986 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4987 rela
.r_addend
= (h
->root
.u
.def
.value
4988 + h
->root
.u
.def
.section
->output_section
->vma
4989 + h
->root
.u
.def
.section
->output_offset
);
4993 BFD_ASSERT((h
->got
.offset
& 1) == 0);
4995 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
4996 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4997 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
5001 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5006 Elf_Internal_Rela rela
;
5008 /* This symbol needs a copy reloc. Set it up. */
5010 if (h
->dynindx
== -1
5011 || (h
->root
.type
!= bfd_link_hash_defined
5012 && h
->root
.type
!= bfd_link_hash_defweak
)
5013 || htab
->srelbss
== NULL
)
5016 rela
.r_offset
= (h
->root
.u
.def
.value
5017 + h
->root
.u
.def
.section
->output_section
->vma
5018 + h
->root
.u
.def
.section
->output_offset
);
5019 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5021 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5027 /* Finish up local dynamic symbol handling. We set the contents of
5028 various dynamic sections here. */
5031 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5033 struct elf_link_hash_entry
*h
5034 = (struct elf_link_hash_entry
*) *slot
;
5035 struct bfd_link_info
*info
5036 = (struct bfd_link_info
*) inf
;
5038 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5042 /* Used to decide how to sort relocs in an optimal manner for the
5043 dynamic linker, before writing them out. */
5045 static enum elf_reloc_type_class
5046 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5047 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5048 const Elf_Internal_Rela
*rela
)
5050 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5052 case R_X86_64_RELATIVE
:
5053 case R_X86_64_RELATIVE64
:
5054 return reloc_class_relative
;
5055 case R_X86_64_JUMP_SLOT
:
5056 return reloc_class_plt
;
5058 return reloc_class_copy
;
5060 return reloc_class_normal
;
5064 /* Finish up the dynamic sections. */
5067 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
5068 struct bfd_link_info
*info
)
5070 struct elf_x86_64_link_hash_table
*htab
;
5073 const struct elf_x86_64_backend_data
*abed
;
5075 htab
= elf_x86_64_hash_table (info
);
5079 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5080 section only if there is .plt section. */
5081 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
5082 ? &elf_x86_64_bnd_arch_bed
5083 : get_elf_x86_64_backend_data (output_bfd
));
5085 dynobj
= htab
->elf
.dynobj
;
5086 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5088 if (htab
->elf
.dynamic_sections_created
)
5090 bfd_byte
*dyncon
, *dynconend
;
5091 const struct elf_backend_data
*bed
;
5092 bfd_size_type sizeof_dyn
;
5094 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5097 bed
= get_elf_backend_data (dynobj
);
5098 sizeof_dyn
= bed
->s
->sizeof_dyn
;
5099 dyncon
= sdyn
->contents
;
5100 dynconend
= sdyn
->contents
+ sdyn
->size
;
5101 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
5103 Elf_Internal_Dyn dyn
;
5106 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
5114 s
= htab
->elf
.sgotplt
;
5115 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5119 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
5123 s
= htab
->elf
.srelplt
->output_section
;
5124 dyn
.d_un
.d_val
= s
->size
;
5128 /* The procedure linkage table relocs (DT_JMPREL) should
5129 not be included in the overall relocs (DT_RELA).
5130 Therefore, we override the DT_RELASZ entry here to
5131 make it not include the JMPREL relocs. Since the
5132 linker script arranges for .rela.plt to follow all
5133 other relocation sections, we don't have to worry
5134 about changing the DT_RELA entry. */
5135 if (htab
->elf
.srelplt
!= NULL
)
5137 s
= htab
->elf
.srelplt
->output_section
;
5138 dyn
.d_un
.d_val
-= s
->size
;
5142 case DT_TLSDESC_PLT
:
5144 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5145 + htab
->tlsdesc_plt
;
5148 case DT_TLSDESC_GOT
:
5150 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5151 + htab
->tlsdesc_got
;
5155 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
5158 /* Fill in the special first entry in the procedure linkage table. */
5159 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5161 /* Fill in the first entry in the procedure linkage table. */
5162 memcpy (htab
->elf
.splt
->contents
,
5163 abed
->plt0_entry
, abed
->plt_entry_size
);
5164 /* Add offset for pushq GOT+8(%rip), since the instruction
5165 uses 6 bytes subtract this value. */
5166 bfd_put_32 (output_bfd
,
5167 (htab
->elf
.sgotplt
->output_section
->vma
5168 + htab
->elf
.sgotplt
->output_offset
5170 - htab
->elf
.splt
->output_section
->vma
5171 - htab
->elf
.splt
->output_offset
5173 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
5174 /* Add offset for the PC-relative instruction accessing GOT+16,
5175 subtracting the offset to the end of that instruction. */
5176 bfd_put_32 (output_bfd
,
5177 (htab
->elf
.sgotplt
->output_section
->vma
5178 + htab
->elf
.sgotplt
->output_offset
5180 - htab
->elf
.splt
->output_section
->vma
5181 - htab
->elf
.splt
->output_offset
5182 - abed
->plt0_got2_insn_end
),
5183 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
5185 elf_section_data (htab
->elf
.splt
->output_section
)
5186 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
5188 if (htab
->tlsdesc_plt
)
5190 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5191 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
5193 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
5194 abed
->plt0_entry
, abed
->plt_entry_size
);
5196 /* Add offset for pushq GOT+8(%rip), since the
5197 instruction uses 6 bytes subtract this value. */
5198 bfd_put_32 (output_bfd
,
5199 (htab
->elf
.sgotplt
->output_section
->vma
5200 + htab
->elf
.sgotplt
->output_offset
5202 - htab
->elf
.splt
->output_section
->vma
5203 - htab
->elf
.splt
->output_offset
5206 htab
->elf
.splt
->contents
5207 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
5208 /* Add offset for the PC-relative instruction accessing GOT+TDG,
5209 where TGD stands for htab->tlsdesc_got, subtracting the offset
5210 to the end of that instruction. */
5211 bfd_put_32 (output_bfd
,
5212 (htab
->elf
.sgot
->output_section
->vma
5213 + htab
->elf
.sgot
->output_offset
5215 - htab
->elf
.splt
->output_section
->vma
5216 - htab
->elf
.splt
->output_offset
5218 - abed
->plt0_got2_insn_end
),
5219 htab
->elf
.splt
->contents
5220 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
5225 if (htab
->plt_bnd
!= NULL
)
5226 elf_section_data (htab
->plt_bnd
->output_section
)
5227 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
5229 if (htab
->elf
.sgotplt
)
5231 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
5233 (*_bfd_error_handler
)
5234 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
5238 /* Fill in the first three entries in the global offset table. */
5239 if (htab
->elf
.sgotplt
->size
> 0)
5241 /* Set the first entry in the global offset table to the address of
5242 the dynamic section. */
5244 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
5246 bfd_put_64 (output_bfd
,
5247 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
5248 htab
->elf
.sgotplt
->contents
);
5249 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
5250 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
5251 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
5254 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
5258 /* Adjust .eh_frame for .plt section. */
5259 if (htab
->plt_eh_frame
!= NULL
5260 && htab
->plt_eh_frame
->contents
!= NULL
)
5262 if (htab
->elf
.splt
!= NULL
5263 && htab
->elf
.splt
->size
!= 0
5264 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
5265 && htab
->elf
.splt
->output_section
!= NULL
5266 && htab
->plt_eh_frame
->output_section
!= NULL
)
5268 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
5269 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
5270 + htab
->plt_eh_frame
->output_offset
5271 + PLT_FDE_START_OFFSET
;
5272 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5273 htab
->plt_eh_frame
->contents
5274 + PLT_FDE_START_OFFSET
);
5276 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
5278 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5280 htab
->plt_eh_frame
->contents
))
5285 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
5286 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
5289 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5290 htab_traverse (htab
->loc_hash_table
,
5291 elf_x86_64_finish_local_dynamic_symbol
,
5297 /* Return address in section PLT for the Ith GOTPLT relocation, for
5298 relocation REL or (bfd_vma) -1 if it should not be included. */
5301 elf_x86_64_plt_sym_val (bfd_vma i
, const asection
*plt
,
5305 const struct elf_x86_64_backend_data
*bed
;
5308 /* Only match R_X86_64_JUMP_SLOT and R_X86_64_IRELATIVE. */
5309 if (rel
->howto
->type
!= R_X86_64_JUMP_SLOT
5310 && rel
->howto
->type
!= R_X86_64_IRELATIVE
)
5311 return (bfd_vma
) -1;
5314 bed
= get_elf_x86_64_backend_data (abfd
);
5315 plt_offset
= bed
->plt_entry_size
;
5317 if (elf_elfheader (abfd
)->e_ident
[EI_OSABI
] != ELFOSABI_GNU
)
5318 return plt
->vma
+ (i
+ 1) * plt_offset
;
5320 while (plt_offset
< plt
->size
)
5322 bfd_vma reloc_index
;
5323 bfd_byte reloc_index_raw
[4];
5325 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
5327 plt_offset
+ bed
->plt_reloc_offset
,
5328 sizeof (reloc_index_raw
)))
5329 return (bfd_vma
) -1;
5331 reloc_index
= H_GET_32 (abfd
, reloc_index_raw
);
5332 if (reloc_index
== i
)
5333 return plt
->vma
+ plt_offset
;
5334 plt_offset
+= bed
->plt_entry_size
;
5340 /* Return offset in .plt.bnd section for the Ith GOTPLT relocation with
5341 PLT section, or (bfd_vma) -1 if it should not be included. */
5344 elf_x86_64_plt_sym_val_offset_plt_bnd (bfd_vma i
, const asection
*plt
)
5346 const struct elf_x86_64_backend_data
*bed
= &elf_x86_64_bnd_arch_bed
;
5347 bfd
*abfd
= plt
->owner
;
5348 bfd_vma plt_offset
= bed
->plt_entry_size
;
5350 if (elf_elfheader (abfd
)->e_ident
[EI_OSABI
] != ELFOSABI_GNU
)
5351 return i
* sizeof (elf_x86_64_legacy_plt2_entry
);
5353 while (plt_offset
< plt
->size
)
5355 bfd_vma reloc_index
;
5356 bfd_byte reloc_index_raw
[4];
5358 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
5360 plt_offset
+ bed
->plt_reloc_offset
,
5361 sizeof (reloc_index_raw
)))
5362 return (bfd_vma
) -1;
5364 reloc_index
= H_GET_32 (abfd
, reloc_index_raw
);
5365 if (reloc_index
== i
)
5367 /* This is the index in .plt section. */
5368 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
5369 /* Return the offset in .plt.bnd section. */
5370 return (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
);
5372 plt_offset
+= bed
->plt_entry_size
;
5378 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
5382 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
5389 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5392 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
5396 Elf_Internal_Shdr
*hdr
;
5398 asection
*plt
, *plt_push
;
5400 plt_push
= bfd_get_section_by_name (abfd
, ".plt");
5401 if (plt_push
== NULL
)
5404 plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
5405 /* Use the generic ELF version if there is no .plt.bnd section. */
5407 return _bfd_elf_get_synthetic_symtab (abfd
, symcount
, syms
,
5408 dynsymcount
, dynsyms
, ret
);
5412 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
5415 if (dynsymcount
<= 0)
5418 relplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
5422 hdr
= &elf_section_data (relplt
)->this_hdr
;
5423 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
5424 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
5427 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5428 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
5431 count
= relplt
->size
/ hdr
->sh_entsize
;
5432 size
= count
* sizeof (asymbol
);
5433 p
= relplt
->relocation
;
5434 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
5436 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
5438 size
+= sizeof ("+0x") - 1 + 8 + 8;
5441 s
= *ret
= (asymbol
*) bfd_malloc (size
);
5445 names
= (char *) (s
+ count
);
5446 p
= relplt
->relocation
;
5448 for (i
= 0; i
< count
; i
++, p
++)
5453 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
5454 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
5457 offset
= elf_x86_64_plt_sym_val_offset_plt_bnd (i
, plt_push
);
5459 *s
= **p
->sym_ptr_ptr
;
5460 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
5461 we are defining a symbol, ensure one of them is set. */
5462 if ((s
->flags
& BSF_LOCAL
) == 0)
5463 s
->flags
|= BSF_GLOBAL
;
5464 s
->flags
|= BSF_SYNTHETIC
;
5469 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
5470 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
5476 memcpy (names
, "+0x", sizeof ("+0x") - 1);
5477 names
+= sizeof ("+0x") - 1;
5478 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
5479 for (a
= buf
; *a
== '0'; ++a
)
5482 memcpy (names
, a
, len
);
5485 memcpy (names
, "@plt", sizeof ("@plt"));
5486 names
+= sizeof ("@plt");
5493 /* Handle an x86-64 specific section when reading an object file. This
5494 is called when elfcode.h finds a section with an unknown type. */
5497 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
5498 const char *name
, int shindex
)
5500 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
5503 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
5509 /* Hook called by the linker routine which adds symbols from an object
5510 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
5514 elf_x86_64_add_symbol_hook (bfd
*abfd
,
5515 struct bfd_link_info
*info
,
5516 Elf_Internal_Sym
*sym
,
5517 const char **namep ATTRIBUTE_UNUSED
,
5518 flagword
*flagsp ATTRIBUTE_UNUSED
,
5524 switch (sym
->st_shndx
)
5526 case SHN_X86_64_LCOMMON
:
5527 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
5530 lcomm
= bfd_make_section_with_flags (abfd
,
5534 | SEC_LINKER_CREATED
));
5537 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
5540 *valp
= sym
->st_size
;
5544 if ((ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
5545 || ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
)
5546 && (abfd
->flags
& DYNAMIC
) == 0
5547 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
5548 elf_tdata (info
->output_bfd
)->has_gnu_symbols
= TRUE
;
5554 /* Given a BFD section, try to locate the corresponding ELF section
5558 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
5559 asection
*sec
, int *index_return
)
5561 if (sec
== &_bfd_elf_large_com_section
)
5563 *index_return
= SHN_X86_64_LCOMMON
;
5569 /* Process a symbol. */
5572 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
5575 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
5577 switch (elfsym
->internal_elf_sym
.st_shndx
)
5579 case SHN_X86_64_LCOMMON
:
5580 asym
->section
= &_bfd_elf_large_com_section
;
5581 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
5582 /* Common symbol doesn't set BSF_GLOBAL. */
5583 asym
->flags
&= ~BSF_GLOBAL
;
5589 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
5591 return (sym
->st_shndx
== SHN_COMMON
5592 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
5596 elf_x86_64_common_section_index (asection
*sec
)
5598 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5601 return SHN_X86_64_LCOMMON
;
5605 elf_x86_64_common_section (asection
*sec
)
5607 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5608 return bfd_com_section_ptr
;
5610 return &_bfd_elf_large_com_section
;
5614 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
5615 const Elf_Internal_Sym
*sym
,
5620 const asection
*oldsec
)
5622 /* A normal common symbol and a large common symbol result in a
5623 normal common symbol. We turn the large common symbol into a
5626 && h
->root
.type
== bfd_link_hash_common
5628 && bfd_is_com_section (*psec
)
5631 if (sym
->st_shndx
== SHN_COMMON
5632 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
5634 h
->root
.u
.c
.p
->section
5635 = bfd_make_section_old_way (oldbfd
, "COMMON");
5636 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
5638 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
5639 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
5640 *psec
= bfd_com_section_ptr
;
5647 elf_x86_64_additional_program_headers (bfd
*abfd
,
5648 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
5653 /* Check to see if we need a large readonly segment. */
5654 s
= bfd_get_section_by_name (abfd
, ".lrodata");
5655 if (s
&& (s
->flags
& SEC_LOAD
))
5658 /* Check to see if we need a large data segment. Since .lbss sections
5659 is placed right after the .bss section, there should be no need for
5660 a large data segment just because of .lbss. */
5661 s
= bfd_get_section_by_name (abfd
, ".ldata");
5662 if (s
&& (s
->flags
& SEC_LOAD
))
5668 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5671 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
5673 if (h
->plt
.offset
!= (bfd_vma
) -1
5675 && !h
->pointer_equality_needed
)
5678 return _bfd_elf_hash_symbol (h
);
5681 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
5684 elf_x86_64_relocs_compatible (const bfd_target
*input
,
5685 const bfd_target
*output
)
5687 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
5688 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
5689 && _bfd_elf_relocs_compatible (input
, output
));
5692 static const struct bfd_elf_special_section
5693 elf_x86_64_special_sections
[]=
5695 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5696 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5697 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
5698 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5699 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5700 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5701 { NULL
, 0, 0, 0, 0 }
5704 #define TARGET_LITTLE_SYM x86_64_elf64_vec
5705 #define TARGET_LITTLE_NAME "elf64-x86-64"
5706 #define ELF_ARCH bfd_arch_i386
5707 #define ELF_TARGET_ID X86_64_ELF_DATA
5708 #define ELF_MACHINE_CODE EM_X86_64
5709 #define ELF_MAXPAGESIZE 0x200000
5710 #define ELF_MINPAGESIZE 0x1000
5711 #define ELF_COMMONPAGESIZE 0x1000
5713 #define elf_backend_can_gc_sections 1
5714 #define elf_backend_can_refcount 1
5715 #define elf_backend_want_got_plt 1
5716 #define elf_backend_plt_readonly 1
5717 #define elf_backend_want_plt_sym 0
5718 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
5719 #define elf_backend_rela_normal 1
5720 #define elf_backend_plt_alignment 4
5722 #define elf_info_to_howto elf_x86_64_info_to_howto
5724 #define bfd_elf64_bfd_link_hash_table_create \
5725 elf_x86_64_link_hash_table_create
5726 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
5727 #define bfd_elf64_bfd_reloc_name_lookup \
5728 elf_x86_64_reloc_name_lookup
5730 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
5731 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
5732 #define elf_backend_check_relocs elf_x86_64_check_relocs
5733 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
5734 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
5735 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5736 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
5737 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
5738 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
5739 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
5740 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
5742 #define elf_backend_write_core_note elf_x86_64_write_core_note
5744 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
5745 #define elf_backend_relocate_section elf_x86_64_relocate_section
5746 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
5747 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
5748 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5749 #define elf_backend_plt_sym_val elf_x86_64_plt_sym_val
5750 #define elf_backend_object_p elf64_x86_64_elf_object_p
5751 #define bfd_elf64_mkobject elf_x86_64_mkobject
5752 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
5754 #define elf_backend_section_from_shdr \
5755 elf_x86_64_section_from_shdr
5757 #define elf_backend_section_from_bfd_section \
5758 elf_x86_64_elf_section_from_bfd_section
5759 #define elf_backend_add_symbol_hook \
5760 elf_x86_64_add_symbol_hook
5761 #define elf_backend_symbol_processing \
5762 elf_x86_64_symbol_processing
5763 #define elf_backend_common_section_index \
5764 elf_x86_64_common_section_index
5765 #define elf_backend_common_section \
5766 elf_x86_64_common_section
5767 #define elf_backend_common_definition \
5768 elf_x86_64_common_definition
5769 #define elf_backend_merge_symbol \
5770 elf_x86_64_merge_symbol
5771 #define elf_backend_special_sections \
5772 elf_x86_64_special_sections
5773 #define elf_backend_additional_program_headers \
5774 elf_x86_64_additional_program_headers
5775 #define elf_backend_hash_symbol \
5776 elf_x86_64_hash_symbol
5778 #include "elf64-target.h"
5780 /* FreeBSD support. */
5782 #undef TARGET_LITTLE_SYM
5783 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
5784 #undef TARGET_LITTLE_NAME
5785 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
5788 #define ELF_OSABI ELFOSABI_FREEBSD
5791 #define elf64_bed elf64_x86_64_fbsd_bed
5793 #include "elf64-target.h"
5795 /* Solaris 2 support. */
5797 #undef TARGET_LITTLE_SYM
5798 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
5799 #undef TARGET_LITTLE_NAME
5800 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5802 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5803 objects won't be recognized. */
5807 #define elf64_bed elf64_x86_64_sol2_bed
5809 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5811 #undef elf_backend_static_tls_alignment
5812 #define elf_backend_static_tls_alignment 16
5814 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5816 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5818 #undef elf_backend_want_plt_sym
5819 #define elf_backend_want_plt_sym 1
5821 #include "elf64-target.h"
5823 #undef bfd_elf64_get_synthetic_symtab
5825 /* Native Client support. */
5828 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
5830 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
5831 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
5835 #undef TARGET_LITTLE_SYM
5836 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
5837 #undef TARGET_LITTLE_NAME
5838 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
5840 #define elf64_bed elf64_x86_64_nacl_bed
5842 #undef ELF_MAXPAGESIZE
5843 #undef ELF_MINPAGESIZE
5844 #undef ELF_COMMONPAGESIZE
5845 #define ELF_MAXPAGESIZE 0x10000
5846 #define ELF_MINPAGESIZE 0x10000
5847 #define ELF_COMMONPAGESIZE 0x10000
5849 /* Restore defaults. */
5851 #undef elf_backend_static_tls_alignment
5852 #undef elf_backend_want_plt_sym
5853 #define elf_backend_want_plt_sym 0
5855 /* NaCl uses substantially different PLT entries for the same effects. */
5857 #undef elf_backend_plt_alignment
5858 #define elf_backend_plt_alignment 5
5859 #define NACL_PLT_ENTRY_SIZE 64
5860 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
5862 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
5864 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
5865 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
5866 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
5867 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5868 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5870 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
5871 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
5873 /* 32 bytes of nop to pad out to the standard size. */
5874 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5875 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5876 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5877 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5878 0x66, /* excess data32 prefix */
5882 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
5884 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
5885 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
5886 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5887 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5889 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
5890 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5891 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5893 /* Lazy GOT entries point here (32-byte aligned). */
5894 0x68, /* pushq immediate */
5895 0, 0, 0, 0, /* replaced with index into relocation table. */
5896 0xe9, /* jmp relative */
5897 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
5899 /* 22 bytes of nop to pad out to the standard size. */
5900 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5901 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5902 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
5905 /* .eh_frame covering the .plt section. */
5907 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
5909 #if (PLT_CIE_LENGTH != 20 \
5910 || PLT_FDE_LENGTH != 36 \
5911 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
5912 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5913 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
5915 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
5916 0, 0, 0, 0, /* CIE ID */
5917 1, /* CIE version */
5918 'z', 'R', 0, /* Augmentation string */
5919 1, /* Code alignment factor */
5920 0x78, /* Data alignment factor */
5921 16, /* Return address column */
5922 1, /* Augmentation size */
5923 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
5924 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5925 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
5926 DW_CFA_nop
, DW_CFA_nop
,
5928 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
5929 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
5930 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
5931 0, 0, 0, 0, /* .plt size goes here */
5932 0, /* Augmentation size */
5933 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
5934 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5935 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
5936 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5937 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
5938 13, /* Block length */
5939 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
5940 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
5941 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
5942 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
5943 DW_CFA_nop
, DW_CFA_nop
5946 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
5948 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
5949 elf_x86_64_nacl_plt_entry
, /* plt_entry */
5950 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
5951 2, /* plt0_got1_offset */
5952 9, /* plt0_got2_offset */
5953 13, /* plt0_got2_insn_end */
5954 3, /* plt_got_offset */
5955 33, /* plt_reloc_offset */
5956 38, /* plt_plt_offset */
5957 7, /* plt_got_insn_size */
5958 42, /* plt_plt_insn_end */
5959 32, /* plt_lazy_offset */
5960 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
5961 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
5964 #undef elf_backend_arch_data
5965 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
5967 #undef elf_backend_object_p
5968 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
5969 #undef elf_backend_modify_segment_map
5970 #define elf_backend_modify_segment_map nacl_modify_segment_map
5971 #undef elf_backend_modify_program_headers
5972 #define elf_backend_modify_program_headers nacl_modify_program_headers
5973 #undef elf_backend_final_write_processing
5974 #define elf_backend_final_write_processing nacl_final_write_processing
5976 #include "elf64-target.h"
5978 /* Native Client x32 support. */
5981 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
5983 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
5984 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
5988 #undef TARGET_LITTLE_SYM
5989 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
5990 #undef TARGET_LITTLE_NAME
5991 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
5993 #define elf32_bed elf32_x86_64_nacl_bed
5995 #define bfd_elf32_bfd_link_hash_table_create \
5996 elf_x86_64_link_hash_table_create
5997 #define bfd_elf32_bfd_reloc_type_lookup \
5998 elf_x86_64_reloc_type_lookup
5999 #define bfd_elf32_bfd_reloc_name_lookup \
6000 elf_x86_64_reloc_name_lookup
6001 #define bfd_elf32_mkobject \
6004 #undef elf_backend_object_p
6005 #define elf_backend_object_p \
6006 elf32_x86_64_nacl_elf_object_p
6008 #undef elf_backend_bfd_from_remote_memory
6009 #define elf_backend_bfd_from_remote_memory \
6010 _bfd_elf32_bfd_from_remote_memory
6012 #undef elf_backend_size_info
6013 #define elf_backend_size_info \
6014 _bfd_elf32_size_info
6016 #include "elf32-target.h"
6018 /* Restore defaults. */
6019 #undef elf_backend_object_p
6020 #define elf_backend_object_p elf64_x86_64_elf_object_p
6021 #undef elf_backend_bfd_from_remote_memory
6022 #undef elf_backend_size_info
6023 #undef elf_backend_modify_segment_map
6024 #undef elf_backend_modify_program_headers
6025 #undef elf_backend_final_write_processing
6027 /* Intel L1OM support. */
6030 elf64_l1om_elf_object_p (bfd
*abfd
)
6032 /* Set the right machine number for an L1OM elf64 file. */
6033 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6037 #undef TARGET_LITTLE_SYM
6038 #define TARGET_LITTLE_SYM l1om_elf64_vec
6039 #undef TARGET_LITTLE_NAME
6040 #define TARGET_LITTLE_NAME "elf64-l1om"
6042 #define ELF_ARCH bfd_arch_l1om
6044 #undef ELF_MACHINE_CODE
6045 #define ELF_MACHINE_CODE EM_L1OM
6050 #define elf64_bed elf64_l1om_bed
6052 #undef elf_backend_object_p
6053 #define elf_backend_object_p elf64_l1om_elf_object_p
6055 /* Restore defaults. */
6056 #undef ELF_MAXPAGESIZE
6057 #undef ELF_MINPAGESIZE
6058 #undef ELF_COMMONPAGESIZE
6059 #define ELF_MAXPAGESIZE 0x200000
6060 #define ELF_MINPAGESIZE 0x1000
6061 #define ELF_COMMONPAGESIZE 0x1000
6062 #undef elf_backend_plt_alignment
6063 #define elf_backend_plt_alignment 4
6064 #undef elf_backend_arch_data
6065 #define elf_backend_arch_data &elf_x86_64_arch_bed
6067 #include "elf64-target.h"
6069 /* FreeBSD L1OM support. */
6071 #undef TARGET_LITTLE_SYM
6072 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6073 #undef TARGET_LITTLE_NAME
6074 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6077 #define ELF_OSABI ELFOSABI_FREEBSD
6080 #define elf64_bed elf64_l1om_fbsd_bed
6082 #include "elf64-target.h"
6084 /* Intel K1OM support. */
6087 elf64_k1om_elf_object_p (bfd
*abfd
)
6089 /* Set the right machine number for an K1OM elf64 file. */
6090 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
6094 #undef TARGET_LITTLE_SYM
6095 #define TARGET_LITTLE_SYM k1om_elf64_vec
6096 #undef TARGET_LITTLE_NAME
6097 #define TARGET_LITTLE_NAME "elf64-k1om"
6099 #define ELF_ARCH bfd_arch_k1om
6101 #undef ELF_MACHINE_CODE
6102 #define ELF_MACHINE_CODE EM_K1OM
6107 #define elf64_bed elf64_k1om_bed
6109 #undef elf_backend_object_p
6110 #define elf_backend_object_p elf64_k1om_elf_object_p
6112 #undef elf_backend_static_tls_alignment
6114 #undef elf_backend_want_plt_sym
6115 #define elf_backend_want_plt_sym 0
6117 #include "elf64-target.h"
6119 /* FreeBSD K1OM support. */
6121 #undef TARGET_LITTLE_SYM
6122 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
6123 #undef TARGET_LITTLE_NAME
6124 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
6127 #define ELF_OSABI ELFOSABI_FREEBSD
6130 #define elf64_bed elf64_k1om_fbsd_bed
6132 #include "elf64-target.h"
6134 /* 32bit x86-64 support. */
6136 #undef TARGET_LITTLE_SYM
6137 #define TARGET_LITTLE_SYM x86_64_elf32_vec
6138 #undef TARGET_LITTLE_NAME
6139 #define TARGET_LITTLE_NAME "elf32-x86-64"
6143 #define ELF_ARCH bfd_arch_i386
6145 #undef ELF_MACHINE_CODE
6146 #define ELF_MACHINE_CODE EM_X86_64
6150 #undef elf_backend_object_p
6151 #define elf_backend_object_p \
6152 elf32_x86_64_elf_object_p
6154 #undef elf_backend_bfd_from_remote_memory
6155 #define elf_backend_bfd_from_remote_memory \
6156 _bfd_elf32_bfd_from_remote_memory
6158 #undef elf_backend_size_info
6159 #define elf_backend_size_info \
6160 _bfd_elf32_size_info
6162 #include "elf32-target.h"