1 /* X86-64 specific support for ELF
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4 Free Software Foundation, Inc.
5 Contributed by Jan Hubicka <jh@suse.cz>.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
29 #include "bfd_stdint.h"
33 #include "libiberty.h"
35 #include "elf/x86-64.h"
42 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
43 #define MINUS_ONE (~ (bfd_vma) 0)
45 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
46 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
47 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
48 since they are the same. */
50 #define ABI_64_P(abfd) \
51 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
53 /* The relocation "howto" table. Order of fields:
54 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
55 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
56 static reloc_howto_type x86_64_elf_howto_table
[] =
58 HOWTO(R_X86_64_NONE
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
59 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
61 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
62 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
64 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
65 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
67 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
68 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
70 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
71 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
73 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
74 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
76 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
77 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
79 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
80 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
82 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
83 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
85 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
86 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
88 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
89 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
91 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
92 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
94 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
95 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
96 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
97 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
98 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
100 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
101 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
102 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
103 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
105 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
106 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
108 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
109 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
111 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
112 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
114 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
115 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
117 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
118 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
120 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
121 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
123 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
124 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
126 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
129 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
130 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
131 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
132 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
133 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
134 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
135 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
136 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
138 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
139 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
141 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
142 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
143 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
144 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
145 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
147 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
148 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
152 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
153 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
154 "R_X86_64_GOTPC32_TLSDESC",
155 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
156 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
157 complain_overflow_dont
, bfd_elf_generic_reloc
,
158 "R_X86_64_TLSDESC_CALL",
160 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
161 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
163 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
164 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
165 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
167 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
168 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
171 /* We have a gap in the reloc numbers here.
172 R_X86_64_standard counts the number up to this point, and
173 R_X86_64_vt_offset is the value to subtract from a reloc type of
174 R_X86_64_GNU_VT* to form an index into this table. */
175 #define R_X86_64_standard (R_X86_64_IRELATIVE + 1)
176 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
178 /* GNU extension to record C++ vtable hierarchy. */
179 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
180 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
182 /* GNU extension to record C++ vtable member usage. */
183 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
184 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
187 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
188 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
189 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
193 #define IS_X86_64_PCREL_TYPE(TYPE) \
194 ( ((TYPE) == R_X86_64_PC8) \
195 || ((TYPE) == R_X86_64_PC16) \
196 || ((TYPE) == R_X86_64_PC32) \
197 || ((TYPE) == R_X86_64_PC64))
199 /* Map BFD relocs to the x86_64 elf relocs. */
202 bfd_reloc_code_real_type bfd_reloc_val
;
203 unsigned char elf_reloc_val
;
206 static const struct elf_reloc_map x86_64_reloc_map
[] =
208 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
209 { BFD_RELOC_64
, R_X86_64_64
, },
210 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
211 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
212 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
213 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
214 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
215 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
216 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
217 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
218 { BFD_RELOC_32
, R_X86_64_32
, },
219 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
220 { BFD_RELOC_16
, R_X86_64_16
, },
221 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
222 { BFD_RELOC_8
, R_X86_64_8
, },
223 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
224 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
225 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
226 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
227 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
228 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
229 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
230 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
231 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
232 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
233 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
234 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
235 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
236 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
237 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
238 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
239 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
240 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
241 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
242 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
243 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
244 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
245 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
248 static reloc_howto_type
*
249 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
253 if (r_type
== (unsigned int) R_X86_64_32
)
258 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
260 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
261 || r_type
>= (unsigned int) R_X86_64_max
)
263 if (r_type
>= (unsigned int) R_X86_64_standard
)
265 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
267 r_type
= R_X86_64_NONE
;
272 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
273 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
274 return &x86_64_elf_howto_table
[i
];
277 /* Given a BFD reloc type, return a HOWTO structure. */
278 static reloc_howto_type
*
279 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
280 bfd_reloc_code_real_type code
)
284 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
287 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
288 return elf_x86_64_rtype_to_howto (abfd
,
289 x86_64_reloc_map
[i
].elf_reloc_val
);
294 static reloc_howto_type
*
295 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
300 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
302 /* Get x32 R_X86_64_32. */
303 reloc_howto_type
*reloc
304 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
305 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
309 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
310 if (x86_64_elf_howto_table
[i
].name
!= NULL
311 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
312 return &x86_64_elf_howto_table
[i
];
317 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
320 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
321 Elf_Internal_Rela
*dst
)
325 r_type
= ELF32_R_TYPE (dst
->r_info
);
326 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
327 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
330 /* Support for core dump NOTE sections. */
332 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
337 switch (note
->descsz
)
342 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
344 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
347 elf_tdata (abfd
)->core_lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
355 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
357 elf_tdata (abfd
)->core_signal
358 = bfd_get_16 (abfd
, note
->descdata
+ 12);
361 elf_tdata (abfd
)->core_lwpid
362 = bfd_get_32 (abfd
, note
->descdata
+ 32);
371 /* Make a ".reg/999" section. */
372 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
373 size
, note
->descpos
+ offset
);
377 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
379 switch (note
->descsz
)
384 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
385 elf_tdata (abfd
)->core_pid
386 = bfd_get_32 (abfd
, note
->descdata
+ 12);
387 elf_tdata (abfd
)->core_program
388 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
389 elf_tdata (abfd
)->core_command
390 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
393 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
394 elf_tdata (abfd
)->core_pid
395 = bfd_get_32 (abfd
, note
->descdata
+ 24);
396 elf_tdata (abfd
)->core_program
397 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
398 elf_tdata (abfd
)->core_command
399 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
402 /* Note that for some reason, a spurious space is tacked
403 onto the end of the args in some (at least one anyway)
404 implementations, so strip it off if it exists. */
407 char *command
= elf_tdata (abfd
)->core_command
;
408 int n
= strlen (command
);
410 if (0 < n
&& command
[n
- 1] == ' ')
411 command
[n
- 1] = '\0';
419 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
422 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
426 const char *fname
, *psargs
;
437 va_start (ap
, note_type
);
438 fname
= va_arg (ap
, const char *);
439 psargs
= va_arg (ap
, const char *);
442 if (bed
->s
->elfclass
== ELFCLASS32
)
445 memset (&data
, 0, sizeof (data
));
446 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
447 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
448 p
= (const void *) &data
;
449 size
= sizeof (data
);
454 memset (&data
, 0, sizeof (data
));
455 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
456 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
457 p
= (const void *) &data
;
458 size
= sizeof (data
);
463 va_start (ap
, note_type
);
464 pid
= va_arg (ap
, long);
465 cursig
= va_arg (ap
, int);
466 gregs
= va_arg (ap
, const void *);
469 if (bed
->s
->elfclass
== ELFCLASS32
)
471 if (bed
->elf_machine_code
== EM_X86_64
)
473 prstatusx32_t prstat
;
474 memset (&prstat
, 0, sizeof (prstat
));
476 prstat
.pr_cursig
= cursig
;
477 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
478 p
= (const void *) &prstat
;
479 size
= sizeof (prstat
);
484 memset (&prstat
, 0, sizeof (prstat
));
486 prstat
.pr_cursig
= cursig
;
487 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
488 p
= (const void *) &prstat
;
489 size
= sizeof (prstat
);
495 memset (&prstat
, 0, sizeof (prstat
));
497 prstat
.pr_cursig
= cursig
;
498 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
499 p
= (const void *) &prstat
;
500 size
= sizeof (prstat
);
505 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
, p
,
510 /* Functions for the x86-64 ELF linker. */
512 /* The name of the dynamic interpreter. This is put in the .interp
515 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
516 #define ELF32_DYNAMIC_INTERPRETER "/lib/ld32.so.1"
518 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
519 copying dynamic variables from a shared lib into an app's dynbss
520 section, and instead use a dynamic relocation to point into the
522 #define ELIMINATE_COPY_RELOCS 1
524 /* The size in bytes of an entry in the global offset table. */
526 #define GOT_ENTRY_SIZE 8
528 /* The size in bytes of an entry in the procedure linkage table. */
530 #define PLT_ENTRY_SIZE 16
532 /* The first entry in a procedure linkage table looks like this. See the
533 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
535 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
537 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
538 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
539 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
542 /* Subsequent entries in a procedure linkage table look like this. */
544 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
546 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
547 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
548 0x68, /* pushq immediate */
549 0, 0, 0, 0, /* replaced with index into relocation table. */
550 0xe9, /* jmp relative */
551 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
554 /* .eh_frame covering the .plt section. */
556 static const bfd_byte elf_x86_64_eh_frame_plt
[] =
558 #define PLT_CIE_LENGTH 20
559 #define PLT_FDE_LENGTH 36
560 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
561 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
562 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
563 0, 0, 0, 0, /* CIE ID */
565 'z', 'R', 0, /* Augmentation string */
566 1, /* Code alignment factor */
567 0x78, /* Data alignment factor */
568 16, /* Return address column */
569 1, /* Augmentation size */
570 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
571 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
572 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
573 DW_CFA_nop
, DW_CFA_nop
,
575 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
576 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
577 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
578 0, 0, 0, 0, /* .plt size goes here */
579 0, /* Augmentation size */
580 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
581 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
582 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
583 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
584 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
585 11, /* Block length */
586 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
587 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
588 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
589 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
590 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
593 /* x86-64 ELF linker hash entry. */
595 struct elf_x86_64_link_hash_entry
597 struct elf_link_hash_entry elf
;
599 /* Track dynamic relocs copied for this symbol. */
600 struct elf_dyn_relocs
*dyn_relocs
;
602 #define GOT_UNKNOWN 0
606 #define GOT_TLS_GDESC 4
607 #define GOT_TLS_GD_BOTH_P(type) \
608 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
609 #define GOT_TLS_GD_P(type) \
610 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
611 #define GOT_TLS_GDESC_P(type) \
612 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
613 #define GOT_TLS_GD_ANY_P(type) \
614 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
615 unsigned char tls_type
;
617 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
618 starting at the end of the jump table. */
622 #define elf_x86_64_hash_entry(ent) \
623 ((struct elf_x86_64_link_hash_entry *)(ent))
625 struct elf_x86_64_obj_tdata
627 struct elf_obj_tdata root
;
629 /* tls_type for each local got entry. */
630 char *local_got_tls_type
;
632 /* GOTPLT entries for TLS descriptors. */
633 bfd_vma
*local_tlsdesc_gotent
;
636 #define elf_x86_64_tdata(abfd) \
637 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
639 #define elf_x86_64_local_got_tls_type(abfd) \
640 (elf_x86_64_tdata (abfd)->local_got_tls_type)
642 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
643 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
645 #define is_x86_64_elf(bfd) \
646 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
647 && elf_tdata (bfd) != NULL \
648 && elf_object_id (bfd) == X86_64_ELF_DATA)
651 elf_x86_64_mkobject (bfd
*abfd
)
653 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
657 /* x86-64 ELF linker hash table. */
659 struct elf_x86_64_link_hash_table
661 struct elf_link_hash_table elf
;
663 /* Short-cuts to get to dynamic linker sections. */
666 asection
*plt_eh_frame
;
670 bfd_signed_vma refcount
;
674 /* The amount of space used by the jump slots in the GOT. */
675 bfd_vma sgotplt_jump_table_size
;
677 /* Small local sym cache. */
678 struct sym_cache sym_cache
;
680 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
681 bfd_vma (*r_sym
) (bfd_vma
);
682 unsigned int pointer_r_type
;
683 const char *dynamic_interpreter
;
684 int dynamic_interpreter_size
;
686 /* _TLS_MODULE_BASE_ symbol. */
687 struct bfd_link_hash_entry
*tls_module_base
;
689 /* Used by local STT_GNU_IFUNC symbols. */
690 htab_t loc_hash_table
;
691 void * loc_hash_memory
;
693 /* The offset into splt of the PLT entry for the TLS descriptor
694 resolver. Special values are 0, if not necessary (or not found
695 to be necessary yet), and -1 if needed but not determined
698 /* The offset into sgot of the GOT entry used by the PLT entry
702 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
703 bfd_vma next_jump_slot_index
;
704 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
705 bfd_vma next_irelative_index
;
708 /* Get the x86-64 ELF linker hash table from a link_info structure. */
710 #define elf_x86_64_hash_table(p) \
711 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
712 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
714 #define elf_x86_64_compute_jump_table_size(htab) \
715 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
717 /* Create an entry in an x86-64 ELF linker hash table. */
719 static struct bfd_hash_entry
*
720 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
721 struct bfd_hash_table
*table
,
724 /* Allocate the structure if it has not already been allocated by a
728 entry
= (struct bfd_hash_entry
*)
729 bfd_hash_allocate (table
,
730 sizeof (struct elf_x86_64_link_hash_entry
));
735 /* Call the allocation method of the superclass. */
736 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
739 struct elf_x86_64_link_hash_entry
*eh
;
741 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
742 eh
->dyn_relocs
= NULL
;
743 eh
->tls_type
= GOT_UNKNOWN
;
744 eh
->tlsdesc_got
= (bfd_vma
) -1;
750 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
751 for local symbol so that we can handle local STT_GNU_IFUNC symbols
752 as global symbol. We reuse indx and dynstr_index for local symbol
753 hash since they aren't used by global symbols in this backend. */
756 elf_x86_64_local_htab_hash (const void *ptr
)
758 struct elf_link_hash_entry
*h
759 = (struct elf_link_hash_entry
*) ptr
;
760 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
763 /* Compare local hash entries. */
766 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
768 struct elf_link_hash_entry
*h1
769 = (struct elf_link_hash_entry
*) ptr1
;
770 struct elf_link_hash_entry
*h2
771 = (struct elf_link_hash_entry
*) ptr2
;
773 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
776 /* Find and/or create a hash entry for local symbol. */
778 static struct elf_link_hash_entry
*
779 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
780 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
783 struct elf_x86_64_link_hash_entry e
, *ret
;
784 asection
*sec
= abfd
->sections
;
785 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
786 htab
->r_sym (rel
->r_info
));
789 e
.elf
.indx
= sec
->id
;
790 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
791 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
792 create
? INSERT
: NO_INSERT
);
799 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
803 ret
= (struct elf_x86_64_link_hash_entry
*)
804 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
805 sizeof (struct elf_x86_64_link_hash_entry
));
808 memset (ret
, 0, sizeof (*ret
));
809 ret
->elf
.indx
= sec
->id
;
810 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
811 ret
->elf
.dynindx
= -1;
817 /* Create an X86-64 ELF linker hash table. */
819 static struct bfd_link_hash_table
*
820 elf_x86_64_link_hash_table_create (bfd
*abfd
)
822 struct elf_x86_64_link_hash_table
*ret
;
823 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
825 ret
= (struct elf_x86_64_link_hash_table
*) bfd_malloc (amt
);
829 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
830 elf_x86_64_link_hash_newfunc
,
831 sizeof (struct elf_x86_64_link_hash_entry
),
840 ret
->plt_eh_frame
= NULL
;
841 ret
->sym_cache
.abfd
= NULL
;
842 ret
->tlsdesc_plt
= 0;
843 ret
->tlsdesc_got
= 0;
844 ret
->tls_ld_got
.refcount
= 0;
845 ret
->sgotplt_jump_table_size
= 0;
846 ret
->tls_module_base
= NULL
;
847 ret
->next_jump_slot_index
= 0;
848 ret
->next_irelative_index
= 0;
852 ret
->r_info
= elf64_r_info
;
853 ret
->r_sym
= elf64_r_sym
;
854 ret
->pointer_r_type
= R_X86_64_64
;
855 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
856 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
860 ret
->r_info
= elf32_r_info
;
861 ret
->r_sym
= elf32_r_sym
;
862 ret
->pointer_r_type
= R_X86_64_32
;
863 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
864 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
867 ret
->loc_hash_table
= htab_try_create (1024,
868 elf_x86_64_local_htab_hash
,
869 elf_x86_64_local_htab_eq
,
871 ret
->loc_hash_memory
= objalloc_create ();
872 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
878 return &ret
->elf
.root
;
881 /* Destroy an X86-64 ELF linker hash table. */
884 elf_x86_64_link_hash_table_free (struct bfd_link_hash_table
*hash
)
886 struct elf_x86_64_link_hash_table
*htab
887 = (struct elf_x86_64_link_hash_table
*) hash
;
889 if (htab
->loc_hash_table
)
890 htab_delete (htab
->loc_hash_table
);
891 if (htab
->loc_hash_memory
)
892 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
893 _bfd_generic_link_hash_table_free (hash
);
896 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
897 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
901 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
902 struct bfd_link_info
*info
)
904 struct elf_x86_64_link_hash_table
*htab
;
906 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
909 htab
= elf_x86_64_hash_table (info
);
913 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
915 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rela.bss");
918 || (!info
->shared
&& !htab
->srelbss
))
921 if (!info
->no_ld_generated_unwind_info
922 && bfd_get_section_by_name (dynobj
, ".eh_frame") == NULL
923 && htab
->elf
.splt
!= NULL
)
925 flagword flags
= get_elf_backend_data (dynobj
)->dynamic_sec_flags
;
927 = bfd_make_section_with_flags (dynobj
, ".eh_frame",
928 flags
| SEC_READONLY
);
929 if (htab
->plt_eh_frame
== NULL
930 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
933 htab
->plt_eh_frame
->size
= sizeof (elf_x86_64_eh_frame_plt
);
934 htab
->plt_eh_frame
->contents
935 = bfd_alloc (dynobj
, htab
->plt_eh_frame
->size
);
936 memcpy (htab
->plt_eh_frame
->contents
, elf_x86_64_eh_frame_plt
,
937 sizeof (elf_x86_64_eh_frame_plt
));
942 /* Copy the extra info we tack onto an elf_link_hash_entry. */
945 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
946 struct elf_link_hash_entry
*dir
,
947 struct elf_link_hash_entry
*ind
)
949 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
951 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
952 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
954 if (eind
->dyn_relocs
!= NULL
)
956 if (edir
->dyn_relocs
!= NULL
)
958 struct elf_dyn_relocs
**pp
;
959 struct elf_dyn_relocs
*p
;
961 /* Add reloc counts against the indirect sym to the direct sym
962 list. Merge any entries against the same section. */
963 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
965 struct elf_dyn_relocs
*q
;
967 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
968 if (q
->sec
== p
->sec
)
970 q
->pc_count
+= p
->pc_count
;
971 q
->count
+= p
->count
;
978 *pp
= edir
->dyn_relocs
;
981 edir
->dyn_relocs
= eind
->dyn_relocs
;
982 eind
->dyn_relocs
= NULL
;
985 if (ind
->root
.type
== bfd_link_hash_indirect
986 && dir
->got
.refcount
<= 0)
988 edir
->tls_type
= eind
->tls_type
;
989 eind
->tls_type
= GOT_UNKNOWN
;
992 if (ELIMINATE_COPY_RELOCS
993 && ind
->root
.type
!= bfd_link_hash_indirect
994 && dir
->dynamic_adjusted
)
996 /* If called to transfer flags for a weakdef during processing
997 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
998 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
999 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1000 dir
->ref_regular
|= ind
->ref_regular
;
1001 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1002 dir
->needs_plt
|= ind
->needs_plt
;
1003 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1006 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1010 elf64_x86_64_elf_object_p (bfd
*abfd
)
1012 /* Set the right machine number for an x86-64 elf64 file. */
1013 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1017 /* Return TRUE if the TLS access code sequence support transition
1021 elf_x86_64_check_tls_transition (bfd
*abfd
,
1022 struct bfd_link_info
*info
,
1025 Elf_Internal_Shdr
*symtab_hdr
,
1026 struct elf_link_hash_entry
**sym_hashes
,
1027 unsigned int r_type
,
1028 const Elf_Internal_Rela
*rel
,
1029 const Elf_Internal_Rela
*relend
)
1032 unsigned long r_symndx
;
1033 struct elf_link_hash_entry
*h
;
1035 struct elf_x86_64_link_hash_table
*htab
;
1037 /* Get the section contents. */
1038 if (contents
== NULL
)
1040 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1041 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1044 /* FIXME: How to better handle error condition? */
1045 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1048 /* Cache the section contents for elf_link_input_bfd. */
1049 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1053 htab
= elf_x86_64_hash_table (info
);
1054 offset
= rel
->r_offset
;
1057 case R_X86_64_TLSGD
:
1058 case R_X86_64_TLSLD
:
1059 if ((rel
+ 1) >= relend
)
1062 if (r_type
== R_X86_64_TLSGD
)
1064 /* Check transition from GD access model. For 64bit, only
1065 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1066 .word 0x6666; rex64; call __tls_get_addr
1067 can transit to different access model. For 32bit, only
1068 leaq foo@tlsgd(%rip), %rdi
1069 .word 0x6666; rex64; call __tls_get_addr
1070 can transit to different access model. */
1072 static const unsigned char call
[] = { 0x66, 0x66, 0x48, 0xe8 };
1073 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1075 if ((offset
+ 12) > sec
->size
1076 || memcmp (contents
+ offset
+ 4, call
, 4) != 0)
1079 if (ABI_64_P (abfd
))
1082 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1088 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1094 /* Check transition from LD access model. Only
1095 leaq foo@tlsld(%rip), %rdi;
1097 can transit to different access model. */
1099 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1101 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1104 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0
1105 || 0xe8 != *(contents
+ offset
+ 4))
1109 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1110 if (r_symndx
< symtab_hdr
->sh_info
)
1113 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1114 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1115 may be versioned. */
1117 && h
->root
.root
.string
!= NULL
1118 && (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1119 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
)
1120 && (strncmp (h
->root
.root
.string
,
1121 "__tls_get_addr", 14) == 0));
1123 case R_X86_64_GOTTPOFF
:
1124 /* Check transition from IE access model:
1125 mov foo@gottpoff(%rip), %reg
1126 add foo@gottpoff(%rip), %reg
1129 /* Check REX prefix first. */
1130 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1132 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1133 if (val
!= 0x48 && val
!= 0x4c)
1135 /* X32 may have 0x44 REX prefix or no REX prefix. */
1136 if (ABI_64_P (abfd
))
1142 /* X32 may not have any REX prefix. */
1143 if (ABI_64_P (abfd
))
1145 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1149 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1150 if (val
!= 0x8b && val
!= 0x03)
1153 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1154 return (val
& 0xc7) == 5;
1156 case R_X86_64_GOTPC32_TLSDESC
:
1157 /* Check transition from GDesc access model:
1158 leaq x@tlsdesc(%rip), %rax
1160 Make sure it's a leaq adding rip to a 32-bit offset
1161 into any register, although it's probably almost always
1164 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1167 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1168 if ((val
& 0xfb) != 0x48)
1171 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1174 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1175 return (val
& 0xc7) == 0x05;
1177 case R_X86_64_TLSDESC_CALL
:
1178 /* Check transition from GDesc access model:
1179 call *x@tlsdesc(%rax)
1181 if (offset
+ 2 <= sec
->size
)
1183 /* Make sure that it's a call *x@tlsdesc(%rax). */
1184 static const unsigned char call
[] = { 0xff, 0x10 };
1185 return memcmp (contents
+ offset
, call
, 2) == 0;
1195 /* Return TRUE if the TLS access transition is OK or no transition
1196 will be performed. Update R_TYPE if there is a transition. */
1199 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1200 asection
*sec
, bfd_byte
*contents
,
1201 Elf_Internal_Shdr
*symtab_hdr
,
1202 struct elf_link_hash_entry
**sym_hashes
,
1203 unsigned int *r_type
, int tls_type
,
1204 const Elf_Internal_Rela
*rel
,
1205 const Elf_Internal_Rela
*relend
,
1206 struct elf_link_hash_entry
*h
,
1207 unsigned long r_symndx
)
1209 unsigned int from_type
= *r_type
;
1210 unsigned int to_type
= from_type
;
1211 bfd_boolean check
= TRUE
;
1213 /* Skip TLS transition for functions. */
1215 && (h
->type
== STT_FUNC
1216 || h
->type
== STT_GNU_IFUNC
))
1221 case R_X86_64_TLSGD
:
1222 case R_X86_64_GOTPC32_TLSDESC
:
1223 case R_X86_64_TLSDESC_CALL
:
1224 case R_X86_64_GOTTPOFF
:
1225 if (info
->executable
)
1228 to_type
= R_X86_64_TPOFF32
;
1230 to_type
= R_X86_64_GOTTPOFF
;
1233 /* When we are called from elf_x86_64_relocate_section,
1234 CONTENTS isn't NULL and there may be additional transitions
1235 based on TLS_TYPE. */
1236 if (contents
!= NULL
)
1238 unsigned int new_to_type
= to_type
;
1240 if (info
->executable
1243 && tls_type
== GOT_TLS_IE
)
1244 new_to_type
= R_X86_64_TPOFF32
;
1246 if (to_type
== R_X86_64_TLSGD
1247 || to_type
== R_X86_64_GOTPC32_TLSDESC
1248 || to_type
== R_X86_64_TLSDESC_CALL
)
1250 if (tls_type
== GOT_TLS_IE
)
1251 new_to_type
= R_X86_64_GOTTPOFF
;
1254 /* We checked the transition before when we were called from
1255 elf_x86_64_check_relocs. We only want to check the new
1256 transition which hasn't been checked before. */
1257 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1258 to_type
= new_to_type
;
1263 case R_X86_64_TLSLD
:
1264 if (info
->executable
)
1265 to_type
= R_X86_64_TPOFF32
;
1272 /* Return TRUE if there is no transition. */
1273 if (from_type
== to_type
)
1276 /* Check if the transition can be performed. */
1278 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1279 symtab_hdr
, sym_hashes
,
1280 from_type
, rel
, relend
))
1282 reloc_howto_type
*from
, *to
;
1285 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1286 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1289 name
= h
->root
.root
.string
;
1292 struct elf_x86_64_link_hash_table
*htab
;
1294 htab
= elf_x86_64_hash_table (info
);
1299 Elf_Internal_Sym
*isym
;
1301 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1303 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1307 (*_bfd_error_handler
)
1308 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1309 "in section `%A' failed"),
1310 abfd
, sec
, from
->name
, to
->name
, name
,
1311 (unsigned long) rel
->r_offset
);
1312 bfd_set_error (bfd_error_bad_value
);
1320 /* Look through the relocs for a section during the first phase, and
1321 calculate needed space in the global offset table, procedure
1322 linkage table, and dynamic reloc sections. */
1325 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1327 const Elf_Internal_Rela
*relocs
)
1329 struct elf_x86_64_link_hash_table
*htab
;
1330 Elf_Internal_Shdr
*symtab_hdr
;
1331 struct elf_link_hash_entry
**sym_hashes
;
1332 const Elf_Internal_Rela
*rel
;
1333 const Elf_Internal_Rela
*rel_end
;
1336 if (info
->relocatable
)
1339 BFD_ASSERT (is_x86_64_elf (abfd
));
1341 htab
= elf_x86_64_hash_table (info
);
1345 symtab_hdr
= &elf_symtab_hdr (abfd
);
1346 sym_hashes
= elf_sym_hashes (abfd
);
1350 rel_end
= relocs
+ sec
->reloc_count
;
1351 for (rel
= relocs
; rel
< rel_end
; rel
++)
1353 unsigned int r_type
;
1354 unsigned long r_symndx
;
1355 struct elf_link_hash_entry
*h
;
1356 Elf_Internal_Sym
*isym
;
1359 r_symndx
= htab
->r_sym (rel
->r_info
);
1360 r_type
= ELF32_R_TYPE (rel
->r_info
);
1362 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1364 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1369 if (r_symndx
< symtab_hdr
->sh_info
)
1371 /* A local symbol. */
1372 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1377 /* Check relocation against local STT_GNU_IFUNC symbol. */
1378 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1380 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
1385 /* Fake a STT_GNU_IFUNC symbol. */
1386 h
->type
= STT_GNU_IFUNC
;
1389 h
->forced_local
= 1;
1390 h
->root
.type
= bfd_link_hash_defined
;
1398 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1399 while (h
->root
.type
== bfd_link_hash_indirect
1400 || h
->root
.type
== bfd_link_hash_warning
)
1401 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1404 /* Check invalid x32 relocations. */
1405 if (!ABI_64_P (abfd
))
1411 case R_X86_64_DTPOFF64
:
1412 case R_X86_64_TPOFF64
:
1414 case R_X86_64_GOTOFF64
:
1415 case R_X86_64_GOT64
:
1416 case R_X86_64_GOTPCREL64
:
1417 case R_X86_64_GOTPC64
:
1418 case R_X86_64_GOTPLT64
:
1419 case R_X86_64_PLTOFF64
:
1422 name
= h
->root
.root
.string
;
1424 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1426 (*_bfd_error_handler
)
1427 (_("%B: relocation %s against symbol `%s' isn't "
1428 "supported in x32 mode"), abfd
,
1429 x86_64_elf_howto_table
[r_type
].name
, name
);
1430 bfd_set_error (bfd_error_bad_value
);
1438 /* Create the ifunc sections for static executables. If we
1439 never see an indirect function symbol nor we are building
1440 a static executable, those sections will be empty and
1441 won't appear in output. */
1452 case R_X86_64_PLT32
:
1453 case R_X86_64_GOTPCREL
:
1454 case R_X86_64_GOTPCREL64
:
1455 if (htab
->elf
.dynobj
== NULL
)
1456 htab
->elf
.dynobj
= abfd
;
1457 if (!_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
1462 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
1463 it here if it is defined in a non-shared object. */
1464 if (h
->type
== STT_GNU_IFUNC
1467 /* It is referenced by a non-shared object. */
1471 /* STT_GNU_IFUNC symbol must go through PLT. */
1472 h
->plt
.refcount
+= 1;
1474 /* STT_GNU_IFUNC needs dynamic sections. */
1475 if (htab
->elf
.dynobj
== NULL
)
1476 htab
->elf
.dynobj
= abfd
;
1481 if (h
->root
.root
.string
)
1482 name
= h
->root
.root
.string
;
1484 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1486 (*_bfd_error_handler
)
1487 (_("%B: relocation %s against STT_GNU_IFUNC "
1488 "symbol `%s' isn't handled by %s"), abfd
,
1489 x86_64_elf_howto_table
[r_type
].name
,
1490 name
, __FUNCTION__
);
1491 bfd_set_error (bfd_error_bad_value
);
1495 if (ABI_64_P (abfd
))
1499 h
->pointer_equality_needed
= 1;
1502 /* We must copy these reloc types into the output
1503 file. Create a reloc section in dynobj and
1504 make room for this reloc. */
1505 sreloc
= _bfd_elf_create_ifunc_dyn_reloc
1506 (abfd
, info
, sec
, sreloc
,
1507 &((struct elf_x86_64_link_hash_entry
*) h
)->dyn_relocs
);
1518 if (r_type
!= R_X86_64_PC32
1519 && r_type
!= R_X86_64_PC64
)
1520 h
->pointer_equality_needed
= 1;
1523 case R_X86_64_PLT32
:
1526 case R_X86_64_GOTPCREL
:
1527 case R_X86_64_GOTPCREL64
:
1528 h
->got
.refcount
+= 1;
1529 if (htab
->elf
.sgot
== NULL
1530 && !_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1540 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1541 symtab_hdr
, sym_hashes
,
1542 &r_type
, GOT_UNKNOWN
,
1543 rel
, rel_end
, h
, r_symndx
))
1548 case R_X86_64_TLSLD
:
1549 htab
->tls_ld_got
.refcount
+= 1;
1552 case R_X86_64_TPOFF32
:
1553 if (!info
->executable
&& ABI_64_P (abfd
))
1556 name
= h
->root
.root
.string
;
1558 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1560 (*_bfd_error_handler
)
1561 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1563 x86_64_elf_howto_table
[r_type
].name
, name
);
1564 bfd_set_error (bfd_error_bad_value
);
1569 case R_X86_64_GOTTPOFF
:
1570 if (!info
->executable
)
1571 info
->flags
|= DF_STATIC_TLS
;
1574 case R_X86_64_GOT32
:
1575 case R_X86_64_GOTPCREL
:
1576 case R_X86_64_TLSGD
:
1577 case R_X86_64_GOT64
:
1578 case R_X86_64_GOTPCREL64
:
1579 case R_X86_64_GOTPLT64
:
1580 case R_X86_64_GOTPC32_TLSDESC
:
1581 case R_X86_64_TLSDESC_CALL
:
1582 /* This symbol requires a global offset table entry. */
1584 int tls_type
, old_tls_type
;
1588 default: tls_type
= GOT_NORMAL
; break;
1589 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1590 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1591 case R_X86_64_GOTPC32_TLSDESC
:
1592 case R_X86_64_TLSDESC_CALL
:
1593 tls_type
= GOT_TLS_GDESC
; break;
1598 if (r_type
== R_X86_64_GOTPLT64
)
1600 /* This relocation indicates that we also need
1601 a PLT entry, as this is a function. We don't need
1602 a PLT entry for local symbols. */
1604 h
->plt
.refcount
+= 1;
1606 h
->got
.refcount
+= 1;
1607 old_tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
1611 bfd_signed_vma
*local_got_refcounts
;
1613 /* This is a global offset table entry for a local symbol. */
1614 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1615 if (local_got_refcounts
== NULL
)
1619 size
= symtab_hdr
->sh_info
;
1620 size
*= sizeof (bfd_signed_vma
)
1621 + sizeof (bfd_vma
) + sizeof (char);
1622 local_got_refcounts
= ((bfd_signed_vma
*)
1623 bfd_zalloc (abfd
, size
));
1624 if (local_got_refcounts
== NULL
)
1626 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1627 elf_x86_64_local_tlsdesc_gotent (abfd
)
1628 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1629 elf_x86_64_local_got_tls_type (abfd
)
1630 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1632 local_got_refcounts
[r_symndx
] += 1;
1634 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1637 /* If a TLS symbol is accessed using IE at least once,
1638 there is no point to use dynamic model for it. */
1639 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1640 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1641 || tls_type
!= GOT_TLS_IE
))
1643 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1644 tls_type
= old_tls_type
;
1645 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1646 && GOT_TLS_GD_ANY_P (tls_type
))
1647 tls_type
|= old_tls_type
;
1651 name
= h
->root
.root
.string
;
1653 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1655 (*_bfd_error_handler
)
1656 (_("%B: '%s' accessed both as normal and thread local symbol"),
1662 if (old_tls_type
!= tls_type
)
1665 elf_x86_64_hash_entry (h
)->tls_type
= tls_type
;
1667 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1672 case R_X86_64_GOTOFF64
:
1673 case R_X86_64_GOTPC32
:
1674 case R_X86_64_GOTPC64
:
1676 if (htab
->elf
.sgot
== NULL
)
1678 if (htab
->elf
.dynobj
== NULL
)
1679 htab
->elf
.dynobj
= abfd
;
1680 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1686 case R_X86_64_PLT32
:
1687 /* This symbol requires a procedure linkage table entry. We
1688 actually build the entry in adjust_dynamic_symbol,
1689 because this might be a case of linking PIC code which is
1690 never referenced by a dynamic object, in which case we
1691 don't need to generate a procedure linkage table entry
1694 /* If this is a local symbol, we resolve it directly without
1695 creating a procedure linkage table entry. */
1700 h
->plt
.refcount
+= 1;
1703 case R_X86_64_PLTOFF64
:
1704 /* This tries to form the 'address' of a function relative
1705 to GOT. For global symbols we need a PLT entry. */
1709 h
->plt
.refcount
+= 1;
1714 if (!ABI_64_P (abfd
))
1719 /* Let's help debug shared library creation. These relocs
1720 cannot be used in shared libs. Don't error out for
1721 sections we don't care about, such as debug sections or
1722 non-constant sections. */
1724 && (sec
->flags
& SEC_ALLOC
) != 0
1725 && (sec
->flags
& SEC_READONLY
) != 0)
1728 name
= h
->root
.root
.string
;
1730 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1731 (*_bfd_error_handler
)
1732 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1733 abfd
, x86_64_elf_howto_table
[r_type
].name
, name
);
1734 bfd_set_error (bfd_error_bad_value
);
1745 if (h
!= NULL
&& info
->executable
)
1747 /* If this reloc is in a read-only section, we might
1748 need a copy reloc. We can't check reliably at this
1749 stage whether the section is read-only, as input
1750 sections have not yet been mapped to output sections.
1751 Tentatively set the flag for now, and correct in
1752 adjust_dynamic_symbol. */
1755 /* We may need a .plt entry if the function this reloc
1756 refers to is in a shared lib. */
1757 h
->plt
.refcount
+= 1;
1758 if (r_type
!= R_X86_64_PC32
&& r_type
!= R_X86_64_PC64
)
1759 h
->pointer_equality_needed
= 1;
1762 /* If we are creating a shared library, and this is a reloc
1763 against a global symbol, or a non PC relative reloc
1764 against a local symbol, then we need to copy the reloc
1765 into the shared library. However, if we are linking with
1766 -Bsymbolic, we do not need to copy a reloc against a
1767 global symbol which is defined in an object we are
1768 including in the link (i.e., DEF_REGULAR is set). At
1769 this point we have not seen all the input files, so it is
1770 possible that DEF_REGULAR is not set now but will be set
1771 later (it is never cleared). In case of a weak definition,
1772 DEF_REGULAR may be cleared later by a strong definition in
1773 a shared library. We account for that possibility below by
1774 storing information in the relocs_copied field of the hash
1775 table entry. A similar situation occurs when creating
1776 shared libraries and symbol visibility changes render the
1779 If on the other hand, we are creating an executable, we
1780 may need to keep relocations for symbols satisfied by a
1781 dynamic library if we manage to avoid copy relocs for the
1784 && (sec
->flags
& SEC_ALLOC
) != 0
1785 && (! IS_X86_64_PCREL_TYPE (r_type
)
1787 && (! SYMBOLIC_BIND (info
, h
)
1788 || h
->root
.type
== bfd_link_hash_defweak
1789 || !h
->def_regular
))))
1790 || (ELIMINATE_COPY_RELOCS
1792 && (sec
->flags
& SEC_ALLOC
) != 0
1794 && (h
->root
.type
== bfd_link_hash_defweak
1795 || !h
->def_regular
)))
1797 struct elf_dyn_relocs
*p
;
1798 struct elf_dyn_relocs
**head
;
1800 /* We must copy these reloc types into the output file.
1801 Create a reloc section in dynobj and make room for
1805 if (htab
->elf
.dynobj
== NULL
)
1806 htab
->elf
.dynobj
= abfd
;
1808 sreloc
= _bfd_elf_make_dynamic_reloc_section
1809 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
1810 abfd
, /*rela?*/ TRUE
);
1816 /* If this is a global symbol, we count the number of
1817 relocations we need for this symbol. */
1820 head
= &((struct elf_x86_64_link_hash_entry
*) h
)->dyn_relocs
;
1824 /* Track dynamic relocs needed for local syms too.
1825 We really need local syms available to do this
1830 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1835 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1839 /* Beware of type punned pointers vs strict aliasing
1841 vpp
= &(elf_section_data (s
)->local_dynrel
);
1842 head
= (struct elf_dyn_relocs
**)vpp
;
1846 if (p
== NULL
|| p
->sec
!= sec
)
1848 bfd_size_type amt
= sizeof *p
;
1850 p
= ((struct elf_dyn_relocs
*)
1851 bfd_alloc (htab
->elf
.dynobj
, amt
));
1862 if (IS_X86_64_PCREL_TYPE (r_type
))
1867 /* This relocation describes the C++ object vtable hierarchy.
1868 Reconstruct it for later use during GC. */
1869 case R_X86_64_GNU_VTINHERIT
:
1870 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1874 /* This relocation describes which C++ vtable entries are actually
1875 used. Record for later use during GC. */
1876 case R_X86_64_GNU_VTENTRY
:
1877 BFD_ASSERT (h
!= NULL
);
1879 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1891 /* Return the section that should be marked against GC for a given
1895 elf_x86_64_gc_mark_hook (asection
*sec
,
1896 struct bfd_link_info
*info
,
1897 Elf_Internal_Rela
*rel
,
1898 struct elf_link_hash_entry
*h
,
1899 Elf_Internal_Sym
*sym
)
1902 switch (ELF32_R_TYPE (rel
->r_info
))
1904 case R_X86_64_GNU_VTINHERIT
:
1905 case R_X86_64_GNU_VTENTRY
:
1909 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1912 /* Update the got entry reference counts for the section being removed. */
1915 elf_x86_64_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
1917 const Elf_Internal_Rela
*relocs
)
1919 struct elf_x86_64_link_hash_table
*htab
;
1920 Elf_Internal_Shdr
*symtab_hdr
;
1921 struct elf_link_hash_entry
**sym_hashes
;
1922 bfd_signed_vma
*local_got_refcounts
;
1923 const Elf_Internal_Rela
*rel
, *relend
;
1925 if (info
->relocatable
)
1928 htab
= elf_x86_64_hash_table (info
);
1932 elf_section_data (sec
)->local_dynrel
= NULL
;
1934 symtab_hdr
= &elf_symtab_hdr (abfd
);
1935 sym_hashes
= elf_sym_hashes (abfd
);
1936 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1938 htab
= elf_x86_64_hash_table (info
);
1939 relend
= relocs
+ sec
->reloc_count
;
1940 for (rel
= relocs
; rel
< relend
; rel
++)
1942 unsigned long r_symndx
;
1943 unsigned int r_type
;
1944 struct elf_link_hash_entry
*h
= NULL
;
1946 r_symndx
= htab
->r_sym (rel
->r_info
);
1947 if (r_symndx
>= symtab_hdr
->sh_info
)
1949 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1950 while (h
->root
.type
== bfd_link_hash_indirect
1951 || h
->root
.type
== bfd_link_hash_warning
)
1952 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1956 /* A local symbol. */
1957 Elf_Internal_Sym
*isym
;
1959 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1962 /* Check relocation against local STT_GNU_IFUNC symbol. */
1964 && ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1966 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
, FALSE
);
1974 struct elf_x86_64_link_hash_entry
*eh
;
1975 struct elf_dyn_relocs
**pp
;
1976 struct elf_dyn_relocs
*p
;
1978 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
1980 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1983 /* Everything must go for SEC. */
1989 r_type
= ELF32_R_TYPE (rel
->r_info
);
1990 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1991 symtab_hdr
, sym_hashes
,
1992 &r_type
, GOT_UNKNOWN
,
1993 rel
, relend
, h
, r_symndx
))
1998 case R_X86_64_TLSLD
:
1999 if (htab
->tls_ld_got
.refcount
> 0)
2000 htab
->tls_ld_got
.refcount
-= 1;
2003 case R_X86_64_TLSGD
:
2004 case R_X86_64_GOTPC32_TLSDESC
:
2005 case R_X86_64_TLSDESC_CALL
:
2006 case R_X86_64_GOTTPOFF
:
2007 case R_X86_64_GOT32
:
2008 case R_X86_64_GOTPCREL
:
2009 case R_X86_64_GOT64
:
2010 case R_X86_64_GOTPCREL64
:
2011 case R_X86_64_GOTPLT64
:
2014 if (r_type
== R_X86_64_GOTPLT64
&& h
->plt
.refcount
> 0)
2015 h
->plt
.refcount
-= 1;
2016 if (h
->got
.refcount
> 0)
2017 h
->got
.refcount
-= 1;
2018 if (h
->type
== STT_GNU_IFUNC
)
2020 if (h
->plt
.refcount
> 0)
2021 h
->plt
.refcount
-= 1;
2024 else if (local_got_refcounts
!= NULL
)
2026 if (local_got_refcounts
[r_symndx
] > 0)
2027 local_got_refcounts
[r_symndx
] -= 1;
2041 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2045 case R_X86_64_PLT32
:
2046 case R_X86_64_PLTOFF64
:
2049 if (h
->plt
.refcount
> 0)
2050 h
->plt
.refcount
-= 1;
2062 /* Adjust a symbol defined by a dynamic object and referenced by a
2063 regular object. The current definition is in some section of the
2064 dynamic object, but we're not including those sections. We have to
2065 change the definition to something the rest of the link can
2069 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2070 struct elf_link_hash_entry
*h
)
2072 struct elf_x86_64_link_hash_table
*htab
;
2075 /* STT_GNU_IFUNC symbol must go through PLT. */
2076 if (h
->type
== STT_GNU_IFUNC
)
2078 if (h
->plt
.refcount
<= 0)
2080 h
->plt
.offset
= (bfd_vma
) -1;
2086 /* If this is a function, put it in the procedure linkage table. We
2087 will fill in the contents of the procedure linkage table later,
2088 when we know the address of the .got section. */
2089 if (h
->type
== STT_FUNC
2092 if (h
->plt
.refcount
<= 0
2093 || SYMBOL_CALLS_LOCAL (info
, h
)
2094 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2095 && h
->root
.type
== bfd_link_hash_undefweak
))
2097 /* This case can occur if we saw a PLT32 reloc in an input
2098 file, but the symbol was never referred to by a dynamic
2099 object, or if all references were garbage collected. In
2100 such a case, we don't actually need to build a procedure
2101 linkage table, and we can just do a PC32 reloc instead. */
2102 h
->plt
.offset
= (bfd_vma
) -1;
2109 /* It's possible that we incorrectly decided a .plt reloc was
2110 needed for an R_X86_64_PC32 reloc to a non-function sym in
2111 check_relocs. We can't decide accurately between function and
2112 non-function syms in check-relocs; Objects loaded later in
2113 the link may change h->type. So fix it now. */
2114 h
->plt
.offset
= (bfd_vma
) -1;
2116 /* If this is a weak symbol, and there is a real definition, the
2117 processor independent code will have arranged for us to see the
2118 real definition first, and we can just use the same value. */
2119 if (h
->u
.weakdef
!= NULL
)
2121 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2122 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2123 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2124 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2125 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2126 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2130 /* This is a reference to a symbol defined by a dynamic object which
2131 is not a function. */
2133 /* If we are creating a shared library, we must presume that the
2134 only references to the symbol are via the global offset table.
2135 For such cases we need not do anything here; the relocations will
2136 be handled correctly by relocate_section. */
2140 /* If there are no references to this symbol that do not use the
2141 GOT, we don't need to generate a copy reloc. */
2142 if (!h
->non_got_ref
)
2145 /* If -z nocopyreloc was given, we won't generate them either. */
2146 if (info
->nocopyreloc
)
2152 if (ELIMINATE_COPY_RELOCS
)
2154 struct elf_x86_64_link_hash_entry
* eh
;
2155 struct elf_dyn_relocs
*p
;
2157 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2158 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2160 s
= p
->sec
->output_section
;
2161 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2165 /* If we didn't find any dynamic relocs in read-only sections, then
2166 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2176 (*_bfd_error_handler
) (_("dynamic variable `%s' is zero size"),
2177 h
->root
.root
.string
);
2181 /* We must allocate the symbol in our .dynbss section, which will
2182 become part of the .bss section of the executable. There will be
2183 an entry for this symbol in the .dynsym section. The dynamic
2184 object will contain position independent code, so all references
2185 from the dynamic object to this symbol will go through the global
2186 offset table. The dynamic linker will use the .dynsym entry to
2187 determine the address it must put in the global offset table, so
2188 both the dynamic object and the regular object will refer to the
2189 same memory location for the variable. */
2191 htab
= elf_x86_64_hash_table (info
);
2195 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2196 to copy the initial value out of the dynamic object and into the
2197 runtime process image. */
2198 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2200 const struct elf_backend_data
*bed
;
2201 bed
= get_elf_backend_data (info
->output_bfd
);
2202 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2208 return _bfd_elf_adjust_dynamic_copy (h
, s
);
2211 /* Allocate space in .plt, .got and associated reloc sections for
2215 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2217 struct bfd_link_info
*info
;
2218 struct elf_x86_64_link_hash_table
*htab
;
2219 struct elf_x86_64_link_hash_entry
*eh
;
2220 struct elf_dyn_relocs
*p
;
2221 const struct elf_backend_data
*bed
;
2223 if (h
->root
.type
== bfd_link_hash_indirect
)
2226 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2228 info
= (struct bfd_link_info
*) inf
;
2229 htab
= elf_x86_64_hash_table (info
);
2232 bed
= get_elf_backend_data (info
->output_bfd
);
2234 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2235 here if it is defined and referenced in a non-shared object. */
2236 if (h
->type
== STT_GNU_IFUNC
2238 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2242 else if (htab
->elf
.dynamic_sections_created
2243 && h
->plt
.refcount
> 0)
2245 /* Make sure this symbol is output as a dynamic symbol.
2246 Undefined weak syms won't yet be marked as dynamic. */
2247 if (h
->dynindx
== -1
2248 && !h
->forced_local
)
2250 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2255 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2257 asection
*s
= htab
->elf
.splt
;
2259 /* If this is the first .plt entry, make room for the special
2262 s
->size
+= PLT_ENTRY_SIZE
;
2264 h
->plt
.offset
= s
->size
;
2266 /* If this symbol is not defined in a regular file, and we are
2267 not generating a shared library, then set the symbol to this
2268 location in the .plt. This is required to make function
2269 pointers compare as equal between the normal executable and
2270 the shared library. */
2274 h
->root
.u
.def
.section
= s
;
2275 h
->root
.u
.def
.value
= h
->plt
.offset
;
2278 /* Make room for this entry. */
2279 s
->size
+= PLT_ENTRY_SIZE
;
2281 /* We also need to make an entry in the .got.plt section, which
2282 will be placed in the .got section by the linker script. */
2283 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2285 /* We also need to make an entry in the .rela.plt section. */
2286 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2287 htab
->elf
.srelplt
->reloc_count
++;
2291 h
->plt
.offset
= (bfd_vma
) -1;
2297 h
->plt
.offset
= (bfd_vma
) -1;
2301 eh
->tlsdesc_got
= (bfd_vma
) -1;
2303 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2304 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2305 if (h
->got
.refcount
> 0
2308 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2310 h
->got
.offset
= (bfd_vma
) -1;
2312 else if (h
->got
.refcount
> 0)
2316 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2318 /* Make sure this symbol is output as a dynamic symbol.
2319 Undefined weak syms won't yet be marked as dynamic. */
2320 if (h
->dynindx
== -1
2321 && !h
->forced_local
)
2323 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2327 if (GOT_TLS_GDESC_P (tls_type
))
2329 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2330 - elf_x86_64_compute_jump_table_size (htab
);
2331 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2332 h
->got
.offset
= (bfd_vma
) -2;
2334 if (! GOT_TLS_GDESC_P (tls_type
)
2335 || GOT_TLS_GD_P (tls_type
))
2338 h
->got
.offset
= s
->size
;
2339 s
->size
+= GOT_ENTRY_SIZE
;
2340 if (GOT_TLS_GD_P (tls_type
))
2341 s
->size
+= GOT_ENTRY_SIZE
;
2343 dyn
= htab
->elf
.dynamic_sections_created
;
2344 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2346 R_X86_64_GOTTPOFF needs one dynamic relocation. */
2347 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2348 || tls_type
== GOT_TLS_IE
)
2349 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2350 else if (GOT_TLS_GD_P (tls_type
))
2351 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2352 else if (! GOT_TLS_GDESC_P (tls_type
)
2353 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2354 || h
->root
.type
!= bfd_link_hash_undefweak
)
2356 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2357 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2358 if (GOT_TLS_GDESC_P (tls_type
))
2360 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2361 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2365 h
->got
.offset
= (bfd_vma
) -1;
2367 if (eh
->dyn_relocs
== NULL
)
2370 /* In the shared -Bsymbolic case, discard space allocated for
2371 dynamic pc-relative relocs against symbols which turn out to be
2372 defined in regular objects. For the normal shared case, discard
2373 space for pc-relative relocs that have become local due to symbol
2374 visibility changes. */
2378 /* Relocs that use pc_count are those that appear on a call
2379 insn, or certain REL relocs that can generated via assembly.
2380 We want calls to protected symbols to resolve directly to the
2381 function rather than going via the plt. If people want
2382 function pointer comparisons to work as expected then they
2383 should avoid writing weird assembly. */
2384 if (SYMBOL_CALLS_LOCAL (info
, h
))
2386 struct elf_dyn_relocs
**pp
;
2388 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2390 p
->count
-= p
->pc_count
;
2399 /* Also discard relocs on undefined weak syms with non-default
2401 if (eh
->dyn_relocs
!= NULL
2402 && h
->root
.type
== bfd_link_hash_undefweak
)
2404 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2405 eh
->dyn_relocs
= NULL
;
2407 /* Make sure undefined weak symbols are output as a dynamic
2409 else if (h
->dynindx
== -1
2410 && ! h
->forced_local
2411 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2416 else if (ELIMINATE_COPY_RELOCS
)
2418 /* For the non-shared case, discard space for relocs against
2419 symbols which turn out to need copy relocs or are not
2425 || (htab
->elf
.dynamic_sections_created
2426 && (h
->root
.type
== bfd_link_hash_undefweak
2427 || h
->root
.type
== bfd_link_hash_undefined
))))
2429 /* Make sure this symbol is output as a dynamic symbol.
2430 Undefined weak syms won't yet be marked as dynamic. */
2431 if (h
->dynindx
== -1
2432 && ! h
->forced_local
2433 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2436 /* If that succeeded, we know we'll be keeping all the
2438 if (h
->dynindx
!= -1)
2442 eh
->dyn_relocs
= NULL
;
2447 /* Finally, allocate space. */
2448 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2452 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2454 BFD_ASSERT (sreloc
!= NULL
);
2456 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2462 /* Allocate space in .plt, .got and associated reloc sections for
2463 local dynamic relocs. */
2466 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
2468 struct elf_link_hash_entry
*h
2469 = (struct elf_link_hash_entry
*) *slot
;
2471 if (h
->type
!= STT_GNU_IFUNC
2475 || h
->root
.type
!= bfd_link_hash_defined
)
2478 return elf_x86_64_allocate_dynrelocs (h
, inf
);
2481 /* Find any dynamic relocs that apply to read-only sections. */
2484 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
2487 struct elf_x86_64_link_hash_entry
*eh
;
2488 struct elf_dyn_relocs
*p
;
2490 /* Skip local IFUNC symbols. */
2491 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2494 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2495 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2497 asection
*s
= p
->sec
->output_section
;
2499 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2501 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2503 info
->flags
|= DF_TEXTREL
;
2505 if (info
->warn_shared_textrel
&& info
->shared
)
2506 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2507 p
->sec
->owner
, h
->root
.root
.string
,
2510 /* Not an error, just cut short the traversal. */
2517 /* Set the sizes of the dynamic sections. */
2520 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
2521 struct bfd_link_info
*info
)
2523 struct elf_x86_64_link_hash_table
*htab
;
2528 const struct elf_backend_data
*bed
;
2530 htab
= elf_x86_64_hash_table (info
);
2533 bed
= get_elf_backend_data (output_bfd
);
2535 dynobj
= htab
->elf
.dynobj
;
2539 if (htab
->elf
.dynamic_sections_created
)
2541 /* Set the contents of the .interp section to the interpreter. */
2542 if (info
->executable
)
2544 s
= bfd_get_section_by_name (dynobj
, ".interp");
2547 s
->size
= htab
->dynamic_interpreter_size
;
2548 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2552 /* Set up .got offsets for local syms, and space for local dynamic
2554 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2556 bfd_signed_vma
*local_got
;
2557 bfd_signed_vma
*end_local_got
;
2558 char *local_tls_type
;
2559 bfd_vma
*local_tlsdesc_gotent
;
2560 bfd_size_type locsymcount
;
2561 Elf_Internal_Shdr
*symtab_hdr
;
2564 if (! is_x86_64_elf (ibfd
))
2567 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2569 struct elf_dyn_relocs
*p
;
2571 for (p
= (struct elf_dyn_relocs
*)
2572 (elf_section_data (s
)->local_dynrel
);
2576 if (!bfd_is_abs_section (p
->sec
)
2577 && bfd_is_abs_section (p
->sec
->output_section
))
2579 /* Input section has been discarded, either because
2580 it is a copy of a linkonce section or due to
2581 linker script /DISCARD/, so we'll be discarding
2584 else if (p
->count
!= 0)
2586 srel
= elf_section_data (p
->sec
)->sreloc
;
2587 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2588 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
2589 && (info
->flags
& DF_TEXTREL
) == 0)
2591 info
->flags
|= DF_TEXTREL
;
2592 if (info
->warn_shared_textrel
&& info
->shared
)
2593 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2594 p
->sec
->owner
, p
->sec
);
2600 local_got
= elf_local_got_refcounts (ibfd
);
2604 symtab_hdr
= &elf_symtab_hdr (ibfd
);
2605 locsymcount
= symtab_hdr
->sh_info
;
2606 end_local_got
= local_got
+ locsymcount
;
2607 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
2608 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
2610 srel
= htab
->elf
.srelgot
;
2611 for (; local_got
< end_local_got
;
2612 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
2614 *local_tlsdesc_gotent
= (bfd_vma
) -1;
2617 if (GOT_TLS_GDESC_P (*local_tls_type
))
2619 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
2620 - elf_x86_64_compute_jump_table_size (htab
);
2621 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2622 *local_got
= (bfd_vma
) -2;
2624 if (! GOT_TLS_GDESC_P (*local_tls_type
)
2625 || GOT_TLS_GD_P (*local_tls_type
))
2627 *local_got
= s
->size
;
2628 s
->size
+= GOT_ENTRY_SIZE
;
2629 if (GOT_TLS_GD_P (*local_tls_type
))
2630 s
->size
+= GOT_ENTRY_SIZE
;
2633 || GOT_TLS_GD_ANY_P (*local_tls_type
)
2634 || *local_tls_type
== GOT_TLS_IE
)
2636 if (GOT_TLS_GDESC_P (*local_tls_type
))
2638 htab
->elf
.srelplt
->size
2639 += bed
->s
->sizeof_rela
;
2640 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2642 if (! GOT_TLS_GDESC_P (*local_tls_type
)
2643 || GOT_TLS_GD_P (*local_tls_type
))
2644 srel
->size
+= bed
->s
->sizeof_rela
;
2648 *local_got
= (bfd_vma
) -1;
2652 if (htab
->tls_ld_got
.refcount
> 0)
2654 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
2656 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
2657 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
2658 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2661 htab
->tls_ld_got
.offset
= -1;
2663 /* Allocate global sym .plt and .got entries, and space for global
2664 sym dynamic relocs. */
2665 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
2668 /* Allocate .plt and .got entries, and space for local symbols. */
2669 htab_traverse (htab
->loc_hash_table
,
2670 elf_x86_64_allocate_local_dynrelocs
,
2673 /* For every jump slot reserved in the sgotplt, reloc_count is
2674 incremented. However, when we reserve space for TLS descriptors,
2675 it's not incremented, so in order to compute the space reserved
2676 for them, it suffices to multiply the reloc count by the jump
2679 PR ld/13302: We start next_irelative_index at the end of .rela.plt
2680 so that R_X86_64_IRELATIVE entries come last. */
2681 if (htab
->elf
.srelplt
)
2683 htab
->sgotplt_jump_table_size
2684 = elf_x86_64_compute_jump_table_size (htab
);
2685 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
2687 else if (htab
->elf
.irelplt
)
2688 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
2690 if (htab
->tlsdesc_plt
)
2692 /* If we're not using lazy TLS relocations, don't generate the
2693 PLT and GOT entries they require. */
2694 if ((info
->flags
& DF_BIND_NOW
))
2695 htab
->tlsdesc_plt
= 0;
2698 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
2699 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
2700 /* Reserve room for the initial entry.
2701 FIXME: we could probably do away with it in this case. */
2702 if (htab
->elf
.splt
->size
== 0)
2703 htab
->elf
.splt
->size
+= PLT_ENTRY_SIZE
;
2704 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
2705 htab
->elf
.splt
->size
+= PLT_ENTRY_SIZE
;
2709 if (htab
->elf
.sgotplt
)
2711 struct elf_link_hash_entry
*got
;
2712 got
= elf_link_hash_lookup (elf_hash_table (info
),
2713 "_GLOBAL_OFFSET_TABLE_",
2714 FALSE
, FALSE
, FALSE
);
2716 /* Don't allocate .got.plt section if there are no GOT nor PLT
2717 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
2719 || !got
->ref_regular_nonweak
)
2720 && (htab
->elf
.sgotplt
->size
2721 == get_elf_backend_data (output_bfd
)->got_header_size
)
2722 && (htab
->elf
.splt
== NULL
2723 || htab
->elf
.splt
->size
== 0)
2724 && (htab
->elf
.sgot
== NULL
2725 || htab
->elf
.sgot
->size
== 0)
2726 && (htab
->elf
.iplt
== NULL
2727 || htab
->elf
.iplt
->size
== 0)
2728 && (htab
->elf
.igotplt
== NULL
2729 || htab
->elf
.igotplt
->size
== 0))
2730 htab
->elf
.sgotplt
->size
= 0;
2733 /* We now have determined the sizes of the various dynamic sections.
2734 Allocate memory for them. */
2736 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2738 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2741 if (s
== htab
->elf
.splt
2742 || s
== htab
->elf
.sgot
2743 || s
== htab
->elf
.sgotplt
2744 || s
== htab
->elf
.iplt
2745 || s
== htab
->elf
.igotplt
2746 || s
== htab
->sdynbss
)
2748 /* Strip this section if we don't need it; see the
2751 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
2753 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
2756 /* We use the reloc_count field as a counter if we need
2757 to copy relocs into the output file. */
2758 if (s
!= htab
->elf
.srelplt
)
2763 /* It's not one of our sections, so don't allocate space. */
2769 /* If we don't need this section, strip it from the
2770 output file. This is mostly to handle .rela.bss and
2771 .rela.plt. We must create both sections in
2772 create_dynamic_sections, because they must be created
2773 before the linker maps input sections to output
2774 sections. The linker does that before
2775 adjust_dynamic_symbol is called, and it is that
2776 function which decides whether anything needs to go
2777 into these sections. */
2779 s
->flags
|= SEC_EXCLUDE
;
2783 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2786 /* Allocate memory for the section contents. We use bfd_zalloc
2787 here in case unused entries are not reclaimed before the
2788 section's contents are written out. This should not happen,
2789 but this way if it does, we get a R_X86_64_NONE reloc instead
2791 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2792 if (s
->contents
== NULL
)
2796 if (htab
->plt_eh_frame
!= NULL
2797 && htab
->elf
.splt
!= NULL
2798 && htab
->elf
.splt
->size
!= 0
2799 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0)
2800 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
2801 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
2803 if (htab
->elf
.dynamic_sections_created
)
2805 /* Add some entries to the .dynamic section. We fill in the
2806 values later, in elf_x86_64_finish_dynamic_sections, but we
2807 must add the entries now so that we get the correct size for
2808 the .dynamic section. The DT_DEBUG entry is filled in by the
2809 dynamic linker and used by the debugger. */
2810 #define add_dynamic_entry(TAG, VAL) \
2811 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2813 if (info
->executable
)
2815 if (!add_dynamic_entry (DT_DEBUG
, 0))
2819 if (htab
->elf
.splt
->size
!= 0)
2821 if (!add_dynamic_entry (DT_PLTGOT
, 0)
2822 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
2823 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2824 || !add_dynamic_entry (DT_JMPREL
, 0))
2827 if (htab
->tlsdesc_plt
2828 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
2829 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
2835 if (!add_dynamic_entry (DT_RELA
, 0)
2836 || !add_dynamic_entry (DT_RELASZ
, 0)
2837 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
2840 /* If any dynamic relocs apply to a read-only section,
2841 then we need a DT_TEXTREL entry. */
2842 if ((info
->flags
& DF_TEXTREL
) == 0)
2843 elf_link_hash_traverse (&htab
->elf
,
2844 elf_x86_64_readonly_dynrelocs
,
2847 if ((info
->flags
& DF_TEXTREL
) != 0)
2849 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2854 #undef add_dynamic_entry
2860 elf_x86_64_always_size_sections (bfd
*output_bfd
,
2861 struct bfd_link_info
*info
)
2863 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
2867 struct elf_link_hash_entry
*tlsbase
;
2869 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
2870 "_TLS_MODULE_BASE_",
2871 FALSE
, FALSE
, FALSE
);
2873 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
2875 struct elf_x86_64_link_hash_table
*htab
;
2876 struct bfd_link_hash_entry
*bh
= NULL
;
2877 const struct elf_backend_data
*bed
2878 = get_elf_backend_data (output_bfd
);
2880 htab
= elf_x86_64_hash_table (info
);
2884 if (!(_bfd_generic_link_add_one_symbol
2885 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
2886 tls_sec
, 0, NULL
, FALSE
,
2887 bed
->collect
, &bh
)))
2890 htab
->tls_module_base
= bh
;
2892 tlsbase
= (struct elf_link_hash_entry
*)bh
;
2893 tlsbase
->def_regular
= 1;
2894 tlsbase
->other
= STV_HIDDEN
;
2895 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
2902 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
2903 executables. Rather than setting it to the beginning of the TLS
2904 section, we have to set it to the end. This function may be called
2905 multiple times, it is idempotent. */
2908 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
2910 struct elf_x86_64_link_hash_table
*htab
;
2911 struct bfd_link_hash_entry
*base
;
2913 if (!info
->executable
)
2916 htab
= elf_x86_64_hash_table (info
);
2920 base
= htab
->tls_module_base
;
2924 base
->u
.def
.value
= htab
->elf
.tls_size
;
2927 /* Return the base VMA address which should be subtracted from real addresses
2928 when resolving @dtpoff relocation.
2929 This is PT_TLS segment p_vaddr. */
2932 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
2934 /* If tls_sec is NULL, we should have signalled an error already. */
2935 if (elf_hash_table (info
)->tls_sec
== NULL
)
2937 return elf_hash_table (info
)->tls_sec
->vma
;
2940 /* Return the relocation value for @tpoff relocation
2941 if STT_TLS virtual address is ADDRESS. */
2944 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
2946 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2947 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
2948 bfd_vma static_tls_size
;
2950 /* If tls_segment is NULL, we should have signalled an error already. */
2951 if (htab
->tls_sec
== NULL
)
2954 /* Consider special static TLS alignment requirements. */
2955 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
2956 return address
- static_tls_size
- htab
->tls_sec
->vma
;
2959 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
2963 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
2965 /* Opcode Instruction
2968 0x0f 0x8x conditional jump */
2970 && (contents
[offset
- 1] == 0xe8
2971 || contents
[offset
- 1] == 0xe9))
2973 && contents
[offset
- 2] == 0x0f
2974 && (contents
[offset
- 1] & 0xf0) == 0x80));
2977 /* Relocate an x86_64 ELF section. */
2980 elf_x86_64_relocate_section (bfd
*output_bfd
,
2981 struct bfd_link_info
*info
,
2983 asection
*input_section
,
2985 Elf_Internal_Rela
*relocs
,
2986 Elf_Internal_Sym
*local_syms
,
2987 asection
**local_sections
)
2989 struct elf_x86_64_link_hash_table
*htab
;
2990 Elf_Internal_Shdr
*symtab_hdr
;
2991 struct elf_link_hash_entry
**sym_hashes
;
2992 bfd_vma
*local_got_offsets
;
2993 bfd_vma
*local_tlsdesc_gotents
;
2994 Elf_Internal_Rela
*rel
;
2995 Elf_Internal_Rela
*relend
;
2997 BFD_ASSERT (is_x86_64_elf (input_bfd
));
2999 htab
= elf_x86_64_hash_table (info
);
3002 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3003 sym_hashes
= elf_sym_hashes (input_bfd
);
3004 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3005 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
3007 elf_x86_64_set_tls_module_base (info
);
3010 relend
= relocs
+ input_section
->reloc_count
;
3011 for (; rel
< relend
; rel
++)
3013 unsigned int r_type
;
3014 reloc_howto_type
*howto
;
3015 unsigned long r_symndx
;
3016 struct elf_link_hash_entry
*h
;
3017 Elf_Internal_Sym
*sym
;
3019 bfd_vma off
, offplt
;
3021 bfd_boolean unresolved_reloc
;
3022 bfd_reloc_status_type r
;
3026 r_type
= ELF32_R_TYPE (rel
->r_info
);
3027 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
3028 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
3031 if (r_type
>= R_X86_64_max
)
3033 bfd_set_error (bfd_error_bad_value
);
3037 if (r_type
!= (int) R_X86_64_32
3038 || ABI_64_P (output_bfd
))
3039 howto
= x86_64_elf_howto_table
+ r_type
;
3041 howto
= (x86_64_elf_howto_table
3042 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
3043 r_symndx
= htab
->r_sym (rel
->r_info
);
3047 unresolved_reloc
= FALSE
;
3048 if (r_symndx
< symtab_hdr
->sh_info
)
3050 sym
= local_syms
+ r_symndx
;
3051 sec
= local_sections
[r_symndx
];
3053 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
3056 /* Relocate against local STT_GNU_IFUNC symbol. */
3057 if (!info
->relocatable
3058 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3060 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
3065 /* Set STT_GNU_IFUNC symbol value. */
3066 h
->root
.u
.def
.value
= sym
->st_value
;
3067 h
->root
.u
.def
.section
= sec
;
3072 bfd_boolean warned ATTRIBUTE_UNUSED
;
3074 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3075 r_symndx
, symtab_hdr
, sym_hashes
,
3077 unresolved_reloc
, warned
);
3080 if (sec
!= NULL
&& elf_discarded_section (sec
))
3081 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3082 rel
, relend
, howto
, contents
);
3084 if (info
->relocatable
)
3087 if (rel
->r_addend
== 0
3088 && r_type
== R_X86_64_64
3089 && !ABI_64_P (output_bfd
))
3091 /* For x32, treat R_X86_64_64 like R_X86_64_32 and zero-extend
3092 it to 64bit if addend is zero. */
3093 r_type
= R_X86_64_32
;
3094 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3097 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3098 it here if it is defined in a non-shared object. */
3100 && h
->type
== STT_GNU_IFUNC
3107 if ((input_section
->flags
& SEC_ALLOC
) == 0
3108 || h
->plt
.offset
== (bfd_vma
) -1)
3111 /* STT_GNU_IFUNC symbol must go through PLT. */
3112 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
3113 relocation
= (plt
->output_section
->vma
3114 + plt
->output_offset
+ h
->plt
.offset
);
3119 if (h
->root
.root
.string
)
3120 name
= h
->root
.root
.string
;
3122 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3124 (*_bfd_error_handler
)
3125 (_("%B: relocation %s against STT_GNU_IFUNC "
3126 "symbol `%s' isn't handled by %s"), input_bfd
,
3127 x86_64_elf_howto_table
[r_type
].name
,
3128 name
, __FUNCTION__
);
3129 bfd_set_error (bfd_error_bad_value
);
3138 if (ABI_64_P (output_bfd
))
3142 if (rel
->r_addend
!= 0)
3144 if (h
->root
.root
.string
)
3145 name
= h
->root
.root
.string
;
3147 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
3149 (*_bfd_error_handler
)
3150 (_("%B: relocation %s against STT_GNU_IFUNC "
3151 "symbol `%s' has non-zero addend: %d"),
3152 input_bfd
, x86_64_elf_howto_table
[r_type
].name
,
3153 name
, rel
->r_addend
);
3154 bfd_set_error (bfd_error_bad_value
);
3158 /* Generate dynamic relcoation only when there is a
3159 non-GOT reference in a shared object. */
3160 if (info
->shared
&& h
->non_got_ref
)
3162 Elf_Internal_Rela outrel
;
3165 /* Need a dynamic relocation to get the real function
3167 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
3171 if (outrel
.r_offset
== (bfd_vma
) -1
3172 || outrel
.r_offset
== (bfd_vma
) -2)
3175 outrel
.r_offset
+= (input_section
->output_section
->vma
3176 + input_section
->output_offset
);
3178 if (h
->dynindx
== -1
3180 || info
->executable
)
3182 /* This symbol is resolved locally. */
3183 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
3184 outrel
.r_addend
= (h
->root
.u
.def
.value
3185 + h
->root
.u
.def
.section
->output_section
->vma
3186 + h
->root
.u
.def
.section
->output_offset
);
3190 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3191 outrel
.r_addend
= 0;
3194 sreloc
= htab
->elf
.irelifunc
;
3195 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3197 /* If this reloc is against an external symbol, we
3198 do not want to fiddle with the addend. Otherwise,
3199 we need to include the symbol value so that it
3200 becomes an addend for the dynamic reloc. For an
3201 internal symbol, we have updated addend. */
3207 case R_X86_64_PLT32
:
3210 case R_X86_64_GOTPCREL
:
3211 case R_X86_64_GOTPCREL64
:
3212 base_got
= htab
->elf
.sgot
;
3213 off
= h
->got
.offset
;
3215 if (base_got
== NULL
)
3218 if (off
== (bfd_vma
) -1)
3220 /* We can't use h->got.offset here to save state, or
3221 even just remember the offset, as finish_dynamic_symbol
3222 would use that as offset into .got. */
3224 if (htab
->elf
.splt
!= NULL
)
3226 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3227 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3228 base_got
= htab
->elf
.sgotplt
;
3232 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
3233 off
= plt_index
* GOT_ENTRY_SIZE
;
3234 base_got
= htab
->elf
.igotplt
;
3237 if (h
->dynindx
== -1
3241 /* This references the local defitionion. We must
3242 initialize this entry in the global offset table.
3243 Since the offset must always be a multiple of 8,
3244 we use the least significant bit to record
3245 whether we have initialized it already.
3247 When doing a dynamic link, we create a .rela.got
3248 relocation entry to initialize the value. This
3249 is done in the finish_dynamic_symbol routine. */
3254 bfd_put_64 (output_bfd
, relocation
,
3255 base_got
->contents
+ off
);
3256 /* Note that this is harmless for the GOTPLT64
3257 case, as -1 | 1 still is -1. */
3263 relocation
= (base_got
->output_section
->vma
3264 + base_got
->output_offset
+ off
);
3270 /* When generating a shared object, the relocations handled here are
3271 copied into the output file to be resolved at run time. */
3274 case R_X86_64_GOT32
:
3275 case R_X86_64_GOT64
:
3276 /* Relocation is to the entry for this symbol in the global
3278 case R_X86_64_GOTPCREL
:
3279 case R_X86_64_GOTPCREL64
:
3280 /* Use global offset table entry as symbol value. */
3281 case R_X86_64_GOTPLT64
:
3282 /* This is the same as GOT64 for relocation purposes, but
3283 indicates the existence of a PLT entry. The difficulty is,
3284 that we must calculate the GOT slot offset from the PLT
3285 offset, if this symbol got a PLT entry (it was global).
3286 Additionally if it's computed from the PLT entry, then that
3287 GOT offset is relative to .got.plt, not to .got. */
3288 base_got
= htab
->elf
.sgot
;
3290 if (htab
->elf
.sgot
== NULL
)
3297 off
= h
->got
.offset
;
3299 && h
->plt
.offset
!= (bfd_vma
)-1
3300 && off
== (bfd_vma
)-1)
3302 /* We can't use h->got.offset here to save
3303 state, or even just remember the offset, as
3304 finish_dynamic_symbol would use that as offset into
3306 bfd_vma plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3307 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3308 base_got
= htab
->elf
.sgotplt
;
3311 dyn
= htab
->elf
.dynamic_sections_created
;
3313 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
3315 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3316 || (ELF_ST_VISIBILITY (h
->other
)
3317 && h
->root
.type
== bfd_link_hash_undefweak
))
3319 /* This is actually a static link, or it is a -Bsymbolic
3320 link and the symbol is defined locally, or the symbol
3321 was forced to be local because of a version file. We
3322 must initialize this entry in the global offset table.
3323 Since the offset must always be a multiple of 8, we
3324 use the least significant bit to record whether we
3325 have initialized it already.
3327 When doing a dynamic link, we create a .rela.got
3328 relocation entry to initialize the value. This is
3329 done in the finish_dynamic_symbol routine. */
3334 bfd_put_64 (output_bfd
, relocation
,
3335 base_got
->contents
+ off
);
3336 /* Note that this is harmless for the GOTPLT64 case,
3337 as -1 | 1 still is -1. */
3342 unresolved_reloc
= FALSE
;
3346 if (local_got_offsets
== NULL
)
3349 off
= local_got_offsets
[r_symndx
];
3351 /* The offset must always be a multiple of 8. We use
3352 the least significant bit to record whether we have
3353 already generated the necessary reloc. */
3358 bfd_put_64 (output_bfd
, relocation
,
3359 base_got
->contents
+ off
);
3364 Elf_Internal_Rela outrel
;
3366 /* We need to generate a R_X86_64_RELATIVE reloc
3367 for the dynamic linker. */
3368 s
= htab
->elf
.srelgot
;
3372 outrel
.r_offset
= (base_got
->output_section
->vma
3373 + base_got
->output_offset
3375 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3376 outrel
.r_addend
= relocation
;
3377 elf_append_rela (output_bfd
, s
, &outrel
);
3380 local_got_offsets
[r_symndx
] |= 1;
3384 if (off
>= (bfd_vma
) -2)
3387 relocation
= base_got
->output_section
->vma
3388 + base_got
->output_offset
+ off
;
3389 if (r_type
!= R_X86_64_GOTPCREL
&& r_type
!= R_X86_64_GOTPCREL64
)
3390 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3391 - htab
->elf
.sgotplt
->output_offset
;
3395 case R_X86_64_GOTOFF64
:
3396 /* Relocation is relative to the start of the global offset
3399 /* Check to make sure it isn't a protected function symbol
3400 for shared library since it may not be local when used
3401 as function address. */
3405 && h
->type
== STT_FUNC
3406 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
3408 (*_bfd_error_handler
)
3409 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3410 input_bfd
, h
->root
.root
.string
);
3411 bfd_set_error (bfd_error_bad_value
);
3415 /* Note that sgot is not involved in this
3416 calculation. We always want the start of .got.plt. If we
3417 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3418 permitted by the ABI, we might have to change this
3420 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3421 + htab
->elf
.sgotplt
->output_offset
;
3424 case R_X86_64_GOTPC32
:
3425 case R_X86_64_GOTPC64
:
3426 /* Use global offset table as symbol value. */
3427 relocation
= htab
->elf
.sgotplt
->output_section
->vma
3428 + htab
->elf
.sgotplt
->output_offset
;
3429 unresolved_reloc
= FALSE
;
3432 case R_X86_64_PLTOFF64
:
3433 /* Relocation is PLT entry relative to GOT. For local
3434 symbols it's the symbol itself relative to GOT. */
3436 /* See PLT32 handling. */
3437 && h
->plt
.offset
!= (bfd_vma
) -1
3438 && htab
->elf
.splt
!= NULL
)
3440 relocation
= (htab
->elf
.splt
->output_section
->vma
3441 + htab
->elf
.splt
->output_offset
3443 unresolved_reloc
= FALSE
;
3446 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3447 + htab
->elf
.sgotplt
->output_offset
;
3450 case R_X86_64_PLT32
:
3451 /* Relocation is to the entry for this symbol in the
3452 procedure linkage table. */
3454 /* Resolve a PLT32 reloc against a local symbol directly,
3455 without using the procedure linkage table. */
3459 if (h
->plt
.offset
== (bfd_vma
) -1
3460 || htab
->elf
.splt
== NULL
)
3462 /* We didn't make a PLT entry for this symbol. This
3463 happens when statically linking PIC code, or when
3464 using -Bsymbolic. */
3468 relocation
= (htab
->elf
.splt
->output_section
->vma
3469 + htab
->elf
.splt
->output_offset
3471 unresolved_reloc
= FALSE
;
3478 && ABI_64_P (output_bfd
)
3479 && (input_section
->flags
& SEC_ALLOC
) != 0
3480 && (input_section
->flags
& SEC_READONLY
) != 0
3483 bfd_boolean fail
= FALSE
;
3485 = (r_type
== R_X86_64_PC32
3486 && is_32bit_relative_branch (contents
, rel
->r_offset
));
3488 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
3490 /* Symbol is referenced locally. Make sure it is
3491 defined locally or for a branch. */
3492 fail
= !h
->def_regular
&& !branch
;
3496 /* Symbol isn't referenced locally. We only allow
3497 branch to symbol with non-default visibility. */
3499 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
3506 const char *pic
= "";
3508 switch (ELF_ST_VISIBILITY (h
->other
))
3511 v
= _("hidden symbol");
3514 v
= _("internal symbol");
3517 v
= _("protected symbol");
3521 pic
= _("; recompile with -fPIC");
3526 fmt
= _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3528 fmt
= _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3530 (*_bfd_error_handler
) (fmt
, input_bfd
,
3531 x86_64_elf_howto_table
[r_type
].name
,
3532 v
, h
->root
.root
.string
, pic
);
3533 bfd_set_error (bfd_error_bad_value
);
3544 /* FIXME: The ABI says the linker should make sure the value is
3545 the same when it's zeroextended to 64 bit. */
3547 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3552 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3553 || h
->root
.type
!= bfd_link_hash_undefweak
)
3554 && (! IS_X86_64_PCREL_TYPE (r_type
)
3555 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
3556 || (ELIMINATE_COPY_RELOCS
3563 || h
->root
.type
== bfd_link_hash_undefweak
3564 || h
->root
.type
== bfd_link_hash_undefined
)))
3566 Elf_Internal_Rela outrel
;
3567 bfd_boolean skip
, relocate
;
3570 /* When generating a shared object, these relocations
3571 are copied into the output file to be resolved at run
3577 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3579 if (outrel
.r_offset
== (bfd_vma
) -1)
3581 else if (outrel
.r_offset
== (bfd_vma
) -2)
3582 skip
= TRUE
, relocate
= TRUE
;
3584 outrel
.r_offset
+= (input_section
->output_section
->vma
3585 + input_section
->output_offset
);
3588 memset (&outrel
, 0, sizeof outrel
);
3590 /* h->dynindx may be -1 if this symbol was marked to
3594 && (IS_X86_64_PCREL_TYPE (r_type
)
3596 || ! SYMBOLIC_BIND (info
, h
)
3597 || ! h
->def_regular
))
3599 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3600 outrel
.r_addend
= rel
->r_addend
;
3604 /* This symbol is local, or marked to become local. */
3605 if (r_type
== htab
->pointer_r_type
)
3608 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3609 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3611 else if (r_type
== R_X86_64_64
3612 && !ABI_64_P (output_bfd
))
3615 outrel
.r_info
= htab
->r_info (0,
3616 R_X86_64_RELATIVE64
);
3617 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3623 if (bfd_is_abs_section (sec
))
3625 else if (sec
== NULL
|| sec
->owner
== NULL
)
3627 bfd_set_error (bfd_error_bad_value
);
3634 /* We are turning this relocation into one
3635 against a section symbol. It would be
3636 proper to subtract the symbol's value,
3637 osec->vma, from the emitted reloc addend,
3638 but ld.so expects buggy relocs. */
3639 osec
= sec
->output_section
;
3640 sindx
= elf_section_data (osec
)->dynindx
;
3643 asection
*oi
= htab
->elf
.text_index_section
;
3644 sindx
= elf_section_data (oi
)->dynindx
;
3646 BFD_ASSERT (sindx
!= 0);
3649 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
3650 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3654 sreloc
= elf_section_data (input_section
)->sreloc
;
3656 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
3658 r
= bfd_reloc_notsupported
;
3659 goto check_relocation_error
;
3662 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3664 /* If this reloc is against an external symbol, we do
3665 not want to fiddle with the addend. Otherwise, we
3666 need to include the symbol value so that it becomes
3667 an addend for the dynamic reloc. */
3674 case R_X86_64_TLSGD
:
3675 case R_X86_64_GOTPC32_TLSDESC
:
3676 case R_X86_64_TLSDESC_CALL
:
3677 case R_X86_64_GOTTPOFF
:
3678 tls_type
= GOT_UNKNOWN
;
3679 if (h
== NULL
&& local_got_offsets
)
3680 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
3682 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
3684 if (! elf_x86_64_tls_transition (info
, input_bfd
,
3685 input_section
, contents
,
3686 symtab_hdr
, sym_hashes
,
3687 &r_type
, tls_type
, rel
,
3688 relend
, h
, r_symndx
))
3691 if (r_type
== R_X86_64_TPOFF32
)
3693 bfd_vma roff
= rel
->r_offset
;
3695 BFD_ASSERT (! unresolved_reloc
);
3697 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
3699 /* GD->LE transition. For 64bit, change
3700 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3701 .word 0x6666; rex64; call __tls_get_addr
3704 leaq foo@tpoff(%rax), %rax
3706 leaq foo@tlsgd(%rip), %rdi
3707 .word 0x6666; rex64; call __tls_get_addr
3710 leaq foo@tpoff(%rax), %rax */
3711 if (ABI_64_P (output_bfd
))
3712 memcpy (contents
+ roff
- 4,
3713 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3716 memcpy (contents
+ roff
- 3,
3717 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3719 bfd_put_32 (output_bfd
,
3720 elf_x86_64_tpoff (info
, relocation
),
3721 contents
+ roff
+ 8);
3722 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
3726 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
3728 /* GDesc -> LE transition.
3729 It's originally something like:
3730 leaq x@tlsdesc(%rip), %rax
3733 movl $x@tpoff, %rax. */
3735 unsigned int val
, type
;
3737 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
3738 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
3739 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
3740 contents
+ roff
- 3);
3741 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
3742 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
3743 contents
+ roff
- 1);
3744 bfd_put_32 (output_bfd
,
3745 elf_x86_64_tpoff (info
, relocation
),
3749 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
3751 /* GDesc -> LE transition.
3756 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
3757 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
3760 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
3762 /* IE->LE transition:
3763 Originally it can be one of:
3764 movq foo@gottpoff(%rip), %reg
3765 addq foo@gottpoff(%rip), %reg
3768 leaq foo(%reg), %reg
3771 unsigned int val
, type
, reg
;
3773 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
3774 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
3775 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
3781 bfd_put_8 (output_bfd
, 0x49,
3782 contents
+ roff
- 3);
3783 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
3784 bfd_put_8 (output_bfd
, 0x41,
3785 contents
+ roff
- 3);
3786 bfd_put_8 (output_bfd
, 0xc7,
3787 contents
+ roff
- 2);
3788 bfd_put_8 (output_bfd
, 0xc0 | reg
,
3789 contents
+ roff
- 1);
3793 /* addq -> addq - addressing with %rsp/%r12 is
3796 bfd_put_8 (output_bfd
, 0x49,
3797 contents
+ roff
- 3);
3798 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
3799 bfd_put_8 (output_bfd
, 0x41,
3800 contents
+ roff
- 3);
3801 bfd_put_8 (output_bfd
, 0x81,
3802 contents
+ roff
- 2);
3803 bfd_put_8 (output_bfd
, 0xc0 | reg
,
3804 contents
+ roff
- 1);
3810 bfd_put_8 (output_bfd
, 0x4d,
3811 contents
+ roff
- 3);
3812 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
3813 bfd_put_8 (output_bfd
, 0x45,
3814 contents
+ roff
- 3);
3815 bfd_put_8 (output_bfd
, 0x8d,
3816 contents
+ roff
- 2);
3817 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
3818 contents
+ roff
- 1);
3820 bfd_put_32 (output_bfd
,
3821 elf_x86_64_tpoff (info
, relocation
),
3829 if (htab
->elf
.sgot
== NULL
)
3834 off
= h
->got
.offset
;
3835 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
3839 if (local_got_offsets
== NULL
)
3842 off
= local_got_offsets
[r_symndx
];
3843 offplt
= local_tlsdesc_gotents
[r_symndx
];
3850 Elf_Internal_Rela outrel
;
3854 if (htab
->elf
.srelgot
== NULL
)
3857 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
3859 if (GOT_TLS_GDESC_P (tls_type
))
3861 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
3862 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
3863 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
3864 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
3865 + htab
->elf
.sgotplt
->output_offset
3867 + htab
->sgotplt_jump_table_size
);
3868 sreloc
= htab
->elf
.srelplt
;
3870 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
3872 outrel
.r_addend
= 0;
3873 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3876 sreloc
= htab
->elf
.srelgot
;
3878 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
3879 + htab
->elf
.sgot
->output_offset
+ off
);
3881 if (GOT_TLS_GD_P (tls_type
))
3882 dr_type
= R_X86_64_DTPMOD64
;
3883 else if (GOT_TLS_GDESC_P (tls_type
))
3886 dr_type
= R_X86_64_TPOFF64
;
3888 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
3889 outrel
.r_addend
= 0;
3890 if ((dr_type
== R_X86_64_TPOFF64
3891 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
3892 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
3893 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
3895 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3897 if (GOT_TLS_GD_P (tls_type
))
3901 BFD_ASSERT (! unresolved_reloc
);
3902 bfd_put_64 (output_bfd
,
3903 relocation
- elf_x86_64_dtpoff_base (info
),
3904 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
3908 bfd_put_64 (output_bfd
, 0,
3909 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
3910 outrel
.r_info
= htab
->r_info (indx
,
3912 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
3913 elf_append_rela (output_bfd
, sreloc
,
3922 local_got_offsets
[r_symndx
] |= 1;
3925 if (off
>= (bfd_vma
) -2
3926 && ! GOT_TLS_GDESC_P (tls_type
))
3928 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
3930 if (r_type
== R_X86_64_GOTPC32_TLSDESC
3931 || r_type
== R_X86_64_TLSDESC_CALL
)
3932 relocation
= htab
->elf
.sgotplt
->output_section
->vma
3933 + htab
->elf
.sgotplt
->output_offset
3934 + offplt
+ htab
->sgotplt_jump_table_size
;
3936 relocation
= htab
->elf
.sgot
->output_section
->vma
3937 + htab
->elf
.sgot
->output_offset
+ off
;
3938 unresolved_reloc
= FALSE
;
3942 bfd_vma roff
= rel
->r_offset
;
3944 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
3946 /* GD->IE transition. For 64bit, change
3947 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3948 .word 0x6666; rex64; call __tls_get_addr@plt
3951 addq foo@gottpoff(%rip), %rax
3953 leaq foo@tlsgd(%rip), %rdi
3954 .word 0x6666; rex64; call __tls_get_addr@plt
3957 addq foo@gottpoff(%rip), %rax */
3958 if (ABI_64_P (output_bfd
))
3959 memcpy (contents
+ roff
- 4,
3960 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3963 memcpy (contents
+ roff
- 3,
3964 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3967 relocation
= (htab
->elf
.sgot
->output_section
->vma
3968 + htab
->elf
.sgot
->output_offset
+ off
3970 - input_section
->output_section
->vma
3971 - input_section
->output_offset
3973 bfd_put_32 (output_bfd
, relocation
,
3974 contents
+ roff
+ 8);
3975 /* Skip R_X86_64_PLT32. */
3979 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
3981 /* GDesc -> IE transition.
3982 It's originally something like:
3983 leaq x@tlsdesc(%rip), %rax
3986 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
3988 /* Now modify the instruction as appropriate. To
3989 turn a leaq into a movq in the form we use it, it
3990 suffices to change the second byte from 0x8d to
3992 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
3994 bfd_put_32 (output_bfd
,
3995 htab
->elf
.sgot
->output_section
->vma
3996 + htab
->elf
.sgot
->output_offset
+ off
3998 - input_section
->output_section
->vma
3999 - input_section
->output_offset
4004 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4006 /* GDesc -> IE transition.
4013 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4014 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4022 case R_X86_64_TLSLD
:
4023 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4024 input_section
, contents
,
4025 symtab_hdr
, sym_hashes
,
4026 &r_type
, GOT_UNKNOWN
,
4027 rel
, relend
, h
, r_symndx
))
4030 if (r_type
!= R_X86_64_TLSLD
)
4032 /* LD->LE transition:
4033 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4034 For 64bit, we change it into:
4035 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4036 For 32bit, we change it into:
4037 nopl 0x0(%rax); movl %fs:0, %eax. */
4039 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
4040 if (ABI_64_P (output_bfd
))
4041 memcpy (contents
+ rel
->r_offset
- 3,
4042 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4044 memcpy (contents
+ rel
->r_offset
- 3,
4045 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4046 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
4051 if (htab
->elf
.sgot
== NULL
)
4054 off
= htab
->tls_ld_got
.offset
;
4059 Elf_Internal_Rela outrel
;
4061 if (htab
->elf
.srelgot
== NULL
)
4064 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4065 + htab
->elf
.sgot
->output_offset
+ off
);
4067 bfd_put_64 (output_bfd
, 0,
4068 htab
->elf
.sgot
->contents
+ off
);
4069 bfd_put_64 (output_bfd
, 0,
4070 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4071 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
4072 outrel
.r_addend
= 0;
4073 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
4075 htab
->tls_ld_got
.offset
|= 1;
4077 relocation
= htab
->elf
.sgot
->output_section
->vma
4078 + htab
->elf
.sgot
->output_offset
+ off
;
4079 unresolved_reloc
= FALSE
;
4082 case R_X86_64_DTPOFF32
:
4083 if (!info
->executable
|| (input_section
->flags
& SEC_CODE
) == 0)
4084 relocation
-= elf_x86_64_dtpoff_base (info
);
4086 relocation
= elf_x86_64_tpoff (info
, relocation
);
4089 case R_X86_64_TPOFF32
:
4090 case R_X86_64_TPOFF64
:
4091 BFD_ASSERT (info
->executable
);
4092 relocation
= elf_x86_64_tpoff (info
, relocation
);
4099 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4100 because such sections are not SEC_ALLOC and thus ld.so will
4101 not process them. */
4102 if (unresolved_reloc
4103 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
4105 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4106 rel
->r_offset
) != (bfd_vma
) -1)
4107 (*_bfd_error_handler
)
4108 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4111 (long) rel
->r_offset
,
4113 h
->root
.root
.string
);
4116 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4117 contents
, rel
->r_offset
,
4118 relocation
, rel
->r_addend
);
4120 check_relocation_error
:
4121 if (r
!= bfd_reloc_ok
)
4126 name
= h
->root
.root
.string
;
4129 name
= bfd_elf_string_from_elf_section (input_bfd
,
4130 symtab_hdr
->sh_link
,
4135 name
= bfd_section_name (input_bfd
, sec
);
4138 if (r
== bfd_reloc_overflow
)
4140 if (! ((*info
->callbacks
->reloc_overflow
)
4141 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4142 (bfd_vma
) 0, input_bfd
, input_section
,
4148 (*_bfd_error_handler
)
4149 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4150 input_bfd
, input_section
,
4151 (long) rel
->r_offset
, name
, (int) r
);
4160 /* Finish up dynamic symbol handling. We set the contents of various
4161 dynamic sections here. */
4164 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
4165 struct bfd_link_info
*info
,
4166 struct elf_link_hash_entry
*h
,
4167 Elf_Internal_Sym
*sym
)
4169 struct elf_x86_64_link_hash_table
*htab
;
4171 htab
= elf_x86_64_hash_table (info
);
4175 if (h
->plt
.offset
!= (bfd_vma
) -1)
4179 Elf_Internal_Rela rela
;
4181 asection
*plt
, *gotplt
, *relplt
;
4182 const struct elf_backend_data
*bed
;
4184 /* When building a static executable, use .iplt, .igot.plt and
4185 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4186 if (htab
->elf
.splt
!= NULL
)
4188 plt
= htab
->elf
.splt
;
4189 gotplt
= htab
->elf
.sgotplt
;
4190 relplt
= htab
->elf
.srelplt
;
4194 plt
= htab
->elf
.iplt
;
4195 gotplt
= htab
->elf
.igotplt
;
4196 relplt
= htab
->elf
.irelplt
;
4199 /* This symbol has an entry in the procedure linkage table. Set
4201 if ((h
->dynindx
== -1
4202 && !((h
->forced_local
|| info
->executable
)
4204 && h
->type
== STT_GNU_IFUNC
))
4210 /* Get the index in the procedure linkage table which
4211 corresponds to this symbol. This is the index of this symbol
4212 in all the symbols for which we are making plt entries. The
4213 first entry in the procedure linkage table is reserved.
4215 Get the offset into the .got table of the entry that
4216 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
4217 bytes. The first three are reserved for the dynamic linker.
4219 For static executables, we don't reserve anything. */
4221 if (plt
== htab
->elf
.splt
)
4223 got_offset
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
4224 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
4228 got_offset
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
4229 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
4232 /* Fill in the entry in the procedure linkage table. */
4233 memcpy (plt
->contents
+ h
->plt
.offset
, elf_x86_64_plt_entry
,
4236 /* Insert the relocation positions of the plt section. The magic
4237 numbers at the end of the statements are the positions of the
4238 relocations in the plt section. */
4239 /* Put offset for jmp *name@GOTPCREL(%rip), since the
4240 instruction uses 6 bytes, subtract this value. */
4241 bfd_put_32 (output_bfd
,
4242 (gotplt
->output_section
->vma
4243 + gotplt
->output_offset
4245 - plt
->output_section
->vma
4246 - plt
->output_offset
4249 plt
->contents
+ h
->plt
.offset
+ 2);
4251 /* Fill in the entry in the global offset table, initially this
4252 points to the pushq instruction in the PLT which is at offset 6. */
4253 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4254 + plt
->output_offset
4255 + h
->plt
.offset
+ 6),
4256 gotplt
->contents
+ got_offset
);
4258 /* Fill in the entry in the .rela.plt section. */
4259 rela
.r_offset
= (gotplt
->output_section
->vma
4260 + gotplt
->output_offset
4262 if (h
->dynindx
== -1
4263 || ((info
->executable
4264 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
4266 && h
->type
== STT_GNU_IFUNC
))
4268 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4269 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4270 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4271 rela
.r_addend
= (h
->root
.u
.def
.value
4272 + h
->root
.u
.def
.section
->output_section
->vma
4273 + h
->root
.u
.def
.section
->output_offset
);
4274 /* R_X86_64_IRELATIVE comes last. */
4275 plt_index
= htab
->next_irelative_index
--;
4279 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
4281 plt_index
= htab
->next_jump_slot_index
++;
4284 /* Don't fill PLT entry for static executables. */
4285 if (plt
== htab
->elf
.splt
)
4287 /* Put relocation index. */
4288 bfd_put_32 (output_bfd
, plt_index
,
4289 plt
->contents
+ h
->plt
.offset
+ 7);
4290 /* Put offset for jmp .PLT0. */
4291 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
4292 plt
->contents
+ h
->plt
.offset
+ 12);
4295 bed
= get_elf_backend_data (output_bfd
);
4296 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
4297 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
4299 if (!h
->def_regular
)
4301 /* Mark the symbol as undefined, rather than as defined in
4302 the .plt section. Leave the value if there were any
4303 relocations where pointer equality matters (this is a clue
4304 for the dynamic linker, to make function pointer
4305 comparisons work between an application and shared
4306 library), otherwise set it to zero. If a function is only
4307 called from a binary, there is no need to slow down
4308 shared libraries because of that. */
4309 sym
->st_shndx
= SHN_UNDEF
;
4310 if (!h
->pointer_equality_needed
)
4315 if (h
->got
.offset
!= (bfd_vma
) -1
4316 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
4317 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
)
4319 Elf_Internal_Rela rela
;
4321 /* This symbol has an entry in the global offset table. Set it
4323 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
4326 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4327 + htab
->elf
.sgot
->output_offset
4328 + (h
->got
.offset
&~ (bfd_vma
) 1));
4330 /* If this is a static link, or it is a -Bsymbolic link and the
4331 symbol is defined locally or was forced to be local because
4332 of a version file, we just want to emit a RELATIVE reloc.
4333 The entry in the global offset table will already have been
4334 initialized in the relocate_section function. */
4336 && h
->type
== STT_GNU_IFUNC
)
4340 /* Generate R_X86_64_GLOB_DAT. */
4347 if (!h
->pointer_equality_needed
)
4350 /* For non-shared object, we can't use .got.plt, which
4351 contains the real function addres if we need pointer
4352 equality. We load the GOT entry with the PLT entry. */
4353 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
4354 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4355 + plt
->output_offset
4357 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4361 else if (info
->shared
4362 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4364 if (!h
->def_regular
)
4366 BFD_ASSERT((h
->got
.offset
& 1) != 0);
4367 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4368 rela
.r_addend
= (h
->root
.u
.def
.value
4369 + h
->root
.u
.def
.section
->output_section
->vma
4370 + h
->root
.u
.def
.section
->output_offset
);
4374 BFD_ASSERT((h
->got
.offset
& 1) == 0);
4376 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
4377 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4378 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
4382 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
4387 Elf_Internal_Rela rela
;
4389 /* This symbol needs a copy reloc. Set it up. */
4391 if (h
->dynindx
== -1
4392 || (h
->root
.type
!= bfd_link_hash_defined
4393 && h
->root
.type
!= bfd_link_hash_defweak
)
4394 || htab
->srelbss
== NULL
)
4397 rela
.r_offset
= (h
->root
.u
.def
.value
4398 + h
->root
.u
.def
.section
->output_section
->vma
4399 + h
->root
.u
.def
.section
->output_offset
);
4400 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
4402 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
4405 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. SYM may
4406 be NULL for local symbols. */
4408 && (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
4409 || h
== htab
->elf
.hgot
))
4410 sym
->st_shndx
= SHN_ABS
;
4415 /* Finish up local dynamic symbol handling. We set the contents of
4416 various dynamic sections here. */
4419 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
4421 struct elf_link_hash_entry
*h
4422 = (struct elf_link_hash_entry
*) *slot
;
4423 struct bfd_link_info
*info
4424 = (struct bfd_link_info
*) inf
;
4426 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
4430 /* Used to decide how to sort relocs in an optimal manner for the
4431 dynamic linker, before writing them out. */
4433 static enum elf_reloc_type_class
4434 elf_x86_64_reloc_type_class (const Elf_Internal_Rela
*rela
)
4436 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4438 case R_X86_64_RELATIVE
:
4439 return reloc_class_relative
;
4440 case R_X86_64_JUMP_SLOT
:
4441 return reloc_class_plt
;
4443 return reloc_class_copy
;
4445 return reloc_class_normal
;
4449 /* Finish up the dynamic sections. */
4452 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
4453 struct bfd_link_info
*info
)
4455 struct elf_x86_64_link_hash_table
*htab
;
4459 htab
= elf_x86_64_hash_table (info
);
4463 dynobj
= htab
->elf
.dynobj
;
4464 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4466 if (htab
->elf
.dynamic_sections_created
)
4468 bfd_byte
*dyncon
, *dynconend
;
4469 const struct elf_backend_data
*bed
;
4470 bfd_size_type sizeof_dyn
;
4472 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
4475 bed
= get_elf_backend_data (dynobj
);
4476 sizeof_dyn
= bed
->s
->sizeof_dyn
;
4477 dyncon
= sdyn
->contents
;
4478 dynconend
= sdyn
->contents
+ sdyn
->size
;
4479 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
4481 Elf_Internal_Dyn dyn
;
4484 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
4492 s
= htab
->elf
.sgotplt
;
4493 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
4497 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
4501 s
= htab
->elf
.srelplt
->output_section
;
4502 dyn
.d_un
.d_val
= s
->size
;
4506 /* The procedure linkage table relocs (DT_JMPREL) should
4507 not be included in the overall relocs (DT_RELA).
4508 Therefore, we override the DT_RELASZ entry here to
4509 make it not include the JMPREL relocs. Since the
4510 linker script arranges for .rela.plt to follow all
4511 other relocation sections, we don't have to worry
4512 about changing the DT_RELA entry. */
4513 if (htab
->elf
.srelplt
!= NULL
)
4515 s
= htab
->elf
.srelplt
->output_section
;
4516 dyn
.d_un
.d_val
-= s
->size
;
4520 case DT_TLSDESC_PLT
:
4522 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
4523 + htab
->tlsdesc_plt
;
4526 case DT_TLSDESC_GOT
:
4528 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
4529 + htab
->tlsdesc_got
;
4533 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
4536 /* Fill in the special first entry in the procedure linkage table. */
4537 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
4539 /* Fill in the first entry in the procedure linkage table. */
4540 memcpy (htab
->elf
.splt
->contents
, elf_x86_64_plt0_entry
,
4542 /* Add offset for pushq GOT+8(%rip), since the instruction
4543 uses 6 bytes subtract this value. */
4544 bfd_put_32 (output_bfd
,
4545 (htab
->elf
.sgotplt
->output_section
->vma
4546 + htab
->elf
.sgotplt
->output_offset
4548 - htab
->elf
.splt
->output_section
->vma
4549 - htab
->elf
.splt
->output_offset
4551 htab
->elf
.splt
->contents
+ 2);
4552 /* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
4553 the end of the instruction. */
4554 bfd_put_32 (output_bfd
,
4555 (htab
->elf
.sgotplt
->output_section
->vma
4556 + htab
->elf
.sgotplt
->output_offset
4558 - htab
->elf
.splt
->output_section
->vma
4559 - htab
->elf
.splt
->output_offset
4561 htab
->elf
.splt
->contents
+ 8);
4563 elf_section_data (htab
->elf
.splt
->output_section
)->this_hdr
.sh_entsize
=
4566 if (htab
->tlsdesc_plt
)
4568 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
4569 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
4571 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
4572 elf_x86_64_plt0_entry
,
4575 /* Add offset for pushq GOT+8(%rip), since the
4576 instruction uses 6 bytes subtract this value. */
4577 bfd_put_32 (output_bfd
,
4578 (htab
->elf
.sgotplt
->output_section
->vma
4579 + htab
->elf
.sgotplt
->output_offset
4581 - htab
->elf
.splt
->output_section
->vma
4582 - htab
->elf
.splt
->output_offset
4585 htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
+ 2);
4586 /* Add offset for jmp *GOT+TDG(%rip), where TGD stands for
4587 htab->tlsdesc_got. The 12 is the offset to the end of
4589 bfd_put_32 (output_bfd
,
4590 (htab
->elf
.sgot
->output_section
->vma
4591 + htab
->elf
.sgot
->output_offset
4593 - htab
->elf
.splt
->output_section
->vma
4594 - htab
->elf
.splt
->output_offset
4597 htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
+ 8);
4602 if (htab
->elf
.sgotplt
)
4604 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
4606 (*_bfd_error_handler
)
4607 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
4611 /* Fill in the first three entries in the global offset table. */
4612 if (htab
->elf
.sgotplt
->size
> 0)
4614 /* Set the first entry in the global offset table to the address of
4615 the dynamic section. */
4617 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
4619 bfd_put_64 (output_bfd
,
4620 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
4621 htab
->elf
.sgotplt
->contents
);
4622 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
4623 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
4624 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
4627 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
4631 /* Adjust .eh_frame for .plt section. */
4632 if (htab
->plt_eh_frame
!= NULL
)
4634 if (htab
->elf
.splt
!= NULL
4635 && htab
->elf
.splt
->size
!= 0
4636 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
4637 && htab
->elf
.splt
->output_section
!= NULL
4638 && htab
->plt_eh_frame
->output_section
!= NULL
)
4640 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
4641 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
4642 + htab
->plt_eh_frame
->output_offset
4643 + PLT_FDE_START_OFFSET
;
4644 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
4645 htab
->plt_eh_frame
->contents
4646 + PLT_FDE_START_OFFSET
);
4648 if (htab
->plt_eh_frame
->sec_info_type
4649 == ELF_INFO_TYPE_EH_FRAME
)
4651 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
4653 htab
->plt_eh_frame
->contents
))
4658 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
4659 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
4662 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4663 htab_traverse (htab
->loc_hash_table
,
4664 elf_x86_64_finish_local_dynamic_symbol
,
4670 /* Return address for Ith PLT stub in section PLT, for relocation REL
4671 or (bfd_vma) -1 if it should not be included. */
4674 elf_x86_64_plt_sym_val (bfd_vma i
, const asection
*plt
,
4675 const arelent
*rel ATTRIBUTE_UNUSED
)
4677 return plt
->vma
+ (i
+ 1) * PLT_ENTRY_SIZE
;
4680 /* Handle an x86-64 specific section when reading an object file. This
4681 is called when elfcode.h finds a section with an unknown type. */
4684 elf_x86_64_section_from_shdr (bfd
*abfd
,
4685 Elf_Internal_Shdr
*hdr
,
4689 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
4692 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
4698 /* Hook called by the linker routine which adds symbols from an object
4699 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4703 elf_x86_64_add_symbol_hook (bfd
*abfd
,
4704 struct bfd_link_info
*info
,
4705 Elf_Internal_Sym
*sym
,
4706 const char **namep ATTRIBUTE_UNUSED
,
4707 flagword
*flagsp ATTRIBUTE_UNUSED
,
4713 switch (sym
->st_shndx
)
4715 case SHN_X86_64_LCOMMON
:
4716 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
4719 lcomm
= bfd_make_section_with_flags (abfd
,
4723 | SEC_LINKER_CREATED
));
4726 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
4729 *valp
= sym
->st_size
;
4733 if ((abfd
->flags
& DYNAMIC
) == 0
4734 && (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
4735 || ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
))
4736 elf_tdata (info
->output_bfd
)->has_gnu_symbols
= TRUE
;
4742 /* Given a BFD section, try to locate the corresponding ELF section
4746 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4747 asection
*sec
, int *index_return
)
4749 if (sec
== &_bfd_elf_large_com_section
)
4751 *index_return
= SHN_X86_64_LCOMMON
;
4757 /* Process a symbol. */
4760 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
4763 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
4765 switch (elfsym
->internal_elf_sym
.st_shndx
)
4767 case SHN_X86_64_LCOMMON
:
4768 asym
->section
= &_bfd_elf_large_com_section
;
4769 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4770 /* Common symbol doesn't set BSF_GLOBAL. */
4771 asym
->flags
&= ~BSF_GLOBAL
;
4777 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
4779 return (sym
->st_shndx
== SHN_COMMON
4780 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
4784 elf_x86_64_common_section_index (asection
*sec
)
4786 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
4789 return SHN_X86_64_LCOMMON
;
4793 elf_x86_64_common_section (asection
*sec
)
4795 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
4796 return bfd_com_section_ptr
;
4798 return &_bfd_elf_large_com_section
;
4802 elf_x86_64_merge_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4803 struct elf_link_hash_entry
**sym_hash ATTRIBUTE_UNUSED
,
4804 struct elf_link_hash_entry
*h
,
4805 Elf_Internal_Sym
*sym
,
4807 bfd_vma
*pvalue ATTRIBUTE_UNUSED
,
4808 unsigned int *pold_alignment ATTRIBUTE_UNUSED
,
4809 bfd_boolean
*skip ATTRIBUTE_UNUSED
,
4810 bfd_boolean
*override ATTRIBUTE_UNUSED
,
4811 bfd_boolean
*type_change_ok ATTRIBUTE_UNUSED
,
4812 bfd_boolean
*size_change_ok ATTRIBUTE_UNUSED
,
4813 bfd_boolean
*newdyn ATTRIBUTE_UNUSED
,
4814 bfd_boolean
*newdef
,
4815 bfd_boolean
*newdyncommon ATTRIBUTE_UNUSED
,
4816 bfd_boolean
*newweak ATTRIBUTE_UNUSED
,
4817 bfd
*abfd ATTRIBUTE_UNUSED
,
4819 bfd_boolean
*olddyn ATTRIBUTE_UNUSED
,
4820 bfd_boolean
*olddef
,
4821 bfd_boolean
*olddyncommon ATTRIBUTE_UNUSED
,
4822 bfd_boolean
*oldweak ATTRIBUTE_UNUSED
,
4826 /* A normal common symbol and a large common symbol result in a
4827 normal common symbol. We turn the large common symbol into a
4830 && h
->root
.type
== bfd_link_hash_common
4832 && bfd_is_com_section (*sec
)
4835 if (sym
->st_shndx
== SHN_COMMON
4836 && (elf_section_flags (*oldsec
) & SHF_X86_64_LARGE
) != 0)
4838 h
->root
.u
.c
.p
->section
4839 = bfd_make_section_old_way (oldbfd
, "COMMON");
4840 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
4842 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
4843 && (elf_section_flags (*oldsec
) & SHF_X86_64_LARGE
) == 0)
4844 *psec
= *sec
= bfd_com_section_ptr
;
4851 elf_x86_64_additional_program_headers (bfd
*abfd
,
4852 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
4857 /* Check to see if we need a large readonly segment. */
4858 s
= bfd_get_section_by_name (abfd
, ".lrodata");
4859 if (s
&& (s
->flags
& SEC_LOAD
))
4862 /* Check to see if we need a large data segment. Since .lbss sections
4863 is placed right after the .bss section, there should be no need for
4864 a large data segment just because of .lbss. */
4865 s
= bfd_get_section_by_name (abfd
, ".ldata");
4866 if (s
&& (s
->flags
& SEC_LOAD
))
4872 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
4875 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
4877 if (h
->plt
.offset
!= (bfd_vma
) -1
4879 && !h
->pointer_equality_needed
)
4882 return _bfd_elf_hash_symbol (h
);
4885 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
4888 elf_x86_64_relocs_compatible (const bfd_target
*input
,
4889 const bfd_target
*output
)
4891 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
4892 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
4893 && _bfd_elf_relocs_compatible (input
, output
));
4896 static const struct bfd_elf_special_section
4897 elf_x86_64_special_sections
[]=
4899 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
4900 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
4901 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
4902 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
4903 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
4904 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
4905 { NULL
, 0, 0, 0, 0 }
4908 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
4909 #define TARGET_LITTLE_NAME "elf64-x86-64"
4910 #define ELF_ARCH bfd_arch_i386
4911 #define ELF_TARGET_ID X86_64_ELF_DATA
4912 #define ELF_MACHINE_CODE EM_X86_64
4913 #define ELF_MAXPAGESIZE 0x200000
4914 #define ELF_MINPAGESIZE 0x1000
4915 #define ELF_COMMONPAGESIZE 0x1000
4917 #define elf_backend_can_gc_sections 1
4918 #define elf_backend_can_refcount 1
4919 #define elf_backend_want_got_plt 1
4920 #define elf_backend_plt_readonly 1
4921 #define elf_backend_want_plt_sym 0
4922 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
4923 #define elf_backend_rela_normal 1
4924 #define elf_backend_plt_alignment 4
4926 #define elf_info_to_howto elf_x86_64_info_to_howto
4928 #define bfd_elf64_bfd_link_hash_table_create \
4929 elf_x86_64_link_hash_table_create
4930 #define bfd_elf64_bfd_link_hash_table_free \
4931 elf_x86_64_link_hash_table_free
4932 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
4933 #define bfd_elf64_bfd_reloc_name_lookup \
4934 elf_x86_64_reloc_name_lookup
4936 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
4937 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
4938 #define elf_backend_check_relocs elf_x86_64_check_relocs
4939 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
4940 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
4941 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
4942 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
4943 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
4944 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
4945 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
4946 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
4948 #define elf_backend_write_core_note elf_x86_64_write_core_note
4950 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
4951 #define elf_backend_relocate_section elf_x86_64_relocate_section
4952 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
4953 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
4954 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4955 #define elf_backend_plt_sym_val elf_x86_64_plt_sym_val
4956 #define elf_backend_object_p elf64_x86_64_elf_object_p
4957 #define bfd_elf64_mkobject elf_x86_64_mkobject
4959 #define elf_backend_section_from_shdr \
4960 elf_x86_64_section_from_shdr
4962 #define elf_backend_section_from_bfd_section \
4963 elf_x86_64_elf_section_from_bfd_section
4964 #define elf_backend_add_symbol_hook \
4965 elf_x86_64_add_symbol_hook
4966 #define elf_backend_symbol_processing \
4967 elf_x86_64_symbol_processing
4968 #define elf_backend_common_section_index \
4969 elf_x86_64_common_section_index
4970 #define elf_backend_common_section \
4971 elf_x86_64_common_section
4972 #define elf_backend_common_definition \
4973 elf_x86_64_common_definition
4974 #define elf_backend_merge_symbol \
4975 elf_x86_64_merge_symbol
4976 #define elf_backend_special_sections \
4977 elf_x86_64_special_sections
4978 #define elf_backend_additional_program_headers \
4979 elf_x86_64_additional_program_headers
4980 #define elf_backend_hash_symbol \
4981 elf_x86_64_hash_symbol
4983 #define elf_backend_post_process_headers _bfd_elf_set_osabi
4985 #include "elf64-target.h"
4987 /* FreeBSD support. */
4989 #undef TARGET_LITTLE_SYM
4990 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_freebsd_vec
4991 #undef TARGET_LITTLE_NAME
4992 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
4995 #define ELF_OSABI ELFOSABI_FREEBSD
4998 #define elf64_bed elf64_x86_64_fbsd_bed
5000 #include "elf64-target.h"
5002 /* Solaris 2 support. */
5004 #undef TARGET_LITTLE_SYM
5005 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_sol2_vec
5006 #undef TARGET_LITTLE_NAME
5007 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5009 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5010 objects won't be recognized. */
5014 #define elf64_bed elf64_x86_64_sol2_bed
5016 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5018 #undef elf_backend_static_tls_alignment
5019 #define elf_backend_static_tls_alignment 16
5021 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5023 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5025 #undef elf_backend_want_plt_sym
5026 #define elf_backend_want_plt_sym 1
5028 #include "elf64-target.h"
5030 /* Intel L1OM support. */
5033 elf64_l1om_elf_object_p (bfd
*abfd
)
5035 /* Set the right machine number for an L1OM elf64 file. */
5036 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
5040 #undef TARGET_LITTLE_SYM
5041 #define TARGET_LITTLE_SYM bfd_elf64_l1om_vec
5042 #undef TARGET_LITTLE_NAME
5043 #define TARGET_LITTLE_NAME "elf64-l1om"
5045 #define ELF_ARCH bfd_arch_l1om
5047 #undef ELF_MACHINE_CODE
5048 #define ELF_MACHINE_CODE EM_L1OM
5053 #define elf64_bed elf64_l1om_bed
5055 #undef elf_backend_object_p
5056 #define elf_backend_object_p elf64_l1om_elf_object_p
5058 #undef elf_backend_static_tls_alignment
5060 #undef elf_backend_want_plt_sym
5061 #define elf_backend_want_plt_sym 0
5063 #include "elf64-target.h"
5065 /* FreeBSD L1OM support. */
5067 #undef TARGET_LITTLE_SYM
5068 #define TARGET_LITTLE_SYM bfd_elf64_l1om_freebsd_vec
5069 #undef TARGET_LITTLE_NAME
5070 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
5073 #define ELF_OSABI ELFOSABI_FREEBSD
5076 #define elf64_bed elf64_l1om_fbsd_bed
5078 #include "elf64-target.h"
5080 /* Intel K1OM support. */
5083 elf64_k1om_elf_object_p (bfd
*abfd
)
5085 /* Set the right machine number for an K1OM elf64 file. */
5086 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
5090 #undef TARGET_LITTLE_SYM
5091 #define TARGET_LITTLE_SYM bfd_elf64_k1om_vec
5092 #undef TARGET_LITTLE_NAME
5093 #define TARGET_LITTLE_NAME "elf64-k1om"
5095 #define ELF_ARCH bfd_arch_k1om
5097 #undef ELF_MACHINE_CODE
5098 #define ELF_MACHINE_CODE EM_K1OM
5103 #define elf64_bed elf64_k1om_bed
5105 #undef elf_backend_object_p
5106 #define elf_backend_object_p elf64_k1om_elf_object_p
5108 #undef elf_backend_static_tls_alignment
5110 #undef elf_backend_want_plt_sym
5111 #define elf_backend_want_plt_sym 0
5113 #include "elf64-target.h"
5115 /* FreeBSD K1OM support. */
5117 #undef TARGET_LITTLE_SYM
5118 #define TARGET_LITTLE_SYM bfd_elf64_k1om_freebsd_vec
5119 #undef TARGET_LITTLE_NAME
5120 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
5123 #define ELF_OSABI ELFOSABI_FREEBSD
5126 #define elf64_bed elf64_k1om_fbsd_bed
5128 #include "elf64-target.h"
5130 /* 32bit x86-64 support. */
5133 elf32_x86_64_elf_object_p (bfd
*abfd
)
5135 /* Set the right machine number for an x86-64 elf32 file. */
5136 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
5140 #undef TARGET_LITTLE_SYM
5141 #define TARGET_LITTLE_SYM bfd_elf32_x86_64_vec
5142 #undef TARGET_LITTLE_NAME
5143 #define TARGET_LITTLE_NAME "elf32-x86-64"
5146 #define ELF_ARCH bfd_arch_i386
5148 #undef ELF_MACHINE_CODE
5149 #define ELF_MACHINE_CODE EM_X86_64
5151 #define bfd_elf32_bfd_link_hash_table_create \
5152 elf_x86_64_link_hash_table_create
5153 #define bfd_elf32_bfd_link_hash_table_free \
5154 elf_x86_64_link_hash_table_free
5155 #define bfd_elf32_bfd_reloc_type_lookup \
5156 elf_x86_64_reloc_type_lookup
5157 #define bfd_elf32_bfd_reloc_name_lookup \
5158 elf_x86_64_reloc_name_lookup
5159 #define bfd_elf32_mkobject \
5164 #undef elf_backend_object_p
5165 #define elf_backend_object_p \
5166 elf32_x86_64_elf_object_p
5168 #undef elf_backend_bfd_from_remote_memory
5169 #define elf_backend_bfd_from_remote_memory \
5170 _bfd_elf32_bfd_from_remote_memory
5172 #undef elf_backend_size_info
5173 #define elf_backend_size_info \
5174 _bfd_elf32_size_info
5176 #include "elf32-target.h"