]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - bfd/elf64-x86-64.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
PR gold/13850
[thirdparty/binutils-gdb.git] / bfd / elf64-x86-64.c
CommitLineData
351f65ca 1/* X86-64 specific support for ELF
4dfe6ac6 2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
3ce231f8 3 2010, 2011, 2012
9f973f28 4 Free Software Foundation, Inc.
8d88c4ca
NC		 5 Contributed by Jan Hubicka <jh@suse.cz>.
6
ae9a127f 7 This file is part of BFD, the Binary File Descriptor library.
8d88c4ca 8
ae9a127f
NC		 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
cd123cb7 11 the Free Software Foundation; either version 3 of the License, or
ae9a127f 12 (at your option) any later version.
8d88c4ca 13
ae9a127f
NC		 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.
8d88c4ca 18
ae9a127f
NC		 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
cd123cb7
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
8d88c4ca 23
8d88c4ca 24#include "sysdep.h"
3db64b00 25#include "bfd.h"
c434dee6 26#include "bfdlink.h"
8d88c4ca
NC		 27#include "libbfd.h"
28#include "elf-bfd.h"
142411ca 29#include "bfd_stdint.h"
c25bc9fc
L		 30#include "objalloc.h"
31#include "hashtab.h"
e41b3a13 32#include "dwarf2.h"
d7921315 33#include "libiberty.h"
8d88c4ca
NC		 34
35#include "elf/x86-64.h"
36
8fd79e71
L		 37#ifdef CORE_HEADER
38#include <stdarg.h>
39#include CORE_HEADER
40#endif
41
8d88c4ca
NC		 42/* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
43#define MINUS_ONE (~ (bfd_vma) 0)
44
351f65ca
L		 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. */
49
50#define ABI_64_P(abfd) \
51 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
52
8d88c4ca 53/* The relocation "howto" table. Order of fields:
7b81dfbb
AJ		 54 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
55 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
70256ad8
AJ		 56static reloc_howto_type x86_64_elf_howto_table[] =
57{
b34976b6
AM		 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,
60 FALSE),
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,
63 FALSE),
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,
66 TRUE),
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,
69 FALSE),
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,
72 TRUE),
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,
75 FALSE),
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,
78 MINUS_ONE, FALSE),
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,
81 MINUS_ONE, FALSE),
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,
84 MINUS_ONE, FALSE),
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,
87 0xffffffff, TRUE),
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,
90 FALSE),
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,
93 FALSE),
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),
b0360d8c 96 HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_bitfield,
b34976b6 97 bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE),
ac2aa337 98 HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
b34976b6
AM		 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,
104 MINUS_ONE, FALSE),
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,
107 MINUS_ONE, FALSE),
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,
110 MINUS_ONE, FALSE),
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,
113 0xffffffff, TRUE),
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,
116 0xffffffff, TRUE),
ac2aa337 117 HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
b34976b6
AM		 118 bfd_elf_generic_reloc, "R_X86_64_DTPOFF32", FALSE, 0xffffffff,
119 0xffffffff, FALSE),
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,
122 0xffffffff, TRUE),
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,
125 0xffffffff, FALSE),
d6ab8113
JB		 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,
128 TRUE),
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),
7b81dfbb
AJ		 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,
137 FALSE),
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,
140 MINUS_ONE, TRUE),
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,
146 MINUS_ONE, FALSE),
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,
149 MINUS_ONE, FALSE),
67a4f2b7
AO		 150 EMPTY_HOWTO (32),
151 EMPTY_HOWTO (33),
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",
159 FALSE, 0, 0, FALSE),
160 HOWTO(R_X86_64_TLSDESC, 0, 4, 64, FALSE, 0,
161 complain_overflow_bitfield, bfd_elf_generic_reloc,
162 "R_X86_64_TLSDESC",
163 FALSE, MINUS_ONE, MINUS_ONE, FALSE),
cbe950e9
L		 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,
166 MINUS_ONE, FALSE),
64d25c44
L		 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,
169 MINUS_ONE, FALSE),
fe4770f4 170
a33d77bc
JB		 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. */
cbe950e9 175#define R_X86_64_standard (R_X86_64_IRELATIVE + 1)
a33d77bc
JB		 176#define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
177
fe4770f4 178/* GNU extension to record C++ vtable hierarchy. */
b34976b6
AM		 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),
fe4770f4
AJ		 181
182/* GNU extension to record C++ vtable member usage. */
b34976b6
AM		 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,
d7921315
L		 185 FALSE),
186
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,
190 FALSE)
8d88c4ca
NC		 191};
192
d8045f23
NC		 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))
198
8d88c4ca 199/* Map BFD relocs to the x86_64 elf relocs. */
70256ad8
AJ		 200struct elf_reloc_map
201{
8d88c4ca
NC		 202 bfd_reloc_code_real_type bfd_reloc_val;
203 unsigned char elf_reloc_val;
204};
205
dc810e39 206static const struct elf_reloc_map x86_64_reloc_map[] =
8d88c4ca 207{
70256ad8
AJ		 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, },
bffbf940
JJ		 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, },
d6ab8113
JB		 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, },
7b81dfbb
AJ		 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, },
67a4f2b7
AO		 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, },
cbe950e9 243 { BFD_RELOC_X86_64_IRELATIVE, R_X86_64_IRELATIVE, },
fe4770f4
AJ		 244 { BFD_RELOC_VTABLE_INHERIT, R_X86_64_GNU_VTINHERIT, },
245 { BFD_RELOC_VTABLE_ENTRY, R_X86_64_GNU_VTENTRY, },
8d88c4ca
NC		 246};
247
67a4f2b7 248static reloc_howto_type *
351f65ca 249elf_x86_64_rtype_to_howto (bfd *abfd, unsigned r_type)
67a4f2b7
AO		 250{
251 unsigned i;
252
d7921315
L		 253 if (r_type == (unsigned int) R_X86_64_32)
254 {
255 if (ABI_64_P (abfd))
256 i = r_type;
257 else
258 i = ARRAY_SIZE (x86_64_elf_howto_table) - 1;
259 }
260 else if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT
261 || r_type >= (unsigned int) R_X86_64_max)
67a4f2b7
AO		 262 {
263 if (r_type >= (unsigned int) R_X86_64_standard)
264 {
265 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
266 abfd, (int) r_type);
267 r_type = R_X86_64_NONE;
268 }
269 i = r_type;
270 }
271 else
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];
275}
8d88c4ca
NC		 276
277/* Given a BFD reloc type, return a HOWTO structure. */
278static reloc_howto_type *
351f65ca
L		 279elf_x86_64_reloc_type_lookup (bfd *abfd,
280 bfd_reloc_code_real_type code)
8d88c4ca
NC		 281{
282 unsigned int i;
27482721 283
8d88c4ca
NC		 284 for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
285 i++)
286 {
287 if (x86_64_reloc_map[i].bfd_reloc_val == code)
351f65ca
L		 288 return elf_x86_64_rtype_to_howto (abfd,
289 x86_64_reloc_map[i].elf_reloc_val);
8d88c4ca
NC		 290 }
291 return 0;
292}
293
157090f7 294static reloc_howto_type *
d7921315 295elf_x86_64_reloc_name_lookup (bfd *abfd,
351f65ca 296 const char *r_name)
157090f7
AM		 297{
298 unsigned int i;
299
d7921315
L		 300 if (!ABI_64_P (abfd) && strcasecmp (r_name, "R_X86_64_32") == 0)
301 {
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);
306 return reloc;
307 }
308
309 for (i = 0; i < ARRAY_SIZE (x86_64_elf_howto_table); i++)
157090f7
AM		 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];
313
314 return NULL;
315}
316
8d88c4ca 317/* Given an x86_64 ELF reloc type, fill in an arelent structure. */
8da6118f 318
8d88c4ca 319static void
351f65ca
L		 320elf_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
321 Elf_Internal_Rela *dst)
8d88c4ca 322{
67a4f2b7 323 unsigned r_type;
8d88c4ca 324
351f65ca
L		 325 r_type = ELF32_R_TYPE (dst->r_info);
326 cache_ptr->howto = elf_x86_64_rtype_to_howto (abfd, r_type);
8d88c4ca
NC		 327 BFD_ASSERT (r_type == cache_ptr->howto->type);
328}
70256ad8 329\f
3bab7989 330/* Support for core dump NOTE sections. */
b34976b6 331static bfd_boolean
351f65ca 332elf_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3bab7989
ML		 333{
334 int offset;
eea6121a 335 size_t size;
3bab7989
ML		 336
337 switch (note->descsz)
338 {
339 default:
b34976b6 340 return FALSE;
3bab7989 341
bcd823f1
L		 342 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
343 /* pr_cursig */
344 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
345
346 /* pr_pid */
347 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
348
349 /* pr_reg */
350 offset = 72;
351 size = 216;
352
353 break;
354
3bab7989
ML		 355 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
356 /* pr_cursig */
cedb70c5 357 elf_tdata (abfd)->core_signal
3bab7989
ML		 358 = bfd_get_16 (abfd, note->descdata + 12);
359
360 /* pr_pid */
261b8d08 361 elf_tdata (abfd)->core_lwpid
3bab7989
ML		 362 = bfd_get_32 (abfd, note->descdata + 32);
363
364 /* pr_reg */
365 offset = 112;
eea6121a 366 size = 216;
3bab7989
ML		 367
368 break;
369 }
370
371 /* Make a ".reg/999" section. */
372 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 373 size, note->descpos + offset);
3bab7989
ML		 374}
375
b34976b6 376static bfd_boolean
351f65ca 377elf_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3bab7989
ML		 378{
379 switch (note->descsz)
380 {
381 default:
b34976b6 382 return FALSE;
3bab7989 383
bcd823f1
L		 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);
391 break;
392
3bab7989 393 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
261b8d08
PA		 394 elf_tdata (abfd)->core_pid
395 = bfd_get_32 (abfd, note->descdata + 24);
3bab7989
ML		 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);
400 }
401
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. */
405
406 {
407 char *command = elf_tdata (abfd)->core_command;
408 int n = strlen (command);
409
410 if (0 < n && command[n - 1] == ' ')
411 command[n - 1] = '\0';
412 }
413
b34976b6 414 return TRUE;
3bab7989 415}
8fd79e71
L		 416
417#ifdef CORE_HEADER
418static char *
419elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz,
420 int note_type, ...)
421{
422 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8fd79e71
L		 423 va_list ap;
424 const char *fname, *psargs;
425 long pid;
426 int cursig;
427 const void *gregs;
428
429 switch (note_type)
430 {
431 default:
432 return NULL;
433
434 case NT_PRPSINFO:
435 va_start (ap, note_type);
436 fname = va_arg (ap, const char *);
437 psargs = va_arg (ap, const char *);
438 va_end (ap);
439
440 if (bed->s->elfclass == ELFCLASS32)
441 {
442 prpsinfo32_t data;
443 memset (&data, 0, sizeof (data));
444 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
445 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
e85c6a70
JK		 446 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
447 &data, sizeof (data));
8fd79e71
L		 448 }
449 else
450 {
451 prpsinfo_t data;
452 memset (&data, 0, sizeof (data));
453 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
454 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
e85c6a70
JK		 455 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
456 &data, sizeof (data));
8fd79e71 457 }
e85c6a70 458 /* NOTREACHED */
8fd79e71
L		 459
460 case NT_PRSTATUS:
461 va_start (ap, note_type);
462 pid = va_arg (ap, long);
463 cursig = va_arg (ap, int);
464 gregs = va_arg (ap, const void *);
465 va_end (ap);
466
467 if (bed->s->elfclass == ELFCLASS32)
468 {
469 if (bed->elf_machine_code == EM_X86_64)
470 {
471 prstatusx32_t prstat;
472 memset (&prstat, 0, sizeof (prstat));
473 prstat.pr_pid = pid;
474 prstat.pr_cursig = cursig;
475 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
e85c6a70
JK		 476 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
477 &prstat, sizeof (prstat));
8fd79e71
L		 478 }
479 else
480 {
481 prstatus32_t prstat;
482 memset (&prstat, 0, sizeof (prstat));
483 prstat.pr_pid = pid;
484 prstat.pr_cursig = cursig;
485 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
e85c6a70
JK		 486 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
487 &prstat, sizeof (prstat));
8fd79e71
L		 488 }
489 }
490 else
491 {
492 prstatus_t prstat;
493 memset (&prstat, 0, sizeof (prstat));
494 prstat.pr_pid = pid;
495 prstat.pr_cursig = cursig;
496 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
e85c6a70
JK		 497 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
498 &prstat, sizeof (prstat));
8fd79e71 499 }
8fd79e71 500 }
e85c6a70 501 /* NOTREACHED */
8fd79e71
L		 502}
503#endif
3bab7989 504\f
407443a3 505/* Functions for the x86-64 ELF linker. */
70256ad8 506
407443a3 507/* The name of the dynamic interpreter. This is put in the .interp
70256ad8
AJ		 508 section. */
509
351f65ca 510#define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
eec9dd95 511#define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
70256ad8 512
d40d037c
AJ		 513/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
514 copying dynamic variables from a shared lib into an app's dynbss
515 section, and instead use a dynamic relocation to point into the
516 shared lib. */
517#define ELIMINATE_COPY_RELOCS 1
518
70256ad8
AJ		 519/* The size in bytes of an entry in the global offset table. */
520
521#define GOT_ENTRY_SIZE 8
8d88c4ca 522
70256ad8 523/* The size in bytes of an entry in the procedure linkage table. */
8d88c4ca 524
70256ad8
AJ		 525#define PLT_ENTRY_SIZE 16
526
527/* The first entry in a procedure linkage table looks like this. See the
528 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
529
351f65ca 530static const bfd_byte elf_x86_64_plt0_entry[PLT_ENTRY_SIZE] =
70256ad8 531{
653165cc
AJ		 532 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
533 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
10efb593 534 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
70256ad8
AJ		 535};
536
537/* Subsequent entries in a procedure linkage table look like this. */
538
351f65ca 539static const bfd_byte elf_x86_64_plt_entry[PLT_ENTRY_SIZE] =
70256ad8 540{
653165cc 541 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
407443a3 542 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
653165cc 543 0x68, /* pushq immediate */
70256ad8
AJ		 544 0, 0, 0, 0, /* replaced with index into relocation table. */
545 0xe9, /* jmp relative */
546 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
547};
548
e41b3a13
JJ		 549/* .eh_frame covering the .plt section. */
550
551static const bfd_byte elf_x86_64_eh_frame_plt[] =
552{
553#define PLT_CIE_LENGTH 20
554#define PLT_FDE_LENGTH 36
555#define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
556#define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
557 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
558 0, 0, 0, 0, /* CIE ID */
559 1, /* CIE version */
560 'z', 'R', 0, /* Augmentation string */
561 1, /* Code alignment factor */
562 0x78, /* Data alignment factor */
563 16, /* Return address column */
564 1, /* Augmentation size */
565 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
566 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
567 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
568 DW_CFA_nop, DW_CFA_nop,
569
570 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
571 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
572 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
573 0, 0, 0, 0, /* .plt size goes here */
574 0, /* Augmentation size */
575 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
576 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
577 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
578 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
579 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
580 11, /* Block length */
581 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
582 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
583 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
584 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
585 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
586};
587
70256ad8
AJ		 588/* x86-64 ELF linker hash entry. */
589
351f65ca 590struct elf_x86_64_link_hash_entry
70256ad8 591{
c434dee6 592 struct elf_link_hash_entry elf;
70256ad8 593
c434dee6 594 /* Track dynamic relocs copied for this symbol. */
e03a8ed8 595 struct elf_dyn_relocs *dyn_relocs;
bffbf940
JJ		 596
597#define GOT_UNKNOWN 0
598#define GOT_NORMAL 1
599#define GOT_TLS_GD 2
600#define GOT_TLS_IE 3
67a4f2b7
AO		 601#define GOT_TLS_GDESC 4
602#define GOT_TLS_GD_BOTH_P(type) \
603 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
604#define GOT_TLS_GD_P(type) \
605 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
606#define GOT_TLS_GDESC_P(type) \
607 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
608#define GOT_TLS_GD_ANY_P(type) \
609 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
bffbf940 610 unsigned char tls_type;
67a4f2b7
AO		 611
612 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
613 starting at the end of the jump table. */
614 bfd_vma tlsdesc_got;
bffbf940
JJ		 615};
616
351f65ca
L		 617#define elf_x86_64_hash_entry(ent) \
618 ((struct elf_x86_64_link_hash_entry *)(ent))
bffbf940 619
351f65ca 620struct elf_x86_64_obj_tdata
bffbf940
JJ		 621{
622 struct elf_obj_tdata root;
623
624 /* tls_type for each local got entry. */
625 char *local_got_tls_type;
67a4f2b7
AO		 626
627 /* GOTPLT entries for TLS descriptors. */
628 bfd_vma *local_tlsdesc_gotent;
70256ad8
AJ		 629};
630
351f65ca
L		 631#define elf_x86_64_tdata(abfd) \
632 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
bffbf940 633
351f65ca
L		 634#define elf_x86_64_local_got_tls_type(abfd) \
635 (elf_x86_64_tdata (abfd)->local_got_tls_type)
bffbf940 636
351f65ca
L		 637#define elf_x86_64_local_tlsdesc_gotent(abfd) \
638 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
bffbf940 639
0ffa91dd
NC		 640#define is_x86_64_elf(bfd) \
641 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
642 && elf_tdata (bfd) != NULL \
4dfe6ac6 643 && elf_object_id (bfd) == X86_64_ELF_DATA)
0ffa91dd
NC		 644
645static bfd_boolean
351f65ca 646elf_x86_64_mkobject (bfd *abfd)
0ffa91dd 647{
351f65ca 648 return bfd_elf_allocate_object (abfd, sizeof (struct elf_x86_64_obj_tdata),
4dfe6ac6 649 X86_64_ELF_DATA);
0ffa91dd
NC		 650}
651
c434dee6 652/* x86-64 ELF linker hash table. */
8d88c4ca 653
351f65ca 654struct elf_x86_64_link_hash_table
407443a3 655{
c434dee6 656 struct elf_link_hash_table elf;
70256ad8 657
c434dee6 658 /* Short-cuts to get to dynamic linker sections. */
c434dee6
AJ		 659 asection *sdynbss;
660 asection *srelbss;
e41b3a13 661 asection *plt_eh_frame;
70256ad8 662
4dfe6ac6
NC		 663 union
664 {
bffbf940
JJ		 665 bfd_signed_vma refcount;
666 bfd_vma offset;
667 } tls_ld_got;
668
67a4f2b7
AO		 669 /* The amount of space used by the jump slots in the GOT. */
670 bfd_vma sgotplt_jump_table_size;
671
87d72d41
AM		 672 /* Small local sym cache. */
673 struct sym_cache sym_cache;
9f03412a 674
351f65ca
L		 675 bfd_vma (*r_info) (bfd_vma, bfd_vma);
676 bfd_vma (*r_sym) (bfd_vma);
248775ba 677 unsigned int pointer_r_type;
351f65ca
L		 678 const char *dynamic_interpreter;
679 int dynamic_interpreter_size;
680
9f03412a
AO		 681 /* _TLS_MODULE_BASE_ symbol. */
682 struct bfd_link_hash_entry *tls_module_base;
c25bc9fc
L		 683
684 /* Used by local STT_GNU_IFUNC symbols. */
685 htab_t loc_hash_table;
4dfe6ac6
NC		 686 void * loc_hash_memory;
687
688 /* The offset into splt of the PLT entry for the TLS descriptor
689 resolver. Special values are 0, if not necessary (or not found
690 to be necessary yet), and -1 if needed but not determined
691 yet. */
692 bfd_vma tlsdesc_plt;
693 /* The offset into sgot of the GOT entry used by the PLT entry
694 above. */
695 bfd_vma tlsdesc_got;
e1f98742
L		 696
697 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
698 bfd_vma next_jump_slot_index;
699 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
700 bfd_vma next_irelative_index;
c434dee6 701};
70256ad8
AJ		 702
703/* Get the x86-64 ELF linker hash table from a link_info structure. */
8d88c4ca 704
351f65ca 705#define elf_x86_64_hash_table(p) \
4dfe6ac6 706 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
351f65ca 707 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
8d88c4ca 708
351f65ca 709#define elf_x86_64_compute_jump_table_size(htab) \
6de2ae4a 710 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
67a4f2b7 711
407443a3 712/* Create an entry in an x86-64 ELF linker hash table. */
70256ad8
AJ		 713
714static struct bfd_hash_entry *
351f65ca
L		 715elf_x86_64_link_hash_newfunc (struct bfd_hash_entry *entry,
716 struct bfd_hash_table *table,
717 const char *string)
70256ad8 718{
70256ad8 719 /* Allocate the structure if it has not already been allocated by a
c434dee6
AJ		 720 subclass. */
721 if (entry == NULL)
722 {
a50b1753
NC		 723 entry = (struct bfd_hash_entry *)
724 bfd_hash_allocate (table,
351f65ca 725 sizeof (struct elf_x86_64_link_hash_entry));
c434dee6
AJ		 726 if (entry == NULL)
727 return entry;
728 }
70256ad8
AJ		 729
730 /* Call the allocation method of the superclass. */
c434dee6
AJ		 731 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
732 if (entry != NULL)
70256ad8 733 {
351f65ca 734 struct elf_x86_64_link_hash_entry *eh;
c434dee6 735
351f65ca 736 eh = (struct elf_x86_64_link_hash_entry *) entry;
c434dee6 737 eh->dyn_relocs = NULL;
bffbf940 738 eh->tls_type = GOT_UNKNOWN;
67a4f2b7 739 eh->tlsdesc_got = (bfd_vma) -1;
70256ad8
AJ		 740 }
741
c434dee6 742 return entry;
70256ad8
AJ		 743}
744
c25bc9fc
L		 745/* Compute a hash of a local hash entry. We use elf_link_hash_entry
746 for local symbol so that we can handle local STT_GNU_IFUNC symbols
747 as global symbol. We reuse indx and dynstr_index for local symbol
748 hash since they aren't used by global symbols in this backend. */
749
750static hashval_t
351f65ca 751elf_x86_64_local_htab_hash (const void *ptr)
c25bc9fc
L		 752{
753 struct elf_link_hash_entry *h
754 = (struct elf_link_hash_entry *) ptr;
d2149d72 755 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
c25bc9fc
L		 756}
757
758/* Compare local hash entries. */
759
760static int
351f65ca 761elf_x86_64_local_htab_eq (const void *ptr1, const void *ptr2)
c25bc9fc
L		 762{
763 struct elf_link_hash_entry *h1
764 = (struct elf_link_hash_entry *) ptr1;
765 struct elf_link_hash_entry *h2
766 = (struct elf_link_hash_entry *) ptr2;
767
768 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
769}
770
771/* Find and/or create a hash entry for local symbol. */
772
773static struct elf_link_hash_entry *
351f65ca
L		 774elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table *htab,
775 bfd *abfd, const Elf_Internal_Rela *rel,
776 bfd_boolean create)
c25bc9fc 777{
351f65ca 778 struct elf_x86_64_link_hash_entry e, *ret;
c25bc9fc 779 asection *sec = abfd->sections;
d2149d72 780 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
351f65ca 781 htab->r_sym (rel->r_info));
c25bc9fc
L		 782 void **slot;
783
784 e.elf.indx = sec->id;
351f65ca 785 e.elf.dynstr_index = htab->r_sym (rel->r_info);
c25bc9fc
L		 786 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
787 create ? INSERT : NO_INSERT);
788
789 if (!slot)
790 return NULL;
791
792 if (*slot)
793 {
351f65ca 794 ret = (struct elf_x86_64_link_hash_entry *) *slot;
c25bc9fc
L		 795 return &ret->elf;
796 }
797
351f65ca 798 ret = (struct elf_x86_64_link_hash_entry *)
c25bc9fc 799 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
351f65ca 800 sizeof (struct elf_x86_64_link_hash_entry));
c25bc9fc
L		 801 if (ret)
802 {
803 memset (ret, 0, sizeof (*ret));
804 ret->elf.indx = sec->id;
351f65ca 805 ret->elf.dynstr_index = htab->r_sym (rel->r_info);
c25bc9fc 806 ret->elf.dynindx = -1;
c25bc9fc
L		 807 *slot = ret;
808 }
809 return &ret->elf;
810}
811
8d88c4ca
NC		 812/* Create an X86-64 ELF linker hash table. */
813
814static struct bfd_link_hash_table *
351f65ca 815elf_x86_64_link_hash_table_create (bfd *abfd)
8d88c4ca 816{
351f65ca
L		 817 struct elf_x86_64_link_hash_table *ret;
818 bfd_size_type amt = sizeof (struct elf_x86_64_link_hash_table);
8d88c4ca 819
351f65ca 820 ret = (struct elf_x86_64_link_hash_table *) bfd_malloc (amt);
c434dee6 821 if (ret == NULL)
8d88c4ca
NC		 822 return NULL;
823
eb4ff4d6 824 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
351f65ca
L		 825 elf_x86_64_link_hash_newfunc,
826 sizeof (struct elf_x86_64_link_hash_entry),
4dfe6ac6 827 X86_64_ELF_DATA))
8d88c4ca 828 {
e2d34d7d 829 free (ret);
8d88c4ca
NC		 830 return NULL;
831 }
832
c434dee6
AJ		 833 ret->sdynbss = NULL;
834 ret->srelbss = NULL;
332ce62b 835 ret->plt_eh_frame = NULL;
87d72d41 836 ret->sym_cache.abfd = NULL;
67a4f2b7
AO		 837 ret->tlsdesc_plt = 0;
838 ret->tlsdesc_got = 0;
bffbf940 839 ret->tls_ld_got.refcount = 0;
67a4f2b7 840 ret->sgotplt_jump_table_size = 0;
9f03412a 841 ret->tls_module_base = NULL;
e1f98742
L		 842 ret->next_jump_slot_index = 0;
843 ret->next_irelative_index = 0;
6bbec505 844
351f65ca
L		 845 if (ABI_64_P (abfd))
846 {
847 ret->r_info = elf64_r_info;
848 ret->r_sym = elf64_r_sym;
248775ba 849 ret->pointer_r_type = R_X86_64_64;
351f65ca
L		 850 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
851 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
852 }
853 else
854 {
855 ret->r_info = elf32_r_info;
856 ret->r_sym = elf32_r_sym;
248775ba 857 ret->pointer_r_type = R_X86_64_32;
351f65ca
L		 858 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
859 ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
860 }
861
c25bc9fc 862 ret->loc_hash_table = htab_try_create (1024,
351f65ca
L		 863 elf_x86_64_local_htab_hash,
864 elf_x86_64_local_htab_eq,
c25bc9fc
L		 865 NULL);
866 ret->loc_hash_memory = objalloc_create ();
867 if (!ret->loc_hash_table || !ret->loc_hash_memory)
868 {
869 free (ret);
870 return NULL;
871 }
872
c434dee6
AJ		 873 return &ret->elf.root;
874}
875
c25bc9fc
L		 876/* Destroy an X86-64 ELF linker hash table. */
877
878static void
351f65ca 879elf_x86_64_link_hash_table_free (struct bfd_link_hash_table *hash)
c25bc9fc 880{
351f65ca
L		 881 struct elf_x86_64_link_hash_table *htab
882 = (struct elf_x86_64_link_hash_table *) hash;
c25bc9fc
L		 883
884 if (htab->loc_hash_table)
885 htab_delete (htab->loc_hash_table);
886 if (htab->loc_hash_memory)
887 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
888 _bfd_generic_link_hash_table_free (hash);
889}
890
c434dee6
AJ		 891/* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
892 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
893 hash table. */
894
b34976b6 895static bfd_boolean
351f65ca
L		 896elf_x86_64_create_dynamic_sections (bfd *dynobj,
897 struct bfd_link_info *info)
c434dee6 898{
351f65ca 899 struct elf_x86_64_link_hash_table *htab;
c434dee6 900
c434dee6 901 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
b34976b6 902 return FALSE;
c434dee6 903
351f65ca 904 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 905 if (htab == NULL)
906 return FALSE;
907
c434dee6
AJ		 908 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
909 if (!info->shared)
910 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
911
6de2ae4a 912 if (!htab->sdynbss
c434dee6
AJ		 913 || (!info->shared && !htab->srelbss))
914 abort ();
915
e41b3a13
JJ		 916 if (!info->no_ld_generated_unwind_info
917 && bfd_get_section_by_name (dynobj, ".eh_frame") == NULL
918 && htab->elf.splt != NULL)
919 {
920 flagword flags = get_elf_backend_data (dynobj)->dynamic_sec_flags;
921 htab->plt_eh_frame
922 = bfd_make_section_with_flags (dynobj, ".eh_frame",
923 flags | SEC_READONLY);
924 if (htab->plt_eh_frame == NULL
925 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 3))
926 return FALSE;
927
928 htab->plt_eh_frame->size = sizeof (elf_x86_64_eh_frame_plt);
929 htab->plt_eh_frame->contents
930 = bfd_alloc (dynobj, htab->plt_eh_frame->size);
931 memcpy (htab->plt_eh_frame->contents, elf_x86_64_eh_frame_plt,
932 sizeof (elf_x86_64_eh_frame_plt));
933 }
b34976b6 934 return TRUE;
c434dee6
AJ		 935}
936
937/* Copy the extra info we tack onto an elf_link_hash_entry. */
938
939static void
351f65ca
L		 940elf_x86_64_copy_indirect_symbol (struct bfd_link_info *info,
941 struct elf_link_hash_entry *dir,
942 struct elf_link_hash_entry *ind)
c434dee6 943{
351f65ca 944 struct elf_x86_64_link_hash_entry *edir, *eind;
c434dee6 945
351f65ca
L		 946 edir = (struct elf_x86_64_link_hash_entry *) dir;
947 eind = (struct elf_x86_64_link_hash_entry *) ind;
c434dee6
AJ		 948
949 if (eind->dyn_relocs != NULL)
950 {
951 if (edir->dyn_relocs != NULL)
952 {
e03a8ed8
L		 953 struct elf_dyn_relocs **pp;
954 struct elf_dyn_relocs *p;
c434dee6 955
fcfa13d2 956 /* Add reloc counts against the indirect sym to the direct sym
c434dee6
AJ		 957 list. Merge any entries against the same section. */
958 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
959 {
e03a8ed8 960 struct elf_dyn_relocs *q;
c434dee6
AJ		 961
962 for (q = edir->dyn_relocs; q != NULL; q = q->next)
963 if (q->sec == p->sec)
964 {
965 q->pc_count += p->pc_count;
966 q->count += p->count;
967 *pp = p->next;
968 break;
969 }
970 if (q == NULL)
971 pp = &p->next;
972 }
973 *pp = edir->dyn_relocs;
974 }
975
976 edir->dyn_relocs = eind->dyn_relocs;
977 eind->dyn_relocs = NULL;
978 }
979
bffbf940
JJ		 980 if (ind->root.type == bfd_link_hash_indirect
981 && dir->got.refcount <= 0)
982 {
983 edir->tls_type = eind->tls_type;
984 eind->tls_type = GOT_UNKNOWN;
985 }
986
d40d037c
AJ		 987 if (ELIMINATE_COPY_RELOCS
988 && ind->root.type != bfd_link_hash_indirect
f5385ebf
AM		 989 && dir->dynamic_adjusted)
990 {
991 /* If called to transfer flags for a weakdef during processing
992 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
993 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
994 dir->ref_dynamic |= ind->ref_dynamic;
995 dir->ref_regular |= ind->ref_regular;
996 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
997 dir->needs_plt |= ind->needs_plt;
998 dir->pointer_equality_needed |= ind->pointer_equality_needed;
999 }
d40d037c 1000 else
fcfa13d2 1001 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
8d88c4ca
NC		 1002}
1003
b34976b6 1004static bfd_boolean
27482721 1005elf64_x86_64_elf_object_p (bfd *abfd)
bffbf940 1006{
8d88c4ca
NC		 1007 /* Set the right machine number for an x86-64 elf64 file. */
1008 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
b34976b6 1009 return TRUE;
8d88c4ca
NC		 1010}
1011
142411ca
L		 1012/* Return TRUE if the TLS access code sequence support transition
1013 from R_TYPE. */
1014
1015static bfd_boolean
351f65ca
L		 1016elf_x86_64_check_tls_transition (bfd *abfd,
1017 struct bfd_link_info *info,
1018 asection *sec,
1019 bfd_byte *contents,
1020 Elf_Internal_Shdr *symtab_hdr,
1021 struct elf_link_hash_entry **sym_hashes,
1022 unsigned int r_type,
1023 const Elf_Internal_Rela *rel,
1024 const Elf_Internal_Rela *relend)
bffbf940 1025{
142411ca
L		 1026 unsigned int val;
1027 unsigned long r_symndx;
1028 struct elf_link_hash_entry *h;
1029 bfd_vma offset;
351f65ca 1030 struct elf_x86_64_link_hash_table *htab;
142411ca
L		 1031
1032 /* Get the section contents. */
1033 if (contents == NULL)
1034 {
1035 if (elf_section_data (sec)->this_hdr.contents != NULL)
1036 contents = elf_section_data (sec)->this_hdr.contents;
1037 else
1038 {
1039 /* FIXME: How to better handle error condition? */
1040 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1041 return FALSE;
bffbf940 1042
142411ca
L		 1043 /* Cache the section contents for elf_link_input_bfd. */
1044 elf_section_data (sec)->this_hdr.contents = contents;
1045 }
1046 }
1047
351f65ca 1048 htab = elf_x86_64_hash_table (info);
142411ca 1049 offset = rel->r_offset;
bffbf940 1050 switch (r_type)
142411ca
L		 1051 {
1052 case R_X86_64_TLSGD:
1053 case R_X86_64_TLSLD:
1054 if ((rel + 1) >= relend)
1055 return FALSE;
1056
1057 if (r_type == R_X86_64_TLSGD)
1058 {
52bc799a 1059 /* Check transition from GD access model. For 64bit, only
142411ca
L		 1060 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1061 .word 0x6666; rex64; call __tls_get_addr
52bc799a
L		 1062 can transit to different access model. For 32bit, only
1063 leaq foo@tlsgd(%rip), %rdi
1064 .word 0x6666; rex64; call __tls_get_addr
142411ca
L		 1065 can transit to different access model. */
1066
fa289a5f
AM		 1067 static const unsigned char call[] = { 0x66, 0x66, 0x48, 0xe8 };
1068 static const unsigned char leaq[] = { 0x66, 0x48, 0x8d, 0x3d };
1069
52bc799a 1070 if ((offset + 12) > sec->size
fa289a5f 1071 || memcmp (contents + offset + 4, call, 4) != 0)
142411ca 1072 return FALSE;
52bc799a
L		 1073
1074 if (ABI_64_P (abfd))
1075 {
52bc799a 1076 if (offset < 4
fa289a5f 1077 || memcmp (contents + offset - 4, leaq, 4) != 0)
52bc799a
L		 1078 return FALSE;
1079 }
1080 else
1081 {
52bc799a 1082 if (offset < 3
fa289a5f 1083 || memcmp (contents + offset - 3, leaq + 1, 3) != 0)
52bc799a
L		 1084 return FALSE;
1085 }
142411ca
L		 1086 }
1087 else
1088 {
1089 /* Check transition from LD access model. Only
1090 leaq foo@tlsld(%rip), %rdi;
1091 call __tls_get_addr
1092 can transit to different access model. */
1093
fa289a5f 1094 static const unsigned char lea[] = { 0x48, 0x8d, 0x3d };
142411ca
L		 1095
1096 if (offset < 3 || (offset + 9) > sec->size)
1097 return FALSE;
1098
fa289a5f
AM		 1099 if (memcmp (contents + offset - 3, lea, 3) != 0
1100 || 0xe8 != *(contents + offset + 4))
142411ca
L		 1101 return FALSE;
1102 }
1103
351f65ca 1104 r_symndx = htab->r_sym (rel[1].r_info);
142411ca
L		 1105 if (r_symndx < symtab_hdr->sh_info)
1106 return FALSE;
1107
1108 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
c4fb387b
L		 1109 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1110 may be versioned. */
142411ca
L		 1111 return (h != NULL
1112 && h->root.root.string != NULL
351f65ca
L		 1113 && (ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PC32
1114 || ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLT32)
c4fb387b
L		 1115 && (strncmp (h->root.root.string,
1116 "__tls_get_addr", 14) == 0));
142411ca
L		 1117
1118 case R_X86_64_GOTTPOFF:
1119 /* Check transition from IE access model:
4a4c5f25
L		 1120 mov foo@gottpoff(%rip), %reg
1121 add foo@gottpoff(%rip), %reg
142411ca
L		 1122 */
1123
4a4c5f25
L		 1124 /* Check REX prefix first. */
1125 if (offset >= 3 && (offset + 4) <= sec->size)
1126 {
1127 val = bfd_get_8 (abfd, contents + offset - 3);
1128 if (val != 0x48 && val != 0x4c)
1129 {
1130 /* X32 may have 0x44 REX prefix or no REX prefix. */
1131 if (ABI_64_P (abfd))
1132 return FALSE;
1133 }
1134 }
1135 else
1136 {
1137 /* X32 may not have any REX prefix. */
1138 if (ABI_64_P (abfd))
1139 return FALSE;
1140 if (offset < 2 || (offset + 3) > sec->size)
1141 return FALSE;
1142 }
142411ca
L		 1143
1144 val = bfd_get_8 (abfd, contents + offset - 2);
1145 if (val != 0x8b && val != 0x03)
1146 return FALSE;
1147
1148 val = bfd_get_8 (abfd, contents + offset - 1);
1149 return (val & 0xc7) == 5;
1150
1151 case R_X86_64_GOTPC32_TLSDESC:
1152 /* Check transition from GDesc access model:
1153 leaq x@tlsdesc(%rip), %rax
1154
1155 Make sure it's a leaq adding rip to a 32-bit offset
1156 into any register, although it's probably almost always
1157 going to be rax. */
1158
1159 if (offset < 3 || (offset + 4) > sec->size)
1160 return FALSE;
1161
1162 val = bfd_get_8 (abfd, contents + offset - 3);
1163 if ((val & 0xfb) != 0x48)
1164 return FALSE;
1165
1166 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1167 return FALSE;
1168
1169 val = bfd_get_8 (abfd, contents + offset - 1);
1170 return (val & 0xc7) == 0x05;
1171
1172 case R_X86_64_TLSDESC_CALL:
1173 /* Check transition from GDesc access model:
1174 call *x@tlsdesc(%rax)
1175 */
1176 if (offset + 2 <= sec->size)
1177 {
1178 /* Make sure that it's a call *x@tlsdesc(%rax). */
fa289a5f
AM		 1179 static const unsigned char call[] = { 0xff, 0x10 };
1180 return memcmp (contents + offset, call, 2) == 0;
142411ca
L		 1181 }
1182
1183 return FALSE;
1184
1185 default:
1186 abort ();
1187 }
1188}
1189
1190/* Return TRUE if the TLS access transition is OK or no transition
1191 will be performed. Update R_TYPE if there is a transition. */
1192
1193static bfd_boolean
351f65ca
L		 1194elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd,
1195 asection *sec, bfd_byte *contents,
1196 Elf_Internal_Shdr *symtab_hdr,
1197 struct elf_link_hash_entry **sym_hashes,
1198 unsigned int *r_type, int tls_type,
1199 const Elf_Internal_Rela *rel,
1200 const Elf_Internal_Rela *relend,
1201 struct elf_link_hash_entry *h,
1202 unsigned long r_symndx)
142411ca
L		 1203{
1204 unsigned int from_type = *r_type;
1205 unsigned int to_type = from_type;
1206 bfd_boolean check = TRUE;
1207
bb1cb422
L		 1208 /* Skip TLS transition for functions. */
1209 if (h != NULL
1210 && (h->type == STT_FUNC
1211 || h->type == STT_GNU_IFUNC))
1212 return TRUE;
1213
142411ca 1214 switch (from_type)
bffbf940
JJ		 1215 {
1216 case R_X86_64_TLSGD:
67a4f2b7
AO		 1217 case R_X86_64_GOTPC32_TLSDESC:
1218 case R_X86_64_TLSDESC_CALL:
bffbf940 1219 case R_X86_64_GOTTPOFF:
1d85728f 1220 if (info->executable)
142411ca
L		 1221 {
1222 if (h == NULL)
1223 to_type = R_X86_64_TPOFF32;
1224 else
1225 to_type = R_X86_64_GOTTPOFF;
1226 }
1227
351f65ca 1228 /* When we are called from elf_x86_64_relocate_section,
142411ca
L		 1229 CONTENTS isn't NULL and there may be additional transitions
1230 based on TLS_TYPE. */
1231 if (contents != NULL)
1232 {
1233 unsigned int new_to_type = to_type;
1234
1d85728f 1235 if (info->executable
142411ca
L		 1236 && h != NULL
1237 && h->dynindx == -1
1238 && tls_type == GOT_TLS_IE)
1239 new_to_type = R_X86_64_TPOFF32;
1240
1241 if (to_type == R_X86_64_TLSGD
1242 || to_type == R_X86_64_GOTPC32_TLSDESC
1243 || to_type == R_X86_64_TLSDESC_CALL)
1244 {
1245 if (tls_type == GOT_TLS_IE)
1246 new_to_type = R_X86_64_GOTTPOFF;
1247 }
1248
1249 /* We checked the transition before when we were called from
351f65ca 1250 elf_x86_64_check_relocs. We only want to check the new
142411ca
L		 1251 transition which hasn't been checked before. */
1252 check = new_to_type != to_type && from_type == to_type;
1253 to_type = new_to_type;
1254 }
1255
1256 break;
1257
bffbf940 1258 case R_X86_64_TLSLD:
1d85728f 1259 if (info->executable)
142411ca
L		 1260 to_type = R_X86_64_TPOFF32;
1261 break;
1262
1263 default:
1264 return TRUE;
bffbf940
JJ		 1265 }
1266
142411ca
L		 1267 /* Return TRUE if there is no transition. */
1268 if (from_type == to_type)
1269 return TRUE;
1270
1271 /* Check if the transition can be performed. */
1272 if (check
351f65ca
L		 1273 && ! elf_x86_64_check_tls_transition (abfd, info, sec, contents,
1274 symtab_hdr, sym_hashes,
1275 from_type, rel, relend))
142411ca 1276 {
2f629d23 1277 reloc_howto_type *from, *to;
4c544807 1278 const char *name;
142411ca 1279
351f65ca
L		 1280 from = elf_x86_64_rtype_to_howto (abfd, from_type);
1281 to = elf_x86_64_rtype_to_howto (abfd, to_type);
142411ca 1282
4c544807
L		 1283 if (h)
1284 name = h->root.root.string;
1285 else
1286 {
351f65ca 1287 struct elf_x86_64_link_hash_table *htab;
4dfe6ac6 1288
351f65ca 1289 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 1290 if (htab == NULL)
1291 name = "*unknown*";
1292 else
1293 {
1294 Elf_Internal_Sym *isym;
1295
1296 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1297 abfd, r_symndx);
1298 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1299 }
4c544807
L		 1300 }
1301
142411ca
L		 1302 (*_bfd_error_handler)
1303 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1304 "in section `%A' failed"),
4c544807 1305 abfd, sec, from->name, to->name, name,
142411ca
L		 1306 (unsigned long) rel->r_offset);
1307 bfd_set_error (bfd_error_bad_value);
1308 return FALSE;
1309 }
1310
1311 *r_type = to_type;
1312 return TRUE;
bffbf940
JJ		 1313}
1314
70256ad8 1315/* Look through the relocs for a section during the first phase, and
c434dee6
AJ		 1316 calculate needed space in the global offset table, procedure
1317 linkage table, and dynamic reloc sections. */
70256ad8 1318
b34976b6 1319static bfd_boolean
351f65ca
L		 1320elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info,
1321 asection *sec,
1322 const Elf_Internal_Rela *relocs)
70256ad8 1323{
351f65ca 1324 struct elf_x86_64_link_hash_table *htab;
70256ad8
AJ		 1325 Elf_Internal_Shdr *symtab_hdr;
1326 struct elf_link_hash_entry **sym_hashes;
70256ad8
AJ		 1327 const Elf_Internal_Rela *rel;
1328 const Elf_Internal_Rela *rel_end;
70256ad8
AJ		 1329 asection *sreloc;
1330
1049f94e 1331 if (info->relocatable)
b34976b6 1332 return TRUE;
70256ad8 1333
0ffa91dd
NC		 1334 BFD_ASSERT (is_x86_64_elf (abfd));
1335
351f65ca 1336 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 1337 if (htab == NULL)
1338 return FALSE;
1339
0ffa91dd 1340 symtab_hdr = &elf_symtab_hdr (abfd);
70256ad8 1341 sym_hashes = elf_sym_hashes (abfd);
70256ad8 1342
c434dee6 1343 sreloc = NULL;
cbe950e9 1344
70256ad8
AJ		 1345 rel_end = relocs + sec->reloc_count;
1346 for (rel = relocs; rel < rel_end; rel++)
1347 {
bffbf940 1348 unsigned int r_type;
70256ad8
AJ		 1349 unsigned long r_symndx;
1350 struct elf_link_hash_entry *h;
4c544807
L		 1351 Elf_Internal_Sym *isym;
1352 const char *name;
70256ad8 1353
351f65ca
L		 1354 r_symndx = htab->r_sym (rel->r_info);
1355 r_type = ELF32_R_TYPE (rel->r_info);
c434dee6
AJ		 1356
1357 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1358 {
d003868e
AM		 1359 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1360 abfd, r_symndx);
b34976b6 1361 return FALSE;
c434dee6
AJ		 1362 }
1363
70256ad8 1364 if (r_symndx < symtab_hdr->sh_info)
c25bc9fc
L		 1365 {
1366 /* A local symbol. */
c2e61a4e
L		 1367 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1368 abfd, r_symndx);
1369 if (isym == NULL)
1370 return FALSE;
c25bc9fc
L		 1371
1372 /* Check relocation against local STT_GNU_IFUNC symbol. */
351f65ca 1373 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
c25bc9fc 1374 {
351f65ca
L		 1375 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel,
1376 TRUE);
c25bc9fc 1377 if (h == NULL)
c2e61a4e 1378 return FALSE;
6bbec505 1379
c25bc9fc
L		 1380 /* Fake a STT_GNU_IFUNC symbol. */
1381 h->type = STT_GNU_IFUNC;
1382 h->def_regular = 1;
1383 h->ref_regular = 1;
1384 h->forced_local = 1;
1385 h->root.type = bfd_link_hash_defined;
1386 }
1387 else
1388 h = NULL;
1389 }
70256ad8 1390 else
71cb9464 1391 {
4c544807 1392 isym = NULL;
71cb9464
L		 1393 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1394 while (h->root.type == bfd_link_hash_indirect
1395 || h->root.type == bfd_link_hash_warning)
1396 h = (struct elf_link_hash_entry *) h->root.u.i.link;
c25bc9fc 1397 }
cbe950e9 1398
d1534d16
L		 1399 /* Check invalid x32 relocations. */
1400 if (!ABI_64_P (abfd))
1401 switch (r_type)
1402 {
1403 default:
1404 break;
1405
d1534d16
L		 1406 case R_X86_64_DTPOFF64:
1407 case R_X86_64_TPOFF64:
1408 case R_X86_64_PC64:
1409 case R_X86_64_GOTOFF64:
1410 case R_X86_64_GOT64:
1411 case R_X86_64_GOTPCREL64:
1412 case R_X86_64_GOTPC64:
1413 case R_X86_64_GOTPLT64:
1414 case R_X86_64_PLTOFF64:
1415 {
1416 if (h)
1417 name = h->root.root.string;
1418 else
1419 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1420 NULL);
1421 (*_bfd_error_handler)
1422 (_("%B: relocation %s against symbol `%s' isn't "
1423 "supported in x32 mode"), abfd,
1424 x86_64_elf_howto_table[r_type].name, name);
1425 bfd_set_error (bfd_error_bad_value);
1426 return FALSE;
1427 }
1428 break;
1429 }
1430
c25bc9fc
L		 1431 if (h != NULL)
1432 {
cbe950e9
L		 1433 /* Create the ifunc sections for static executables. If we
1434 never see an indirect function symbol nor we are building
1435 a static executable, those sections will be empty and
1436 won't appear in output. */
1437 switch (r_type)
1438 {
1439 default:
1440 break;
1441
1442 case R_X86_64_32S:
1443 case R_X86_64_32:
1444 case R_X86_64_64:
1445 case R_X86_64_PC32:
1446 case R_X86_64_PC64:
1447 case R_X86_64_PLT32:
1448 case R_X86_64_GOTPCREL:
1449 case R_X86_64_GOTPCREL64:
9d4057ee
AM		 1450 if (htab->elf.dynobj == NULL)
1451 htab->elf.dynobj = abfd;
1452 if (!_bfd_elf_create_ifunc_sections (htab->elf.dynobj, info))
c2e61a4e 1453 return FALSE;
cbe950e9
L		 1454 break;
1455 }
1456
1457 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
1458 it here if it is defined in a non-shared object. */
1459 if (h->type == STT_GNU_IFUNC
1460 && h->def_regular)
1461 {
1462 /* It is referenced by a non-shared object. */
1463 h->ref_regular = 1;
7ae26bc1 1464 h->needs_plt = 1;
6bbec505 1465
cbe950e9
L		 1466 /* STT_GNU_IFUNC symbol must go through PLT. */
1467 h->plt.refcount += 1;
1468
1469 /* STT_GNU_IFUNC needs dynamic sections. */
1470 if (htab->elf.dynobj == NULL)
1471 htab->elf.dynobj = abfd;
1472
1473 switch (r_type)
1474 {
048cbda4 1475 default:
4c544807
L		 1476 if (h->root.root.string)
1477 name = h->root.root.string;
1478 else
1479 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1480 NULL);
048cbda4
L		 1481 (*_bfd_error_handler)
1482 (_("%B: relocation %s against STT_GNU_IFUNC "
1483 "symbol `%s' isn't handled by %s"), abfd,
1484 x86_64_elf_howto_table[r_type].name,
4c544807 1485 name, __FUNCTION__);
048cbda4 1486 bfd_set_error (bfd_error_bad_value);
c2e61a4e 1487 return FALSE;
cbe950e9 1488
248775ba
L		 1489 case R_X86_64_32:
1490 if (ABI_64_P (abfd))
1491 goto not_pointer;
710ab287
L		 1492 case R_X86_64_64:
1493 h->non_got_ref = 1;
1494 h->pointer_equality_needed = 1;
1495 if (info->shared)
1496 {
710ab287
L		 1497 /* We must copy these reloc types into the output
1498 file. Create a reloc section in dynobj and
1499 make room for this reloc. */
e03a8ed8
L		 1500 sreloc = _bfd_elf_create_ifunc_dyn_reloc
1501 (abfd, info, sec, sreloc,
351f65ca 1502 &((struct elf_x86_64_link_hash_entry *) h)->dyn_relocs);
710ab287 1503 if (sreloc == NULL)
c2e61a4e 1504 return FALSE;
710ab287
L		 1505 }
1506 break;
1507
cbe950e9 1508 case R_X86_64_32S:
cbe950e9
L		 1509 case R_X86_64_PC32:
1510 case R_X86_64_PC64:
248775ba 1511not_pointer:
cbe950e9
L		 1512 h->non_got_ref = 1;
1513 if (r_type != R_X86_64_PC32
1514 && r_type != R_X86_64_PC64)
1515 h->pointer_equality_needed = 1;
1516 break;
1517
1518 case R_X86_64_PLT32:
1519 break;
1520
1521 case R_X86_64_GOTPCREL:
1522 case R_X86_64_GOTPCREL64:
7afd84dc 1523 h->got.refcount += 1;
6de2ae4a
L		 1524 if (htab->elf.sgot == NULL
1525 && !_bfd_elf_create_got_section (htab->elf.dynobj,
1526 info))
c2e61a4e 1527 return FALSE;
cbe950e9
L		 1528 break;
1529 }
1530
1531 continue;
1532 }
71cb9464 1533 }
70256ad8 1534
351f65ca
L		 1535 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
1536 symtab_hdr, sym_hashes,
1537 &r_type, GOT_UNKNOWN,
1538 rel, rel_end, h, r_symndx))
c2e61a4e 1539 return FALSE;
142411ca 1540
bffbf940 1541 switch (r_type)
70256ad8 1542 {
bffbf940
JJ		 1543 case R_X86_64_TLSLD:
1544 htab->tls_ld_got.refcount += 1;
1545 goto create_got;
1546
1547 case R_X86_64_TPOFF32:
351f65ca 1548 if (!info->executable && ABI_64_P (abfd))
70256ad8 1549 {
09a24cbf 1550 if (h)
4c544807
L		 1551 name = h->root.root.string;
1552 else
1553 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1554 NULL);
bffbf940 1555 (*_bfd_error_handler)
d003868e
AM		 1556 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1557 abfd,
4c544807 1558 x86_64_elf_howto_table[r_type].name, name);
bffbf940 1559 bfd_set_error (bfd_error_bad_value);
c2e61a4e 1560 return FALSE;
70256ad8 1561 }
bffbf940 1562 break;
c434dee6 1563
bffbf940 1564 case R_X86_64_GOTTPOFF:
1d85728f 1565 if (!info->executable)
bffbf940
JJ		 1566 info->flags |= DF_STATIC_TLS;
1567 /* Fall through */
70256ad8 1568
bffbf940
JJ		 1569 case R_X86_64_GOT32:
1570 case R_X86_64_GOTPCREL:
1571 case R_X86_64_TLSGD:
7b81dfbb
AJ		 1572 case R_X86_64_GOT64:
1573 case R_X86_64_GOTPCREL64:
1574 case R_X86_64_GOTPLT64:
67a4f2b7
AO		 1575 case R_X86_64_GOTPC32_TLSDESC:
1576 case R_X86_64_TLSDESC_CALL:
bffbf940
JJ		 1577 /* This symbol requires a global offset table entry. */
1578 {
1579 int tls_type, old_tls_type;
1580
1581 switch (r_type)
1582 {
1583 default: tls_type = GOT_NORMAL; break;
1584 case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
1585 case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
67a4f2b7
AO		 1586 case R_X86_64_GOTPC32_TLSDESC:
1587 case R_X86_64_TLSDESC_CALL:
1588 tls_type = GOT_TLS_GDESC; break;
bffbf940
JJ		 1589 }
1590
1591 if (h != NULL)
1592 {
7b81dfbb
AJ		 1593 if (r_type == R_X86_64_GOTPLT64)
1594 {
1595 /* This relocation indicates that we also need
1596 a PLT entry, as this is a function. We don't need
1597 a PLT entry for local symbols. */
1598 h->needs_plt = 1;
1599 h->plt.refcount += 1;
1600 }
bffbf940 1601 h->got.refcount += 1;
351f65ca 1602 old_tls_type = elf_x86_64_hash_entry (h)->tls_type;
bffbf940
JJ		 1603 }
1604 else
1605 {
1606 bfd_signed_vma *local_got_refcounts;
1607
1608 /* This is a global offset table entry for a local symbol. */
1609 local_got_refcounts = elf_local_got_refcounts (abfd);
1610 if (local_got_refcounts == NULL)
1611 {
1612 bfd_size_type size;
1613
1614 size = symtab_hdr->sh_info;
67a4f2b7
AO		 1615 size *= sizeof (bfd_signed_vma)
1616 + sizeof (bfd_vma) + sizeof (char);
bffbf940
JJ		 1617 local_got_refcounts = ((bfd_signed_vma *)
1618 bfd_zalloc (abfd, size));
1619 if (local_got_refcounts == NULL)
c2e61a4e 1620 return FALSE;
bffbf940 1621 elf_local_got_refcounts (abfd) = local_got_refcounts;
351f65ca 1622 elf_x86_64_local_tlsdesc_gotent (abfd)
67a4f2b7 1623 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
351f65ca 1624 elf_x86_64_local_got_tls_type (abfd)
67a4f2b7 1625 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
bffbf940
JJ		 1626 }
1627 local_got_refcounts[r_symndx] += 1;
1628 old_tls_type
351f65ca 1629 = elf_x86_64_local_got_tls_type (abfd) [r_symndx];
bffbf940
JJ		 1630 }
1631
1632 /* If a TLS symbol is accessed using IE at least once,
1633 there is no point to use dynamic model for it. */
1634 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
67a4f2b7
AO		 1635 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1636 || tls_type != GOT_TLS_IE))
bffbf940 1637 {
67a4f2b7 1638 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type))
bffbf940 1639 tls_type = old_tls_type;
67a4f2b7
AO		 1640 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1641 && GOT_TLS_GD_ANY_P (tls_type))
1642 tls_type |= old_tls_type;
bffbf940
JJ		 1643 else
1644 {
09a24cbf 1645 if (h)
4c544807
L		 1646 name = h->root.root.string;
1647 else
1648 name = bfd_elf_sym_name (abfd, symtab_hdr,
1649 isym, NULL);
bffbf940 1650 (*_bfd_error_handler)
1f7a4e42 1651 (_("%B: '%s' accessed both as normal and thread local symbol"),
4c544807 1652 abfd, name);
c2e61a4e 1653 return FALSE;
bffbf940
JJ		 1654 }
1655 }
1656
1657 if (old_tls_type != tls_type)
1658 {
1659 if (h != NULL)
351f65ca 1660 elf_x86_64_hash_entry (h)->tls_type = tls_type;
bffbf940 1661 else
351f65ca 1662 elf_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
bffbf940
JJ		 1663 }
1664 }
c434dee6
AJ		 1665 /* Fall through */
1666
d6ab8113
JB		 1667 case R_X86_64_GOTOFF64:
1668 case R_X86_64_GOTPC32:
7b81dfbb 1669 case R_X86_64_GOTPC64:
bffbf940 1670 create_got:
6de2ae4a 1671 if (htab->elf.sgot == NULL)
c434dee6
AJ		 1672 {
1673 if (htab->elf.dynobj == NULL)
1674 htab->elf.dynobj = abfd;
6de2ae4a
L		 1675 if (!_bfd_elf_create_got_section (htab->elf.dynobj,
1676 info))
c2e61a4e 1677 return FALSE;
c434dee6 1678 }
70256ad8
AJ		 1679 break;
1680
1681 case R_X86_64_PLT32:
1682 /* This symbol requires a procedure linkage table entry. We
407443a3
AJ		 1683 actually build the entry in adjust_dynamic_symbol,
1684 because this might be a case of linking PIC code which is
1685 never referenced by a dynamic object, in which case we
1686 don't need to generate a procedure linkage table entry
1687 after all. */
70256ad8
AJ		 1688
1689 /* If this is a local symbol, we resolve it directly without
407443a3 1690 creating a procedure linkage table entry. */
70256ad8
AJ		 1691 if (h == NULL)
1692 continue;
1693
f5385ebf 1694 h->needs_plt = 1;
51b64d56 1695 h->plt.refcount += 1;
70256ad8
AJ		 1696 break;
1697
7b81dfbb
AJ		 1698 case R_X86_64_PLTOFF64:
1699 /* This tries to form the 'address' of a function relative
1700 to GOT. For global symbols we need a PLT entry. */
1701 if (h != NULL)
1702 {
1703 h->needs_plt = 1;
1704 h->plt.refcount += 1;
1705 }
1706 goto create_got;
1707
248775ba
L		 1708 case R_X86_64_32:
1709 if (!ABI_64_P (abfd))
1710 goto pointer;
cc78d0af
AJ		 1711 case R_X86_64_8:
1712 case R_X86_64_16:
70256ad8 1713 case R_X86_64_32S:
1b71fb54
AJ		 1714 /* Let's help debug shared library creation. These relocs
1715 cannot be used in shared libs. Don't error out for
1716 sections we don't care about, such as debug sections or
1717 non-constant sections. */
1718 if (info->shared
1719 && (sec->flags & SEC_ALLOC) != 0
1720 && (sec->flags & SEC_READONLY) != 0)
1721 {
09a24cbf 1722 if (h)
4c544807
L		 1723 name = h->root.root.string;
1724 else
1725 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1b71fb54 1726 (*_bfd_error_handler)
d003868e 1727 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
4c544807 1728 abfd, x86_64_elf_howto_table[r_type].name, name);
1b71fb54 1729 bfd_set_error (bfd_error_bad_value);
c2e61a4e 1730 return FALSE;
1b71fb54
AJ		 1731 }
1732 /* Fall through. */
1733
c434dee6
AJ		 1734 case R_X86_64_PC8:
1735 case R_X86_64_PC16:
70256ad8 1736 case R_X86_64_PC32:
d6ab8113 1737 case R_X86_64_PC64:
1b71fb54 1738 case R_X86_64_64:
248775ba 1739pointer:
710ab287 1740 if (h != NULL && info->executable)
c434dee6
AJ		 1741 {
1742 /* If this reloc is in a read-only section, we might
1743 need a copy reloc. We can't check reliably at this
1744 stage whether the section is read-only, as input
1745 sections have not yet been mapped to output sections.
1746 Tentatively set the flag for now, and correct in
1747 adjust_dynamic_symbol. */
f5385ebf 1748 h->non_got_ref = 1;
c434dee6
AJ		 1749
1750 /* We may need a .plt entry if the function this reloc
1751 refers to is in a shared lib. */
1752 h->plt.refcount += 1;
d6ab8113 1753 if (r_type != R_X86_64_PC32 && r_type != R_X86_64_PC64)
f5385ebf 1754 h->pointer_equality_needed = 1;
c434dee6 1755 }
70256ad8
AJ		 1756
1757 /* If we are creating a shared library, and this is a reloc
1758 against a global symbol, or a non PC relative reloc
1759 against a local symbol, then we need to copy the reloc
1760 into the shared library. However, if we are linking with
1761 -Bsymbolic, we do not need to copy a reloc against a
1762 global symbol which is defined in an object we are
407443a3 1763 including in the link (i.e., DEF_REGULAR is set). At
70256ad8
AJ		 1764 this point we have not seen all the input files, so it is
1765 possible that DEF_REGULAR is not set now but will be set
c434dee6
AJ		 1766 later (it is never cleared). In case of a weak definition,
1767 DEF_REGULAR may be cleared later by a strong definition in
1768 a shared library. We account for that possibility below by
1769 storing information in the relocs_copied field of the hash
1770 table entry. A similar situation occurs when creating
1771 shared libraries and symbol visibility changes render the
1772 symbol local.
1773
1774 If on the other hand, we are creating an executable, we
1775 may need to keep relocations for symbols satisfied by a
1776 dynamic library if we manage to avoid copy relocs for the
0f88be7a 1777 symbol. */
c434dee6
AJ		 1778 if ((info->shared
1779 && (sec->flags & SEC_ALLOC) != 0
d8045f23 1780 && (! IS_X86_64_PCREL_TYPE (r_type)
c434dee6 1781 || (h != NULL
55255dae 1782 && (! SYMBOLIC_BIND (info, h)
c434dee6 1783 || h->root.type == bfd_link_hash_defweak
f5385ebf 1784 || !h->def_regular))))
d40d037c
AJ		 1785 || (ELIMINATE_COPY_RELOCS
1786 && !info->shared
c434dee6
AJ		 1787 && (sec->flags & SEC_ALLOC) != 0
1788 && h != NULL
1789 && (h->root.type == bfd_link_hash_defweak
0f88be7a 1790 || !h->def_regular)))
70256ad8 1791 {
e03a8ed8
L		 1792 struct elf_dyn_relocs *p;
1793 struct elf_dyn_relocs **head;
c434dee6
AJ		 1794
1795 /* We must copy these reloc types into the output file.
1796 Create a reloc section in dynobj and make room for
1797 this reloc. */
70256ad8
AJ		 1798 if (sreloc == NULL)
1799 {
c434dee6
AJ		 1800 if (htab->elf.dynobj == NULL)
1801 htab->elf.dynobj = abfd;
1802
83bac4b0 1803 sreloc = _bfd_elf_make_dynamic_reloc_section
82e96e07
L		 1804 (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2,
1805 abfd, /*rela?*/ TRUE);
70256ad8 1806
70256ad8 1807 if (sreloc == NULL)
c2e61a4e 1808 return FALSE;
70256ad8
AJ		 1809 }
1810
c434dee6
AJ		 1811 /* If this is a global symbol, we count the number of
1812 relocations we need for this symbol. */
1813 if (h != NULL)
70256ad8 1814 {
351f65ca 1815 head = &((struct elf_x86_64_link_hash_entry *) h)->dyn_relocs;
c434dee6
AJ		 1816 }
1817 else
1818 {
1819 /* Track dynamic relocs needed for local syms too.
1820 We really need local syms available to do this
1821 easily. Oh well. */
c434dee6 1822 asection *s;
87d72d41 1823 void **vpp;
87d72d41
AM		 1824
1825 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1826 abfd, r_symndx);
1827 if (isym == NULL)
1828 return FALSE;
1829
1830 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
c434dee6 1831 if (s == NULL)
87d72d41 1832 s = sec;
70256ad8 1833
e81d3500
DD		 1834 /* Beware of type punned pointers vs strict aliasing
1835 rules. */
1836 vpp = &(elf_section_data (s)->local_dynrel);
e03a8ed8 1837 head = (struct elf_dyn_relocs **)vpp;
c434dee6 1838 }
70256ad8 1839
c434dee6
AJ		 1840 p = *head;
1841 if (p == NULL || p->sec != sec)
1842 {
1843 bfd_size_type amt = sizeof *p;
d8045f23 1844
e03a8ed8 1845 p = ((struct elf_dyn_relocs *)
c434dee6 1846 bfd_alloc (htab->elf.dynobj, amt));
70256ad8 1847 if (p == NULL)
c2e61a4e 1848 return FALSE;
c434dee6
AJ		 1849 p->next = *head;
1850 *head = p;
1851 p->sec = sec;
1852 p->count = 0;
1853 p->pc_count = 0;
70256ad8 1854 }
c434dee6
AJ		 1855
1856 p->count += 1;
d8045f23 1857 if (IS_X86_64_PCREL_TYPE (r_type))
c434dee6 1858 p->pc_count += 1;
70256ad8
AJ		 1859 }
1860 break;
fe4770f4
AJ		 1861
1862 /* This relocation describes the C++ object vtable hierarchy.
1863 Reconstruct it for later use during GC. */
1864 case R_X86_64_GNU_VTINHERIT:
c152c796 1865 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
c2e61a4e 1866 return FALSE;
fe4770f4
AJ		 1867 break;
1868
1869 /* This relocation describes which C++ vtable entries are actually
1870 used. Record for later use during GC. */
1871 case R_X86_64_GNU_VTENTRY:
d17e0c6e
JB		 1872 BFD_ASSERT (h != NULL);
1873 if (h != NULL
1874 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
c2e61a4e 1875 return FALSE;
fe4770f4 1876 break;
c434dee6
AJ		 1877
1878 default:
1879 break;
70256ad8
AJ		 1880 }
1881 }
1882
b34976b6 1883 return TRUE;
70256ad8
AJ		 1884}
1885
1886/* Return the section that should be marked against GC for a given
407443a3 1887 relocation. */
70256ad8
AJ		 1888
1889static asection *
351f65ca
L		 1890elf_x86_64_gc_mark_hook (asection *sec,
1891 struct bfd_link_info *info,
1892 Elf_Internal_Rela *rel,
1893 struct elf_link_hash_entry *h,
1894 Elf_Internal_Sym *sym)
70256ad8
AJ		 1895{
1896 if (h != NULL)
351f65ca 1897 switch (ELF32_R_TYPE (rel->r_info))
07adf181
AM		 1898 {
1899 case R_X86_64_GNU_VTINHERIT:
1900 case R_X86_64_GNU_VTENTRY:
1901 return NULL;
1902 }
1903
1904 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
70256ad8
AJ		 1905}
1906
407443a3 1907/* Update the got entry reference counts for the section being removed. */
70256ad8 1908
b34976b6 1909static bfd_boolean
351f65ca
L		 1910elf_x86_64_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1911 asection *sec,
1912 const Elf_Internal_Rela *relocs)
70256ad8 1913{
351f65ca 1914 struct elf_x86_64_link_hash_table *htab;
70256ad8
AJ		 1915 Elf_Internal_Shdr *symtab_hdr;
1916 struct elf_link_hash_entry **sym_hashes;
1917 bfd_signed_vma *local_got_refcounts;
1918 const Elf_Internal_Rela *rel, *relend;
c434dee6 1919
7dda2462
TG		 1920 if (info->relocatable)
1921 return TRUE;
1922
351f65ca 1923 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 1924 if (htab == NULL)
1925 return FALSE;
1926
c434dee6 1927 elf_section_data (sec)->local_dynrel = NULL;
70256ad8 1928
0ffa91dd 1929 symtab_hdr = &elf_symtab_hdr (abfd);
70256ad8
AJ		 1930 sym_hashes = elf_sym_hashes (abfd);
1931 local_got_refcounts = elf_local_got_refcounts (abfd);
1932
351f65ca 1933 htab = elf_x86_64_hash_table (info);
70256ad8
AJ		 1934 relend = relocs + sec->reloc_count;
1935 for (rel = relocs; rel < relend; rel++)
26e41594
AM		 1936 {
1937 unsigned long r_symndx;
1938 unsigned int r_type;
1939 struct elf_link_hash_entry *h = NULL;
70256ad8 1940
351f65ca 1941 r_symndx = htab->r_sym (rel->r_info);
26e41594
AM		 1942 if (r_symndx >= symtab_hdr->sh_info)
1943 {
26e41594 1944 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3eb128b2
AM		 1945 while (h->root.type == bfd_link_hash_indirect
1946 || h->root.type == bfd_link_hash_warning)
1947 h = (struct elf_link_hash_entry *) h->root.u.i.link;
26e41594 1948 }
bb1cb422
L		 1949 else
1950 {
1951 /* A local symbol. */
1952 Elf_Internal_Sym *isym;
1953
1954 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1955 abfd, r_symndx);
1956
1957 /* Check relocation against local STT_GNU_IFUNC symbol. */
1958 if (isym != NULL
82e96e07 1959 && ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
bb1cb422 1960 {
351f65ca 1961 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel, FALSE);
bb1cb422
L		 1962 if (h == NULL)
1963 abort ();
1964 }
1965 }
c434dee6 1966
3db2e7dd
L		 1967 if (h)
1968 {
1969 struct elf_x86_64_link_hash_entry *eh;
1970 struct elf_dyn_relocs **pp;
1971 struct elf_dyn_relocs *p;
1972
1973 eh = (struct elf_x86_64_link_hash_entry *) h;
1974
1975 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1976 if (p->sec == sec)
1977 {
1978 /* Everything must go for SEC. */
1979 *pp = p->next;
1980 break;
1981 }
1982 }
1983
351f65ca
L		 1984 r_type = ELF32_R_TYPE (rel->r_info);
1985 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
1986 symtab_hdr, sym_hashes,
1987 &r_type, GOT_UNKNOWN,
1988 rel, relend, h, r_symndx))
142411ca
L		 1989 return FALSE;
1990
26e41594
AM		 1991 switch (r_type)
1992 {
1993 case R_X86_64_TLSLD:
4dfe6ac6
NC		 1994 if (htab->tls_ld_got.refcount > 0)
1995 htab->tls_ld_got.refcount -= 1;
26e41594 1996 break;
c434dee6 1997
26e41594 1998 case R_X86_64_TLSGD:
67a4f2b7
AO		 1999 case R_X86_64_GOTPC32_TLSDESC:
2000 case R_X86_64_TLSDESC_CALL:
26e41594
AM		 2001 case R_X86_64_GOTTPOFF:
2002 case R_X86_64_GOT32:
2003 case R_X86_64_GOTPCREL:
7b81dfbb
AJ		 2004 case R_X86_64_GOT64:
2005 case R_X86_64_GOTPCREL64:
2006 case R_X86_64_GOTPLT64:
26e41594
AM		 2007 if (h != NULL)
2008 {
7b81dfbb
AJ		 2009 if (r_type == R_X86_64_GOTPLT64 && h->plt.refcount > 0)
2010 h->plt.refcount -= 1;
26e41594
AM		 2011 if (h->got.refcount > 0)
2012 h->got.refcount -= 1;
bb1cb422
L		 2013 if (h->type == STT_GNU_IFUNC)
2014 {
2015 if (h->plt.refcount > 0)
2016 h->plt.refcount -= 1;
2017 }
26e41594
AM		 2018 }
2019 else if (local_got_refcounts != NULL)
2020 {
2021 if (local_got_refcounts[r_symndx] > 0)
2022 local_got_refcounts[r_symndx] -= 1;
2023 }
2024 break;
c434dee6 2025
26e41594
AM		 2026 case R_X86_64_8:
2027 case R_X86_64_16:
2028 case R_X86_64_32:
2029 case R_X86_64_64:
2030 case R_X86_64_32S:
2031 case R_X86_64_PC8:
2032 case R_X86_64_PC16:
2033 case R_X86_64_PC32:
d6ab8113 2034 case R_X86_64_PC64:
3db2e7dd
L		 2035 if (info->shared
2036 && (h == NULL || h->type != STT_GNU_IFUNC))
26e41594
AM		 2037 break;
2038 /* Fall thru */
c434dee6 2039
26e41594 2040 case R_X86_64_PLT32:
7b81dfbb 2041 case R_X86_64_PLTOFF64:
26e41594
AM		 2042 if (h != NULL)
2043 {
2044 if (h->plt.refcount > 0)
2045 h->plt.refcount -= 1;
2046 }
2047 break;
70256ad8 2048
26e41594
AM		 2049 default:
2050 break;
2051 }
2052 }
70256ad8 2053
b34976b6 2054 return TRUE;
70256ad8
AJ		 2055}
2056
2057/* Adjust a symbol defined by a dynamic object and referenced by a
2058 regular object. The current definition is in some section of the
2059 dynamic object, but we're not including those sections. We have to
2060 change the definition to something the rest of the link can
407443a3 2061 understand. */
70256ad8 2062
b34976b6 2063static bfd_boolean
351f65ca
L		 2064elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
2065 struct elf_link_hash_entry *h)
70256ad8 2066{
351f65ca 2067 struct elf_x86_64_link_hash_table *htab;
70256ad8 2068 asection *s;
70256ad8 2069
cbe950e9
L		 2070 /* STT_GNU_IFUNC symbol must go through PLT. */
2071 if (h->type == STT_GNU_IFUNC)
2072 {
2073 if (h->plt.refcount <= 0)
2074 {
2075 h->plt.offset = (bfd_vma) -1;
2076 h->needs_plt = 0;
2077 }
2078 return TRUE;
2079 }
2080
70256ad8
AJ		 2081 /* If this is a function, put it in the procedure linkage table. We
2082 will fill in the contents of the procedure linkage table later,
2083 when we know the address of the .got section. */
2084 if (h->type == STT_FUNC
f5385ebf 2085 || h->needs_plt)
70256ad8 2086 {
c434dee6 2087 if (h->plt.refcount <= 0
27482721
AJ		 2088 || SYMBOL_CALLS_LOCAL (info, h)
2089 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2090 && h->root.type == bfd_link_hash_undefweak))
70256ad8 2091 {
70256ad8
AJ		 2092 /* This case can occur if we saw a PLT32 reloc in an input
2093 file, but the symbol was never referred to by a dynamic
2094 object, or if all references were garbage collected. In
2095 such a case, we don't actually need to build a procedure
2096 linkage table, and we can just do a PC32 reloc instead. */
70256ad8 2097 h->plt.offset = (bfd_vma) -1;
f5385ebf 2098 h->needs_plt = 0;
70256ad8
AJ		 2099 }
2100
b34976b6 2101 return TRUE;
70256ad8 2102 }
bbd7ec4a 2103 else
c434dee6
AJ		 2104 /* It's possible that we incorrectly decided a .plt reloc was
2105 needed for an R_X86_64_PC32 reloc to a non-function sym in
2106 check_relocs. We can't decide accurately between function and
2107 non-function syms in check-relocs; Objects loaded later in
2108 the link may change h->type. So fix it now. */
bbd7ec4a 2109 h->plt.offset = (bfd_vma) -1;
70256ad8
AJ		 2110
2111 /* If this is a weak symbol, and there is a real definition, the
2112 processor independent code will have arranged for us to see the
407443a3 2113 real definition first, and we can just use the same value. */
f6e332e6 2114 if (h->u.weakdef != NULL)
70256ad8 2115 {
f6e332e6
AM		 2116 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2117 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2118 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2119 h->root.u.def.value = h->u.weakdef->root.u.def.value;
d40d037c 2120 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
f6e332e6 2121 h->non_got_ref = h->u.weakdef->non_got_ref;
b34976b6 2122 return TRUE;
70256ad8
AJ		 2123 }
2124
2125 /* This is a reference to a symbol defined by a dynamic object which
407443a3 2126 is not a function. */
70256ad8
AJ		 2127
2128 /* If we are creating a shared library, we must presume that the
2129 only references to the symbol are via the global offset table.
2130 For such cases we need not do anything here; the relocations will
407443a3 2131 be handled correctly by relocate_section. */
70256ad8 2132 if (info->shared)
b34976b6 2133 return TRUE;
70256ad8
AJ		 2134
2135 /* If there are no references to this symbol that do not use the
2136 GOT, we don't need to generate a copy reloc. */
f5385ebf 2137 if (!h->non_got_ref)
b34976b6 2138 return TRUE;
70256ad8 2139
c434dee6
AJ		 2140 /* If -z nocopyreloc was given, we won't generate them either. */
2141 if (info->nocopyreloc)
2142 {
f5385ebf 2143 h->non_got_ref = 0;
b34976b6 2144 return TRUE;
c434dee6
AJ		 2145 }
2146
d40d037c 2147 if (ELIMINATE_COPY_RELOCS)
c434dee6 2148 {
351f65ca 2149 struct elf_x86_64_link_hash_entry * eh;
e03a8ed8 2150 struct elf_dyn_relocs *p;
c434dee6 2151
351f65ca 2152 eh = (struct elf_x86_64_link_hash_entry *) h;
d40d037c
AJ		 2153 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2154 {
2155 s = p->sec->output_section;
2156 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2157 break;
2158 }
2159
2160 /* If we didn't find any dynamic relocs in read-only sections, then
2161 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2162 if (p == NULL)
2163 {
f5385ebf 2164 h->non_got_ref = 0;
d40d037c
AJ		 2165 return TRUE;
2166 }
c434dee6
AJ		 2167 }
2168
70256ad8 2169 /* We must allocate the symbol in our .dynbss section, which will
407443a3 2170 become part of the .bss section of the executable. There will be
70256ad8
AJ		 2171 an entry for this symbol in the .dynsym section. The dynamic
2172 object will contain position independent code, so all references
2173 from the dynamic object to this symbol will go through the global
2174 offset table. The dynamic linker will use the .dynsym entry to
2175 determine the address it must put in the global offset table, so
2176 both the dynamic object and the regular object will refer to the
2177 same memory location for the variable. */
2178
351f65ca 2179 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 2180 if (htab == NULL)
2181 return FALSE;
70256ad8
AJ		 2182
2183 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2184 to copy the initial value out of the dynamic object and into the
cedb70c5 2185 runtime process image. */
1d7e9d18 2186 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
70256ad8 2187 {
351f65ca
L		 2188 const struct elf_backend_data *bed;
2189 bed = get_elf_backend_data (info->output_bfd);
2190 htab->srelbss->size += bed->s->sizeof_rela;
f5385ebf 2191 h->needs_copy = 1;
70256ad8
AJ		 2192 }
2193
c434dee6 2194 s = htab->sdynbss;
70256ad8 2195
027297b7 2196 return _bfd_elf_adjust_dynamic_copy (h, s);
70256ad8
AJ		 2197}
2198
c434dee6
AJ		 2199/* Allocate space in .plt, .got and associated reloc sections for
2200 dynamic relocs. */
2201
b34976b6 2202static bfd_boolean
351f65ca 2203elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
c434dee6
AJ		 2204{
2205 struct bfd_link_info *info;
351f65ca
L		 2206 struct elf_x86_64_link_hash_table *htab;
2207 struct elf_x86_64_link_hash_entry *eh;
e03a8ed8 2208 struct elf_dyn_relocs *p;
351f65ca 2209 const struct elf_backend_data *bed;
c434dee6 2210
e92d460e 2211 if (h->root.type == bfd_link_hash_indirect)
b34976b6 2212 return TRUE;
c434dee6 2213
351f65ca 2214 eh = (struct elf_x86_64_link_hash_entry *) h;
e92d460e 2215
c434dee6 2216 info = (struct bfd_link_info *) inf;
351f65ca 2217 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 2218 if (htab == NULL)
2219 return FALSE;
351f65ca 2220 bed = get_elf_backend_data (info->output_bfd);
c434dee6 2221
cbe950e9
L		 2222 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2223 here if it is defined and referenced in a non-shared object. */
2224 if (h->type == STT_GNU_IFUNC
2225 && h->def_regular)
e03a8ed8
L		 2226 return _bfd_elf_allocate_ifunc_dyn_relocs (info, h,
2227 &eh->dyn_relocs,
2228 PLT_ENTRY_SIZE,
2229 GOT_ENTRY_SIZE);
cbe950e9
L		 2230 else if (htab->elf.dynamic_sections_created
2231 && h->plt.refcount > 0)
c434dee6
AJ		 2232 {
2233 /* Make sure this symbol is output as a dynamic symbol.
2234 Undefined weak syms won't yet be marked as dynamic. */
2235 if (h->dynindx == -1
f5385ebf 2236 && !h->forced_local)
c434dee6 2237 {
c152c796 2238 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2239 return FALSE;
c434dee6
AJ		 2240 }
2241
27482721
AJ		 2242 if (info->shared
2243 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
c434dee6 2244 {
6de2ae4a 2245 asection *s = htab->elf.splt;
c434dee6
AJ		 2246
2247 /* If this is the first .plt entry, make room for the special
2248 first entry. */
eea6121a
AM		 2249 if (s->size == 0)
2250 s->size += PLT_ENTRY_SIZE;
c434dee6 2251
eea6121a 2252 h->plt.offset = s->size;
c434dee6
AJ		 2253
2254 /* If this symbol is not defined in a regular file, and we are
2255 not generating a shared library, then set the symbol to this
2256 location in the .plt. This is required to make function
2257 pointers compare as equal between the normal executable and
2258 the shared library. */
2259 if (! info->shared
f5385ebf 2260 && !h->def_regular)
c434dee6
AJ		 2261 {
2262 h->root.u.def.section = s;
2263 h->root.u.def.value = h->plt.offset;
2264 }
2265
2266 /* Make room for this entry. */
eea6121a 2267 s->size += PLT_ENTRY_SIZE;
c434dee6
AJ		 2268
2269 /* We also need to make an entry in the .got.plt section, which
2270 will be placed in the .got section by the linker script. */
6de2ae4a 2271 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
c434dee6
AJ		 2272
2273 /* We also need to make an entry in the .rela.plt section. */
351f65ca 2274 htab->elf.srelplt->size += bed->s->sizeof_rela;
6de2ae4a 2275 htab->elf.srelplt->reloc_count++;
c434dee6
AJ		 2276 }
2277 else
2278 {
2279 h->plt.offset = (bfd_vma) -1;
f5385ebf 2280 h->needs_plt = 0;
c434dee6
AJ		 2281 }
2282 }
2283 else
2284 {
2285 h->plt.offset = (bfd_vma) -1;
f5385ebf 2286 h->needs_plt = 0;
c434dee6
AJ		 2287 }
2288
67a4f2b7
AO		 2289 eh->tlsdesc_got = (bfd_vma) -1;
2290
bffbf940
JJ		 2291 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2292 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2293 if (h->got.refcount > 0
1d85728f 2294 && info->executable
bffbf940 2295 && h->dynindx == -1
351f65ca 2296 && elf_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
d8045f23
NC		 2297 {
2298 h->got.offset = (bfd_vma) -1;
2299 }
bffbf940 2300 else if (h->got.refcount > 0)
c434dee6
AJ		 2301 {
2302 asection *s;
b34976b6 2303 bfd_boolean dyn;
351f65ca 2304 int tls_type = elf_x86_64_hash_entry (h)->tls_type;
c434dee6
AJ		 2305
2306 /* Make sure this symbol is output as a dynamic symbol.
2307 Undefined weak syms won't yet be marked as dynamic. */
2308 if (h->dynindx == -1
f5385ebf 2309 && !h->forced_local)
c434dee6 2310 {
c152c796 2311 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2312 return FALSE;
c434dee6
AJ		 2313 }
2314
67a4f2b7
AO		 2315 if (GOT_TLS_GDESC_P (tls_type))
2316 {
6de2ae4a 2317 eh->tlsdesc_got = htab->elf.sgotplt->size
351f65ca 2318 - elf_x86_64_compute_jump_table_size (htab);
6de2ae4a 2319 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
67a4f2b7
AO		 2320 h->got.offset = (bfd_vma) -2;
2321 }
2322 if (! GOT_TLS_GDESC_P (tls_type)
2323 || GOT_TLS_GD_P (tls_type))
2324 {
6de2ae4a 2325 s = htab->elf.sgot;
67a4f2b7
AO		 2326 h->got.offset = s->size;
2327 s->size += GOT_ENTRY_SIZE;
2328 if (GOT_TLS_GD_P (tls_type))
2329 s->size += GOT_ENTRY_SIZE;
2330 }
c434dee6 2331 dyn = htab->elf.dynamic_sections_created;
bffbf940
JJ		 2332 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2333 and two if global.
2334 R_X86_64_GOTTPOFF needs one dynamic relocation. */
67a4f2b7 2335 if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
bffbf940 2336 || tls_type == GOT_TLS_IE)
351f65ca 2337 htab->elf.srelgot->size += bed->s->sizeof_rela;
67a4f2b7 2338 else if (GOT_TLS_GD_P (tls_type))
351f65ca 2339 htab->elf.srelgot->size += 2 * bed->s->sizeof_rela;
67a4f2b7
AO		 2340 else if (! GOT_TLS_GDESC_P (tls_type)
2341 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2342 || h->root.type != bfd_link_hash_undefweak)
27482721
AJ		 2343 && (info->shared
2344 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
351f65ca 2345 htab->elf.srelgot->size += bed->s->sizeof_rela;
67a4f2b7
AO		 2346 if (GOT_TLS_GDESC_P (tls_type))
2347 {
351f65ca 2348 htab->elf.srelplt->size += bed->s->sizeof_rela;
67a4f2b7
AO		 2349 htab->tlsdesc_plt = (bfd_vma) -1;
2350 }
c434dee6
AJ		 2351 }
2352 else
2353 h->got.offset = (bfd_vma) -1;
2354
c434dee6 2355 if (eh->dyn_relocs == NULL)
b34976b6 2356 return TRUE;
c434dee6
AJ		 2357
2358 /* In the shared -Bsymbolic case, discard space allocated for
2359 dynamic pc-relative relocs against symbols which turn out to be
2360 defined in regular objects. For the normal shared case, discard
2361 space for pc-relative relocs that have become local due to symbol
2362 visibility changes. */
2363
2364 if (info->shared)
2365 {
27482721
AJ		 2366 /* Relocs that use pc_count are those that appear on a call
2367 insn, or certain REL relocs that can generated via assembly.
2368 We want calls to protected symbols to resolve directly to the
2369 function rather than going via the plt. If people want
2370 function pointer comparisons to work as expected then they
2371 should avoid writing weird assembly. */
2372 if (SYMBOL_CALLS_LOCAL (info, h))
c434dee6 2373 {
e03a8ed8 2374 struct elf_dyn_relocs **pp;
c434dee6
AJ		 2375
2376 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2377 {
2378 p->count -= p->pc_count;
2379 p->pc_count = 0;
2380 if (p->count == 0)
2381 *pp = p->next;
2382 else
2383 pp = &p->next;
2384 }
2385 }
4e795f50
AM		 2386
2387 /* Also discard relocs on undefined weak syms with non-default
2388 visibility. */
22d606e9 2389 if (eh->dyn_relocs != NULL
4e795f50 2390 && h->root.type == bfd_link_hash_undefweak)
22d606e9
AM		 2391 {
2392 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2393 eh->dyn_relocs = NULL;
2394
2395 /* Make sure undefined weak symbols are output as a dynamic
2396 symbol in PIEs. */
2397 else if (h->dynindx == -1
d8045f23
NC		 2398 && ! h->forced_local
2399 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2400 return FALSE;
22d606e9 2401 }
cbe950e9 2402
d8045f23 2403 }
d40d037c 2404 else if (ELIMINATE_COPY_RELOCS)
c434dee6
AJ		 2405 {
2406 /* For the non-shared case, discard space for relocs against
2407 symbols which turn out to need copy relocs or are not
2408 dynamic. */
2409
f5385ebf
AM		 2410 if (!h->non_got_ref
2411 && ((h->def_dynamic
2412 && !h->def_regular)
c434dee6
AJ		 2413 || (htab->elf.dynamic_sections_created
2414 && (h->root.type == bfd_link_hash_undefweak
2415 || h->root.type == bfd_link_hash_undefined))))
2416 {
2417 /* Make sure this symbol is output as a dynamic symbol.
2418 Undefined weak syms won't yet be marked as dynamic. */
2419 if (h->dynindx == -1
d8045f23
NC		 2420 && ! h->forced_local
2421 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2422 return FALSE;
c434dee6
AJ		 2423
2424 /* If that succeeded, we know we'll be keeping all the
2425 relocs. */
2426 if (h->dynindx != -1)
2427 goto keep;
2428 }
2429
2430 eh->dyn_relocs = NULL;
2431
2432 keep: ;
2433 }
2434
2435 /* Finally, allocate space. */
2436 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2437 {
e7c33416
NC		 2438 asection * sreloc;
2439
cbe950e9 2440 sreloc = elf_section_data (p->sec)->sreloc;
e7c33416
NC		 2441
2442 BFD_ASSERT (sreloc != NULL);
2443
351f65ca 2444 sreloc->size += p->count * bed->s->sizeof_rela;
c434dee6
AJ		 2445 }
2446
b34976b6 2447 return TRUE;
c434dee6
AJ		 2448}
2449
c25bc9fc
L		 2450/* Allocate space in .plt, .got and associated reloc sections for
2451 local dynamic relocs. */
2452
2453static bfd_boolean
351f65ca 2454elf_x86_64_allocate_local_dynrelocs (void **slot, void *inf)
c25bc9fc
L		 2455{
2456 struct elf_link_hash_entry *h
2457 = (struct elf_link_hash_entry *) *slot;
2458
2459 if (h->type != STT_GNU_IFUNC
2460 || !h->def_regular
2461 || !h->ref_regular
2462 || !h->forced_local
2463 || h->root.type != bfd_link_hash_defined)
2464 abort ();
2465
351f65ca 2466 return elf_x86_64_allocate_dynrelocs (h, inf);
c25bc9fc
L		 2467}
2468
c434dee6
AJ		 2469/* Find any dynamic relocs that apply to read-only sections. */
2470
b34976b6 2471static bfd_boolean
351f65ca
L		 2472elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h,
2473 void * inf)
c434dee6 2474{
351f65ca 2475 struct elf_x86_64_link_hash_entry *eh;
e03a8ed8 2476 struct elf_dyn_relocs *p;
c434dee6 2477
aa715242
L		 2478 /* Skip local IFUNC symbols. */
2479 if (h->forced_local && h->type == STT_GNU_IFUNC)
2480 return TRUE;
2481
351f65ca 2482 eh = (struct elf_x86_64_link_hash_entry *) h;
c434dee6
AJ		 2483 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2484 {
2485 asection *s = p->sec->output_section;
2486
2487 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2488 {
2489 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2490
2491 info->flags |= DF_TEXTREL;
2492
b70321a2
L		 2493 if (info->warn_shared_textrel && info->shared)
2494 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2495 p->sec->owner, h->root.root.string,
2496 p->sec);
2497
c434dee6 2498 /* Not an error, just cut short the traversal. */
b34976b6 2499 return FALSE;
c434dee6
AJ		 2500 }
2501 }
b34976b6 2502 return TRUE;
c434dee6
AJ		 2503}
2504
70256ad8
AJ		 2505/* Set the sizes of the dynamic sections. */
2506
b34976b6 2507static bfd_boolean
351f65ca
L		 2508elf_x86_64_size_dynamic_sections (bfd *output_bfd,
2509 struct bfd_link_info *info)
70256ad8 2510{
351f65ca 2511 struct elf_x86_64_link_hash_table *htab;
70256ad8
AJ		 2512 bfd *dynobj;
2513 asection *s;
b34976b6 2514 bfd_boolean relocs;
c434dee6 2515 bfd *ibfd;
351f65ca 2516 const struct elf_backend_data *bed;
70256ad8 2517
351f65ca 2518 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 2519 if (htab == NULL)
2520 return FALSE;
351f65ca 2521 bed = get_elf_backend_data (output_bfd);
4dfe6ac6 2522
c434dee6
AJ		 2523 dynobj = htab->elf.dynobj;
2524 if (dynobj == NULL)
2525 abort ();
70256ad8 2526
c434dee6 2527 if (htab->elf.dynamic_sections_created)
70256ad8
AJ		 2528 {
2529 /* Set the contents of the .interp section to the interpreter. */
36af4a4e 2530 if (info->executable)
70256ad8
AJ		 2531 {
2532 s = bfd_get_section_by_name (dynobj, ".interp");
c434dee6
AJ		 2533 if (s == NULL)
2534 abort ();
351f65ca
L		 2535 s->size = htab->dynamic_interpreter_size;
2536 s->contents = (unsigned char *) htab->dynamic_interpreter;
70256ad8
AJ		 2537 }
2538 }
70256ad8 2539
c434dee6
AJ		 2540 /* Set up .got offsets for local syms, and space for local dynamic
2541 relocs. */
2542 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
70256ad8 2543 {
c434dee6
AJ		 2544 bfd_signed_vma *local_got;
2545 bfd_signed_vma *end_local_got;
bffbf940 2546 char *local_tls_type;
67a4f2b7 2547 bfd_vma *local_tlsdesc_gotent;
c434dee6
AJ		 2548 bfd_size_type locsymcount;
2549 Elf_Internal_Shdr *symtab_hdr;
2550 asection *srel;
70256ad8 2551
0ffa91dd 2552 if (! is_x86_64_elf (ibfd))
70256ad8
AJ		 2553 continue;
2554
c434dee6 2555 for (s = ibfd->sections; s != NULL; s = s->next)
70256ad8 2556 {
e03a8ed8 2557 struct elf_dyn_relocs *p;
c434dee6 2558
e03a8ed8 2559 for (p = (struct elf_dyn_relocs *)
e81d3500 2560 (elf_section_data (s)->local_dynrel);
c434dee6
AJ		 2561 p != NULL;
2562 p = p->next)
70256ad8 2563 {
c434dee6
AJ		 2564 if (!bfd_is_abs_section (p->sec)
2565 && bfd_is_abs_section (p->sec->output_section))
2566 {
2567 /* Input section has been discarded, either because
2568 it is a copy of a linkonce section or due to
2569 linker script /DISCARD/, so we'll be discarding
2570 the relocs too. */
2571 }
2572 else if (p->count != 0)
2573 {
2574 srel = elf_section_data (p->sec)->sreloc;
351f65ca 2575 srel->size += p->count * bed->s->sizeof_rela;
4b819e1f
L		 2576 if ((p->sec->output_section->flags & SEC_READONLY) != 0
2577 && (info->flags & DF_TEXTREL) == 0)
b70321a2
L		 2578 {
2579 info->flags |= DF_TEXTREL;
2580 if (info->warn_shared_textrel && info->shared)
2581 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2582 p->sec->owner, p->sec);
b70321a2 2583 }
c434dee6 2584 }
70256ad8
AJ		 2585 }
2586 }
c434dee6
AJ		 2587
2588 local_got = elf_local_got_refcounts (ibfd);
2589 if (!local_got)
2590 continue;
2591
0ffa91dd 2592 symtab_hdr = &elf_symtab_hdr (ibfd);
c434dee6
AJ		 2593 locsymcount = symtab_hdr->sh_info;
2594 end_local_got = local_got + locsymcount;
351f65ca
L		 2595 local_tls_type = elf_x86_64_local_got_tls_type (ibfd);
2596 local_tlsdesc_gotent = elf_x86_64_local_tlsdesc_gotent (ibfd);
6de2ae4a
L		 2597 s = htab->elf.sgot;
2598 srel = htab->elf.srelgot;
67a4f2b7
AO		 2599 for (; local_got < end_local_got;
2600 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
70256ad8 2601 {
67a4f2b7 2602 *local_tlsdesc_gotent = (bfd_vma) -1;
c434dee6 2603 if (*local_got > 0)
70256ad8 2604 {
67a4f2b7
AO		 2605 if (GOT_TLS_GDESC_P (*local_tls_type))
2606 {
6de2ae4a 2607 *local_tlsdesc_gotent = htab->elf.sgotplt->size
351f65ca 2608 - elf_x86_64_compute_jump_table_size (htab);
6de2ae4a 2609 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
67a4f2b7
AO		 2610 *local_got = (bfd_vma) -2;
2611 }
2612 if (! GOT_TLS_GDESC_P (*local_tls_type)
2613 || GOT_TLS_GD_P (*local_tls_type))
2614 {
2615 *local_got = s->size;
2616 s->size += GOT_ENTRY_SIZE;
2617 if (GOT_TLS_GD_P (*local_tls_type))
2618 s->size += GOT_ENTRY_SIZE;
2619 }
bffbf940 2620 if (info->shared
67a4f2b7 2621 || GOT_TLS_GD_ANY_P (*local_tls_type)
bffbf940 2622 || *local_tls_type == GOT_TLS_IE)
67a4f2b7
AO		 2623 {
2624 if (GOT_TLS_GDESC_P (*local_tls_type))
2625 {
6de2ae4a 2626 htab->elf.srelplt->size
351f65ca 2627 += bed->s->sizeof_rela;
67a4f2b7
AO		 2628 htab->tlsdesc_plt = (bfd_vma) -1;
2629 }
2630 if (! GOT_TLS_GDESC_P (*local_tls_type)
2631 || GOT_TLS_GD_P (*local_tls_type))
351f65ca 2632 srel->size += bed->s->sizeof_rela;
67a4f2b7 2633 }
70256ad8
AJ		 2634 }
2635 else
c434dee6
AJ		 2636 *local_got = (bfd_vma) -1;
2637 }
2638 }
70256ad8 2639
bffbf940
JJ		 2640 if (htab->tls_ld_got.refcount > 0)
2641 {
2642 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
2643 relocs. */
6de2ae4a
L		 2644 htab->tls_ld_got.offset = htab->elf.sgot->size;
2645 htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
351f65ca 2646 htab->elf.srelgot->size += bed->s->sizeof_rela;
bffbf940
JJ		 2647 }
2648 else
2649 htab->tls_ld_got.offset = -1;
2650
c434dee6
AJ		 2651 /* Allocate global sym .plt and .got entries, and space for global
2652 sym dynamic relocs. */
351f65ca 2653 elf_link_hash_traverse (&htab->elf, elf_x86_64_allocate_dynrelocs,
eb4ff4d6 2654 info);
c434dee6 2655
c25bc9fc
L		 2656 /* Allocate .plt and .got entries, and space for local symbols. */
2657 htab_traverse (htab->loc_hash_table,
351f65ca 2658 elf_x86_64_allocate_local_dynrelocs,
c25bc9fc
L		 2659 info);
2660
67a4f2b7
AO		 2661 /* For every jump slot reserved in the sgotplt, reloc_count is
2662 incremented. However, when we reserve space for TLS descriptors,
2663 it's not incremented, so in order to compute the space reserved
2664 for them, it suffices to multiply the reloc count by the jump
e1f98742
L		 2665 slot size.
2666
2667 PR ld/13302: We start next_irelative_index at the end of .rela.plt
2668 so that R_X86_64_IRELATIVE entries come last. */
6de2ae4a 2669 if (htab->elf.srelplt)
e1f98742
L		 2670 {
2671 htab->sgotplt_jump_table_size
2672 = elf_x86_64_compute_jump_table_size (htab);
2673 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
2674 }
2675 else if (htab->elf.irelplt)
2676 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
67a4f2b7
AO		 2677
2678 if (htab->tlsdesc_plt)
2679 {
2680 /* If we're not using lazy TLS relocations, don't generate the
2681 PLT and GOT entries they require. */
2682 if ((info->flags & DF_BIND_NOW))
2683 htab->tlsdesc_plt = 0;
2684 else
2685 {
6de2ae4a
L		 2686 htab->tlsdesc_got = htab->elf.sgot->size;
2687 htab->elf.sgot->size += GOT_ENTRY_SIZE;
67a4f2b7
AO		 2688 /* Reserve room for the initial entry.
2689 FIXME: we could probably do away with it in this case. */
6de2ae4a
L		 2690 if (htab->elf.splt->size == 0)
2691 htab->elf.splt->size += PLT_ENTRY_SIZE;
2692 htab->tlsdesc_plt = htab->elf.splt->size;
2693 htab->elf.splt->size += PLT_ENTRY_SIZE;
67a4f2b7
AO		 2694 }
2695 }
2696
a7b16ceb
L		 2697 if (htab->elf.sgotplt)
2698 {
e28df02b
L		 2699 struct elf_link_hash_entry *got;
2700 got = elf_link_hash_lookup (elf_hash_table (info),
2701 "_GLOBAL_OFFSET_TABLE_",
2702 FALSE, FALSE, FALSE);
2703
a7b16ceb 2704 /* Don't allocate .got.plt section if there are no GOT nor PLT
e28df02b
L		 2705 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
2706 if ((got == NULL
2707 || !got->ref_regular_nonweak)
2708 && (htab->elf.sgotplt->size
2709 == get_elf_backend_data (output_bfd)->got_header_size)
a7b16ceb
L		 2710 && (htab->elf.splt == NULL
2711 || htab->elf.splt->size == 0)
2712 && (htab->elf.sgot == NULL
2713 || htab->elf.sgot->size == 0)
2714 && (htab->elf.iplt == NULL
2715 || htab->elf.iplt->size == 0)
2716 && (htab->elf.igotplt == NULL
2717 || htab->elf.igotplt->size == 0))
2718 htab->elf.sgotplt->size = 0;
2719 }
2720
c434dee6
AJ		 2721 /* We now have determined the sizes of the various dynamic sections.
2722 Allocate memory for them. */
b34976b6 2723 relocs = FALSE;
c434dee6
AJ		 2724 for (s = dynobj->sections; s != NULL; s = s->next)
2725 {
2726 if ((s->flags & SEC_LINKER_CREATED) == 0)
2727 continue;
2728
6de2ae4a
L		 2729 if (s == htab->elf.splt
2730 || s == htab->elf.sgot
2731 || s == htab->elf.sgotplt
2732 || s == htab->elf.iplt
2733 || s == htab->elf.igotplt
75ff4589 2734 || s == htab->sdynbss)
c434dee6
AJ		 2735 {
2736 /* Strip this section if we don't need it; see the
2737 comment below. */
2738 }
0112cd26 2739 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
c434dee6 2740 {
6de2ae4a 2741 if (s->size != 0 && s != htab->elf.srelplt)
b34976b6 2742 relocs = TRUE;
c434dee6
AJ		 2743
2744 /* We use the reloc_count field as a counter if we need
2745 to copy relocs into the output file. */
6de2ae4a 2746 if (s != htab->elf.srelplt)
67a4f2b7 2747 s->reloc_count = 0;
70256ad8 2748 }
c434dee6 2749 else
70256ad8
AJ		 2750 {
2751 /* It's not one of our sections, so don't allocate space. */
2752 continue;
2753 }
2754
eea6121a 2755 if (s->size == 0)
70256ad8 2756 {
c434dee6
AJ		 2757 /* If we don't need this section, strip it from the
2758 output file. This is mostly to handle .rela.bss and
2759 .rela.plt. We must create both sections in
2760 create_dynamic_sections, because they must be created
2761 before the linker maps input sections to output
2762 sections. The linker does that before
2763 adjust_dynamic_symbol is called, and it is that
2764 function which decides whether anything needs to go
2765 into these sections. */
2766
8423293d 2767 s->flags |= SEC_EXCLUDE;
70256ad8
AJ		 2768 continue;
2769 }
2770
c456f082
AM		 2771 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2772 continue;
2773
70256ad8
AJ		 2774 /* Allocate memory for the section contents. We use bfd_zalloc
2775 here in case unused entries are not reclaimed before the
2776 section's contents are written out. This should not happen,
2777 but this way if it does, we get a R_X86_64_NONE reloc instead
2778 of garbage. */
eea6121a 2779 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
c434dee6 2780 if (s->contents == NULL)
b34976b6 2781 return FALSE;
70256ad8
AJ		 2782 }
2783
e41b3a13
JJ		 2784 if (htab->plt_eh_frame != NULL
2785 && htab->elf.splt != NULL
2786 && htab->elf.splt->size != 0
2787 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0)
2788 bfd_put_32 (dynobj, htab->elf.splt->size,
2789 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
2790
c434dee6 2791 if (htab->elf.dynamic_sections_created)
70256ad8
AJ		 2792 {
2793 /* Add some entries to the .dynamic section. We fill in the
351f65ca 2794 values later, in elf_x86_64_finish_dynamic_sections, but we
70256ad8 2795 must add the entries now so that we get the correct size for
407443a3 2796 the .dynamic section. The DT_DEBUG entry is filled in by the
70256ad8 2797 dynamic linker and used by the debugger. */
dc810e39 2798#define add_dynamic_entry(TAG, VAL) \
5a580b3a 2799 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39 2800
36af4a4e 2801 if (info->executable)
70256ad8 2802 {
dc810e39 2803 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 2804 return FALSE;
70256ad8
AJ		 2805 }
2806
6de2ae4a 2807 if (htab->elf.splt->size != 0)
70256ad8 2808 {
dc810e39
AM		 2809 if (!add_dynamic_entry (DT_PLTGOT, 0)
2810 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2811 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2812 || !add_dynamic_entry (DT_JMPREL, 0))
b34976b6 2813 return FALSE;
67a4f2b7
AO		 2814
2815 if (htab->tlsdesc_plt
2816 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
2817 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
2818 return FALSE;
70256ad8
AJ		 2819 }
2820
2821 if (relocs)
2822 {
dc810e39
AM		 2823 if (!add_dynamic_entry (DT_RELA, 0)
2824 || !add_dynamic_entry (DT_RELASZ, 0)
351f65ca 2825 || !add_dynamic_entry (DT_RELAENT, bed->s->sizeof_rela))
b34976b6 2826 return FALSE;
70256ad8 2827
c434dee6
AJ		 2828 /* If any dynamic relocs apply to a read-only section,
2829 then we need a DT_TEXTREL entry. */
2830 if ((info->flags & DF_TEXTREL) == 0)
eb4ff4d6 2831 elf_link_hash_traverse (&htab->elf,
351f65ca 2832 elf_x86_64_readonly_dynrelocs,
eb4ff4d6 2833 info);
c434dee6
AJ		 2834
2835 if ((info->flags & DF_TEXTREL) != 0)
2836 {
2837 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 2838 return FALSE;
c434dee6 2839 }
70256ad8
AJ		 2840 }
2841 }
dc810e39 2842#undef add_dynamic_entry
70256ad8 2843
b34976b6 2844 return TRUE;
70256ad8
AJ		 2845}
2846
67a4f2b7 2847static bfd_boolean
351f65ca
L		 2848elf_x86_64_always_size_sections (bfd *output_bfd,
2849 struct bfd_link_info *info)
67a4f2b7
AO		 2850{
2851 asection *tls_sec = elf_hash_table (info)->tls_sec;
2852
2853 if (tls_sec)
2854 {
2855 struct elf_link_hash_entry *tlsbase;
2856
2857 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
2858 "_TLS_MODULE_BASE_",
2859 FALSE, FALSE, FALSE);
2860
2861 if (tlsbase && tlsbase->type == STT_TLS)
2862 {
351f65ca 2863 struct elf_x86_64_link_hash_table *htab;
67a4f2b7
AO		 2864 struct bfd_link_hash_entry *bh = NULL;
2865 const struct elf_backend_data *bed
2866 = get_elf_backend_data (output_bfd);
2867
351f65ca 2868 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 2869 if (htab == NULL)
2870 return FALSE;
2871
67a4f2b7
AO		 2872 if (!(_bfd_generic_link_add_one_symbol
2873 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
2874 tls_sec, 0, NULL, FALSE,
2875 bed->collect, &bh)))
2876 return FALSE;
9f03412a 2877
4dfe6ac6 2878 htab->tls_module_base = bh;
9f03412a 2879
67a4f2b7
AO		 2880 tlsbase = (struct elf_link_hash_entry *)bh;
2881 tlsbase->def_regular = 1;
2882 tlsbase->other = STV_HIDDEN;
2883 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
2884 }
2885 }
2886
2887 return TRUE;
2888}
2889
9f03412a
AO		 2890/* _TLS_MODULE_BASE_ needs to be treated especially when linking
2891 executables. Rather than setting it to the beginning of the TLS
2892 section, we have to set it to the end. This function may be called
2893 multiple times, it is idempotent. */
2894
2895static void
351f65ca 2896elf_x86_64_set_tls_module_base (struct bfd_link_info *info)
9f03412a 2897{
351f65ca 2898 struct elf_x86_64_link_hash_table *htab;
9f03412a
AO		 2899 struct bfd_link_hash_entry *base;
2900
2901 if (!info->executable)
2902 return;
2903
351f65ca 2904 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 2905 if (htab == NULL)
2906 return;
9f03412a 2907
4dfe6ac6
NC		 2908 base = htab->tls_module_base;
2909 if (base == NULL)
9f03412a
AO		 2910 return;
2911
4dfe6ac6 2912 base->u.def.value = htab->elf.tls_size;
9f03412a
AO		 2913}
2914
bffbf940
JJ		 2915/* Return the base VMA address which should be subtracted from real addresses
2916 when resolving @dtpoff relocation.
2917 This is PT_TLS segment p_vaddr. */
2918
2919static bfd_vma
351f65ca 2920elf_x86_64_dtpoff_base (struct bfd_link_info *info)
bffbf940 2921{
e1918d23
AM		 2922 /* If tls_sec is NULL, we should have signalled an error already. */
2923 if (elf_hash_table (info)->tls_sec == NULL)
bffbf940 2924 return 0;
e1918d23 2925 return elf_hash_table (info)->tls_sec->vma;
bffbf940
JJ		 2926}
2927
2928/* Return the relocation value for @tpoff relocation
2929 if STT_TLS virtual address is ADDRESS. */
2930
2931static bfd_vma
351f65ca 2932elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
bffbf940 2933{
e1918d23 2934 struct elf_link_hash_table *htab = elf_hash_table (info);
7dc98aea
RO		 2935 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
2936 bfd_vma static_tls_size;
bffbf940
JJ		 2937
2938 /* If tls_segment is NULL, we should have signalled an error already. */
e1918d23 2939 if (htab->tls_sec == NULL)
bffbf940 2940 return 0;
7dc98aea
RO		 2941
2942 /* Consider special static TLS alignment requirements. */
2943 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
2944 return address - static_tls_size - htab->tls_sec->vma;
bffbf940
JJ		 2945}
2946
90f487df
L		 2947/* Is the instruction before OFFSET in CONTENTS a 32bit relative
2948 branch? */
2949
2950static bfd_boolean
2951is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
2952{
2953 /* Opcode Instruction
2954 0xe8 call
2955 0xe9 jump
2956 0x0f 0x8x conditional jump */
2957 return ((offset > 0
2958 && (contents [offset - 1] == 0xe8
2959 || contents [offset - 1] == 0xe9))
2960 || (offset > 1
2961 && contents [offset - 2] == 0x0f
2962 && (contents [offset - 1] & 0xf0) == 0x80));
2963}
2964
8d88c4ca
NC		 2965/* Relocate an x86_64 ELF section. */
2966
b34976b6 2967static bfd_boolean
351f65ca
L		 2968elf_x86_64_relocate_section (bfd *output_bfd,
2969 struct bfd_link_info *info,
2970 bfd *input_bfd,
2971 asection *input_section,
2972 bfd_byte *contents,
2973 Elf_Internal_Rela *relocs,
2974 Elf_Internal_Sym *local_syms,
2975 asection **local_sections)
8d88c4ca 2976{
351f65ca 2977 struct elf_x86_64_link_hash_table *htab;
8d88c4ca
NC		 2978 Elf_Internal_Shdr *symtab_hdr;
2979 struct elf_link_hash_entry **sym_hashes;
2980 bfd_vma *local_got_offsets;
67a4f2b7 2981 bfd_vma *local_tlsdesc_gotents;
c434dee6 2982 Elf_Internal_Rela *rel;
8d88c4ca
NC		 2983 Elf_Internal_Rela *relend;
2984
0ffa91dd
NC		 2985 BFD_ASSERT (is_x86_64_elf (input_bfd));
2986
351f65ca 2987 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 2988 if (htab == NULL)
2989 return FALSE;
0ffa91dd 2990 symtab_hdr = &elf_symtab_hdr (input_bfd);
8d88c4ca
NC		 2991 sym_hashes = elf_sym_hashes (input_bfd);
2992 local_got_offsets = elf_local_got_offsets (input_bfd);
351f65ca 2993 local_tlsdesc_gotents = elf_x86_64_local_tlsdesc_gotent (input_bfd);
8d88c4ca 2994
351f65ca 2995 elf_x86_64_set_tls_module_base (info);
9f03412a 2996
c434dee6 2997 rel = relocs;
8d88c4ca 2998 relend = relocs + input_section->reloc_count;
c434dee6 2999 for (; rel < relend; rel++)
8d88c4ca 3000 {
bffbf940 3001 unsigned int r_type;
8d88c4ca
NC		 3002 reloc_howto_type *howto;
3003 unsigned long r_symndx;
3004 struct elf_link_hash_entry *h;
3005 Elf_Internal_Sym *sym;
3006 asection *sec;
67a4f2b7 3007 bfd_vma off, offplt;
8d88c4ca 3008 bfd_vma relocation;
b34976b6 3009 bfd_boolean unresolved_reloc;
8d88c4ca 3010 bfd_reloc_status_type r;
bffbf940 3011 int tls_type;
cbe950e9 3012 asection *base_got;
8d88c4ca 3013
351f65ca 3014 r_type = ELF32_R_TYPE (rel->r_info);
fe4770f4
AJ		 3015 if (r_type == (int) R_X86_64_GNU_VTINHERIT
3016 || r_type == (int) R_X86_64_GNU_VTENTRY)
3017 continue;
8d88c4ca 3018
bffbf940 3019 if (r_type >= R_X86_64_max)
8da6118f
KH		 3020 {
3021 bfd_set_error (bfd_error_bad_value);
b34976b6 3022 return FALSE;
8da6118f 3023 }
8d88c4ca 3024
d7921315
L		 3025 if (r_type != (int) R_X86_64_32
3026 || ABI_64_P (output_bfd))
3027 howto = x86_64_elf_howto_table + r_type;
3028 else
3029 howto = (x86_64_elf_howto_table
3030 + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
351f65ca 3031 r_symndx = htab->r_sym (rel->r_info);
8d88c4ca
NC		 3032 h = NULL;
3033 sym = NULL;
3034 sec = NULL;
b34976b6 3035 unresolved_reloc = FALSE;
8d88c4ca 3036 if (r_symndx < symtab_hdr->sh_info)
8da6118f
KH		 3037 {
3038 sym = local_syms + r_symndx;
3039 sec = local_sections[r_symndx];
c434dee6 3040
c25bc9fc
L		 3041 relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
3042 &sec, rel);
3043
3044 /* Relocate against local STT_GNU_IFUNC symbol. */
1f85278f 3045 if (!info->relocatable
351f65ca 3046 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
c25bc9fc 3047 {
351f65ca
L		 3048 h = elf_x86_64_get_local_sym_hash (htab, input_bfd,
3049 rel, FALSE);
c25bc9fc
L		 3050 if (h == NULL)
3051 abort ();
3052
3053 /* Set STT_GNU_IFUNC symbol value. */
3054 h->root.u.def.value = sym->st_value;
3055 h->root.u.def.section = sec;
3056 }
8da6118f 3057 }
8d88c4ca 3058 else
8da6118f 3059 {
c9736ba0 3060 bfd_boolean warned ATTRIBUTE_UNUSED;
c434dee6 3061
b2a8e766
AM		 3062 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3063 r_symndx, symtab_hdr, sym_hashes,
3064 h, sec, relocation,
3065 unresolved_reloc, warned);
8da6118f 3066 }
ab96bf03
AM		 3067
3068 if (sec != NULL && elf_discarded_section (sec))
0672748a
L		 3069 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3070 rel, relend, howto, contents);
ab96bf03
AM		 3071
3072 if (info->relocatable)
3073 continue;
3074
64d25c44
L		 3075 if (rel->r_addend == 0
3076 && r_type == R_X86_64_64
3077 && !ABI_64_P (output_bfd))
3078 {
3079 /* For x32, treat R_X86_64_64 like R_X86_64_32 and zero-extend
3080 it to 64bit if addend is zero. */
3081 r_type = R_X86_64_32;
3082 memset (contents + rel->r_offset + 4, 0, 4);
3083 }
3084
cbe950e9
L		 3085 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3086 it here if it is defined in a non-shared object. */
3087 if (h != NULL
3088 && h->type == STT_GNU_IFUNC
3089 && h->def_regular)
3090 {
3091 asection *plt;
3092 bfd_vma plt_index;
4c544807 3093 const char *name;
cbe950e9
L		 3094
3095 if ((input_section->flags & SEC_ALLOC) == 0
3096 || h->plt.offset == (bfd_vma) -1)
3097 abort ();
3098
3099 /* STT_GNU_IFUNC symbol must go through PLT. */
6de2ae4a 3100 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
cbe950e9
L		 3101 relocation = (plt->output_section->vma
3102 + plt->output_offset + h->plt.offset);
3103
3104 switch (r_type)
3105 {
3106 default:
4c544807
L		 3107 if (h->root.root.string)
3108 name = h->root.root.string;
3109 else
3110 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3111 NULL);
cbe950e9
L		 3112 (*_bfd_error_handler)
3113 (_("%B: relocation %s against STT_GNU_IFUNC "
3114 "symbol `%s' isn't handled by %s"), input_bfd,
3115 x86_64_elf_howto_table[r_type].name,
4c544807 3116 name, __FUNCTION__);
cbe950e9
L		 3117 bfd_set_error (bfd_error_bad_value);
3118 return FALSE;
3119
3120 case R_X86_64_32S:
710ab287 3121 if (info->shared)
cbe950e9 3122 abort ();
710ab287
L		 3123 goto do_relocation;
3124
248775ba
L		 3125 case R_X86_64_32:
3126 if (ABI_64_P (output_bfd))
3127 goto do_relocation;
17672001 3128 /* FALLTHROUGH */
710ab287
L		 3129 case R_X86_64_64:
3130 if (rel->r_addend != 0)
3131 {
4c544807
L		 3132 if (h->root.root.string)
3133 name = h->root.root.string;
3134 else
3135 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3136 sym, NULL);
710ab287
L		 3137 (*_bfd_error_handler)
3138 (_("%B: relocation %s against STT_GNU_IFUNC "
3139 "symbol `%s' has non-zero addend: %d"),
3140 input_bfd, x86_64_elf_howto_table[r_type].name,
4c544807 3141 name, rel->r_addend);
710ab287
L		 3142 bfd_set_error (bfd_error_bad_value);
3143 return FALSE;
3144 }
3145
3146 /* Generate dynamic relcoation only when there is a
c293fa49 3147 non-GOT reference in a shared object. */
710ab287
L		 3148 if (info->shared && h->non_got_ref)
3149 {
3150 Elf_Internal_Rela outrel;
710ab287
L		 3151 asection *sreloc;
3152
c25bc9fc
L		 3153 /* Need a dynamic relocation to get the real function
3154 address. */
710ab287
L		 3155 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
3156 info,
3157 input_section,
3158 rel->r_offset);
3159 if (outrel.r_offset == (bfd_vma) -1
3160 || outrel.r_offset == (bfd_vma) -2)
3161 abort ();
3162
3163 outrel.r_offset += (input_section->output_section->vma
3164 + input_section->output_offset);
3165
3166 if (h->dynindx == -1
44c4ea11
L		 3167 || h->forced_local
3168 || info->executable)
710ab287
L		 3169 {
3170 /* This symbol is resolved locally. */
56b8aada
L		 3171 outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
3172 outrel.r_addend = (h->root.u.def.value
3173 + h->root.u.def.section->output_section->vma
3174 + h->root.u.def.section->output_offset);
710ab287
L		 3175 }
3176 else
3177 {
351f65ca 3178 outrel.r_info = htab->r_info (h->dynindx, r_type);
710ab287
L		 3179 outrel.r_addend = 0;
3180 }
3181
6de2ae4a 3182 sreloc = htab->elf.irelifunc;
351f65ca 3183 elf_append_rela (output_bfd, sreloc, &outrel);
710ab287
L		 3184
3185 /* If this reloc is against an external symbol, we
3186 do not want to fiddle with the addend. Otherwise,
3187 we need to include the symbol value so that it
3188 becomes an addend for the dynamic reloc. For an
3189 internal symbol, we have updated addend. */
56b8aada 3190 continue;
710ab287 3191 }
17672001 3192 /* FALLTHROUGH */
cbe950e9
L		 3193 case R_X86_64_PC32:
3194 case R_X86_64_PC64:
3195 case R_X86_64_PLT32:
3196 goto do_relocation;
3197
3198 case R_X86_64_GOTPCREL:
3199 case R_X86_64_GOTPCREL64:
6de2ae4a 3200 base_got = htab->elf.sgot;
cbe950e9
L		 3201 off = h->got.offset;
3202
7afd84dc 3203 if (base_got == NULL)
cbe950e9
L		 3204 abort ();
3205
7afd84dc 3206 if (off == (bfd_vma) -1)
cbe950e9 3207 {
7afd84dc
L		 3208 /* We can't use h->got.offset here to save state, or
3209 even just remember the offset, as finish_dynamic_symbol
3210 would use that as offset into .got. */
cbe950e9 3211
6de2ae4a 3212 if (htab->elf.splt != NULL)
7afd84dc
L		 3213 {
3214 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3215 off = (plt_index + 3) * GOT_ENTRY_SIZE;
6de2ae4a 3216 base_got = htab->elf.sgotplt;
7afd84dc 3217 }
cbe950e9
L		 3218 else
3219 {
7afd84dc
L		 3220 plt_index = h->plt.offset / PLT_ENTRY_SIZE;
3221 off = plt_index * GOT_ENTRY_SIZE;
6de2ae4a 3222 base_got = htab->elf.igotplt;
7afd84dc
L		 3223 }
3224
3225 if (h->dynindx == -1
3226 || h->forced_local
3227 || info->symbolic)
3228 {
3229 /* This references the local defitionion. We must
3230 initialize this entry in the global offset table.
3231 Since the offset must always be a multiple of 8,
3232 we use the least significant bit to record
3233 whether we have initialized it already.
3234
3235 When doing a dynamic link, we create a .rela.got
3236 relocation entry to initialize the value. This
3237 is done in the finish_dynamic_symbol routine. */
3238 if ((off & 1) != 0)
3239 off &= ~1;
3240 else
3241 {
3242 bfd_put_64 (output_bfd, relocation,
3243 base_got->contents + off);
3244 /* Note that this is harmless for the GOTPLT64
3245 case, as -1 | 1 still is -1. */
3246 h->got.offset |= 1;
3247 }
cbe950e9
L		 3248 }
3249 }
3250
3251 relocation = (base_got->output_section->vma
3252 + base_got->output_offset + off);
3253
cbe950e9
L		 3254 goto do_relocation;
3255 }
3256 }
3257
70256ad8
AJ		 3258 /* When generating a shared object, the relocations handled here are
3259 copied into the output file to be resolved at run time. */
3260 switch (r_type)
3261 {
3262 case R_X86_64_GOT32:
7b81dfbb 3263 case R_X86_64_GOT64:
70256ad8
AJ		 3264 /* Relocation is to the entry for this symbol in the global
3265 offset table. */
70256ad8 3266 case R_X86_64_GOTPCREL:
7b81dfbb
AJ		 3267 case R_X86_64_GOTPCREL64:
3268 /* Use global offset table entry as symbol value. */
3269 case R_X86_64_GOTPLT64:
3270 /* This is the same as GOT64 for relocation purposes, but
3271 indicates the existence of a PLT entry. The difficulty is,
3272 that we must calculate the GOT slot offset from the PLT
3273 offset, if this symbol got a PLT entry (it was global).
3274 Additionally if it's computed from the PLT entry, then that
3275 GOT offset is relative to .got.plt, not to .got. */
6de2ae4a 3276 base_got = htab->elf.sgot;
7b81dfbb 3277
6de2ae4a 3278 if (htab->elf.sgot == NULL)
c434dee6 3279 abort ();
053579d7 3280
51e0a107 3281 if (h != NULL)
70256ad8 3282 {
b34976b6 3283 bfd_boolean dyn;
c434dee6
AJ		 3284
3285 off = h->got.offset;
7b81dfbb
AJ		 3286 if (h->needs_plt
3287 && h->plt.offset != (bfd_vma)-1
3288 && off == (bfd_vma)-1)
3289 {
3290 /* We can't use h->got.offset here to save
3291 state, or even just remember the offset, as
3292 finish_dynamic_symbol would use that as offset into
3293 .got. */
3294 bfd_vma plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3295 off = (plt_index + 3) * GOT_ENTRY_SIZE;
6de2ae4a 3296 base_got = htab->elf.sgotplt;
7b81dfbb
AJ		 3297 }
3298
c434dee6 3299 dyn = htab->elf.dynamic_sections_created;
51e0a107 3300
27482721 3301 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
51e0a107 3302 || (info->shared
27482721 3303 && SYMBOL_REFERENCES_LOCAL (info, h))
4bc6e03a
AJ		 3304 || (ELF_ST_VISIBILITY (h->other)
3305 && h->root.type == bfd_link_hash_undefweak))
51e0a107
JH		 3306 {
3307 /* This is actually a static link, or it is a -Bsymbolic
3308 link and the symbol is defined locally, or the symbol
407443a3 3309 was forced to be local because of a version file. We
51e0a107
JH		 3310 must initialize this entry in the global offset table.
3311 Since the offset must always be a multiple of 8, we
3312 use the least significant bit to record whether we
3313 have initialized it already.
3314
3315 When doing a dynamic link, we create a .rela.got
407443a3
AJ		 3316 relocation entry to initialize the value. This is
3317 done in the finish_dynamic_symbol routine. */
51e0a107
JH		 3318 if ((off & 1) != 0)
3319 off &= ~1;
3320 else
3321 {
3322 bfd_put_64 (output_bfd, relocation,
7b81dfbb
AJ		 3323 base_got->contents + off);
3324 /* Note that this is harmless for the GOTPLT64 case,
3325 as -1 | 1 still is -1. */
51e0a107
JH		 3326 h->got.offset |= 1;
3327 }
3328 }
053579d7 3329 else
b34976b6 3330 unresolved_reloc = FALSE;
70256ad8 3331 }
51e0a107
JH		 3332 else
3333 {
c434dee6
AJ		 3334 if (local_got_offsets == NULL)
3335 abort ();
51e0a107
JH		 3336
3337 off = local_got_offsets[r_symndx];
3338
3339 /* The offset must always be a multiple of 8. We use
407443a3
AJ		 3340 the least significant bit to record whether we have
3341 already generated the necessary reloc. */
51e0a107
JH		 3342 if ((off & 1) != 0)
3343 off &= ~1;
3344 else
3345 {
c434dee6 3346 bfd_put_64 (output_bfd, relocation,
7b81dfbb 3347 base_got->contents + off);
51e0a107
JH		 3348
3349 if (info->shared)
3350 {
947216bf 3351 asection *s;
51e0a107 3352 Elf_Internal_Rela outrel;
70256ad8 3353
51e0a107
JH		 3354 /* We need to generate a R_X86_64_RELATIVE reloc
3355 for the dynamic linker. */
6de2ae4a 3356 s = htab->elf.srelgot;
947216bf 3357 if (s == NULL)
c434dee6 3358 abort ();
51e0a107 3359
7b81dfbb
AJ		 3360 outrel.r_offset = (base_got->output_section->vma
3361 + base_got->output_offset
51e0a107 3362 + off);
351f65ca 3363 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
51e0a107 3364 outrel.r_addend = relocation;
351f65ca 3365 elf_append_rela (output_bfd, s, &outrel);
51e0a107
JH		 3366 }
3367
3368 local_got_offsets[r_symndx] |= 1;
3369 }
51e0a107 3370 }
6a2bda3f 3371
c434dee6
AJ		 3372 if (off >= (bfd_vma) -2)
3373 abort ();
3374
7b81dfbb
AJ		 3375 relocation = base_got->output_section->vma
3376 + base_got->output_offset + off;
3377 if (r_type != R_X86_64_GOTPCREL && r_type != R_X86_64_GOTPCREL64)
6de2ae4a
L		 3378 relocation -= htab->elf.sgotplt->output_section->vma
3379 - htab->elf.sgotplt->output_offset;
c434dee6 3380
70256ad8
AJ		 3381 break;
3382
d6ab8113
JB		 3383 case R_X86_64_GOTOFF64:
3384 /* Relocation is relative to the start of the global offset
3385 table. */
3386
3387 /* Check to make sure it isn't a protected function symbol
3388 for shared library since it may not be local when used
3389 as function address. */
3390 if (info->shared
3391 && h
3392 && h->def_regular
3393 && h->type == STT_FUNC
3394 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3395 {
3396 (*_bfd_error_handler)
3397 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3398 input_bfd, h->root.root.string);
3399 bfd_set_error (bfd_error_bad_value);
3400 return FALSE;
3401 }
3402
3403 /* Note that sgot is not involved in this
3404 calculation. We always want the start of .got.plt. If we
3405 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3406 permitted by the ABI, we might have to change this
3407 calculation. */
6de2ae4a
L		 3408 relocation -= htab->elf.sgotplt->output_section->vma
3409 + htab->elf.sgotplt->output_offset;
d6ab8113
JB		 3410 break;
3411
3412 case R_X86_64_GOTPC32:
7b81dfbb 3413 case R_X86_64_GOTPC64:
d6ab8113 3414 /* Use global offset table as symbol value. */
6de2ae4a
L		 3415 relocation = htab->elf.sgotplt->output_section->vma
3416 + htab->elf.sgotplt->output_offset;
d6ab8113
JB		 3417 unresolved_reloc = FALSE;
3418 break;
7b81dfbb
AJ		 3419
3420 case R_X86_64_PLTOFF64:
3421 /* Relocation is PLT entry relative to GOT. For local
3422 symbols it's the symbol itself relative to GOT. */
3423 if (h != NULL
3424 /* See PLT32 handling. */
3425 && h->plt.offset != (bfd_vma) -1
6de2ae4a 3426 && htab->elf.splt != NULL)
7b81dfbb 3427 {
6de2ae4a
L		 3428 relocation = (htab->elf.splt->output_section->vma
3429 + htab->elf.splt->output_offset
7b81dfbb
AJ		 3430 + h->plt.offset);
3431 unresolved_reloc = FALSE;
3432 }
3433
6de2ae4a
L		 3434 relocation -= htab->elf.sgotplt->output_section->vma
3435 + htab->elf.sgotplt->output_offset;
7b81dfbb 3436 break;
d6ab8113 3437
70256ad8
AJ		 3438 case R_X86_64_PLT32:
3439 /* Relocation is to the entry for this symbol in the
3440 procedure linkage table. */
3441
3442 /* Resolve a PLT32 reloc against a local symbol directly,
407443a3 3443 without using the procedure linkage table. */
70256ad8
AJ		 3444 if (h == NULL)
3445 break;
3446
c434dee6 3447 if (h->plt.offset == (bfd_vma) -1
6de2ae4a 3448 || htab->elf.splt == NULL)
70256ad8
AJ		 3449 {
3450 /* We didn't make a PLT entry for this symbol. This
407443a3
AJ		 3451 happens when statically linking PIC code, or when
3452 using -Bsymbolic. */
70256ad8
AJ		 3453 break;
3454 }
3455
6de2ae4a
L		 3456 relocation = (htab->elf.splt->output_section->vma
3457 + htab->elf.splt->output_offset
70256ad8 3458 + h->plt.offset);
b34976b6 3459 unresolved_reloc = FALSE;
70256ad8
AJ		 3460 break;
3461
fd8ab9e5
AJ		 3462 case R_X86_64_PC8:
3463 case R_X86_64_PC16:
3464 case R_X86_64_PC32:
6610a52d 3465 if (info->shared
ba3bee0b 3466 && (input_section->flags & SEC_ALLOC) != 0
90f487df 3467 && (input_section->flags & SEC_READONLY) != 0
41bed6dd 3468 && h != NULL)
6610a52d 3469 {
41bed6dd
L		 3470 bfd_boolean fail = FALSE;
3471 bfd_boolean branch
3472 = (r_type == R_X86_64_PC32
3473 && is_32bit_relative_branch (contents, rel->r_offset));
3474
3475 if (SYMBOL_REFERENCES_LOCAL (info, h))
3476 {
3477 /* Symbol is referenced locally. Make sure it is
3478 defined locally or for a branch. */
3479 fail = !h->def_regular && !branch;
3480 }
90f487df 3481 else
41bed6dd
L		 3482 {
3483 /* Symbol isn't referenced locally. We only allow
3484 branch to symbol with non-default visibility. */
3485 fail = (!branch
3486 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
3487 }
3488
3489 if (fail)
3490 {
3491 const char *fmt;
3492 const char *v;
3493 const char *pic = "";
3494
3495 switch (ELF_ST_VISIBILITY (h->other))
3496 {
3497 case STV_HIDDEN:
3498 v = _("hidden symbol");
3499 break;
3500 case STV_INTERNAL:
3501 v = _("internal symbol");
3502 break;
3503 case STV_PROTECTED:
3504 v = _("protected symbol");
3505 break;
3506 default:
3507 v = _("symbol");
3508 pic = _("; recompile with -fPIC");
3509 break;
3510 }
3511
3512 if (h->def_regular)
3513 fmt = _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3514 else
3515 fmt = _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3516
3517 (*_bfd_error_handler) (fmt, input_bfd,
3518 x86_64_elf_howto_table[r_type].name,
3519 v, h->root.root.string, pic);
3520 bfd_set_error (bfd_error_bad_value);
3521 return FALSE;
3522 }
6610a52d
L		 3523 }
3524 /* Fall through. */
3525
70256ad8
AJ		 3526 case R_X86_64_8:
3527 case R_X86_64_16:
3528 case R_X86_64_32:
d6ab8113 3529 case R_X86_64_PC64:
6b3db546 3530 case R_X86_64_64:
80643fbc 3531 /* FIXME: The ABI says the linker should make sure the value is
407443a3 3532 the same when it's zeroextended to 64 bit. */
c434dee6 3533
b1e24c02 3534 if ((input_section->flags & SEC_ALLOC) == 0)
c434dee6
AJ		 3535 break;
3536
3537 if ((info->shared
4bc6e03a
AJ		 3538 && (h == NULL
3539 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3540 || h->root.type != bfd_link_hash_undefweak)
d8045f23
NC		 3541 && (! IS_X86_64_PCREL_TYPE (r_type)
3542 || ! SYMBOL_CALLS_LOCAL (info, h)))
d40d037c
AJ		 3543 || (ELIMINATE_COPY_RELOCS
3544 && !info->shared
c434dee6
AJ		 3545 && h != NULL
3546 && h->dynindx != -1
f5385ebf
AM		 3547 && !h->non_got_ref
3548 && ((h->def_dynamic
3549 && !h->def_regular)
c434dee6 3550 || h->root.type == bfd_link_hash_undefweak
0f88be7a 3551 || h->root.type == bfd_link_hash_undefined)))
70256ad8
AJ		 3552 {
3553 Elf_Internal_Rela outrel;
b34976b6 3554 bfd_boolean skip, relocate;
c434dee6 3555 asection *sreloc;
70256ad8
AJ		 3556
3557 /* When generating a shared object, these relocations
3558 are copied into the output file to be resolved at run
407443a3 3559 time. */
b34976b6
AM		 3560 skip = FALSE;
3561 relocate = FALSE;
70256ad8 3562
c629eae0
JJ		 3563 outrel.r_offset =
3564 _bfd_elf_section_offset (output_bfd, info, input_section,
c434dee6 3565 rel->r_offset);
c629eae0 3566 if (outrel.r_offset == (bfd_vma) -1)
b34976b6 3567 skip = TRUE;
0fb19cbc 3568 else if (outrel.r_offset == (bfd_vma) -2)
b34976b6 3569 skip = TRUE, relocate = TRUE;
70256ad8
AJ		 3570
3571 outrel.r_offset += (input_section->output_section->vma
3572 + input_section->output_offset);
3573
3574 if (skip)
0bb2d96a 3575 memset (&outrel, 0, sizeof outrel);
c434dee6 3576
fd8ab9e5
AJ		 3577 /* h->dynindx may be -1 if this symbol was marked to
3578 become local. */
3579 else if (h != NULL
c434dee6 3580 && h->dynindx != -1
d8045f23
NC		 3581 && (IS_X86_64_PCREL_TYPE (r_type)
3582 || ! info->shared
3583 || ! SYMBOLIC_BIND (info, h)
3584 || ! h->def_regular))
70256ad8 3585 {
351f65ca 3586 outrel.r_info = htab->r_info (h->dynindx, r_type);
c434dee6 3587 outrel.r_addend = rel->r_addend;
70256ad8
AJ		 3588 }
3589 else
3590 {
c434dee6 3591 /* This symbol is local, or marked to become local. */
248775ba 3592 if (r_type == htab->pointer_r_type)
607c0e09 3593 {
b34976b6 3594 relocate = TRUE;
351f65ca 3595 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
607c0e09
AS		 3596 outrel.r_addend = relocation + rel->r_addend;
3597 }
64d25c44
L		 3598 else if (r_type == R_X86_64_64
3599 && !ABI_64_P (output_bfd))
3600 {
3601 relocate = TRUE;
3602 outrel.r_info = htab->r_info (0,
3603 R_X86_64_RELATIVE64);
3604 outrel.r_addend = relocation + rel->r_addend;
3605 }
607c0e09
AS		 3606 else
3607 {
3608 long sindx;
3609
8517fae7 3610 if (bfd_is_abs_section (sec))
607c0e09
AS		 3611 sindx = 0;
3612 else if (sec == NULL || sec->owner == NULL)
3613 {
3614 bfd_set_error (bfd_error_bad_value);
b34976b6 3615 return FALSE;
607c0e09
AS		 3616 }
3617 else
3618 {
3619 asection *osec;
3620
74541ad4
AM		 3621 /* We are turning this relocation into one
3622 against a section symbol. It would be
3623 proper to subtract the symbol's value,
3624 osec->vma, from the emitted reloc addend,
3625 but ld.so expects buggy relocs. */
607c0e09
AS		 3626 osec = sec->output_section;
3627 sindx = elf_section_data (osec)->dynindx;
74541ad4
AM		 3628 if (sindx == 0)
3629 {
3630 asection *oi = htab->elf.text_index_section;
3631 sindx = elf_section_data (oi)->dynindx;
3632 }
3633 BFD_ASSERT (sindx != 0);
607c0e09
AS		 3634 }
3635
351f65ca 3636 outrel.r_info = htab->r_info (sindx, r_type);
607c0e09
AS		 3637 outrel.r_addend = relocation + rel->r_addend;
3638 }
70256ad8
AJ		 3639 }
3640
cbe950e9 3641 sreloc = elf_section_data (input_section)->sreloc;
d8045f23 3642
62d78908
L		 3643 if (sreloc == NULL || sreloc->contents == NULL)
3644 {
3645 r = bfd_reloc_notsupported;
3646 goto check_relocation_error;
3647 }
c434dee6 3648
351f65ca 3649 elf_append_rela (output_bfd, sreloc, &outrel);
70256ad8
AJ		 3650
3651 /* If this reloc is against an external symbol, we do
3652 not want to fiddle with the addend. Otherwise, we
3653 need to include the symbol value so that it becomes
3654 an addend for the dynamic reloc. */
0f88be7a 3655 if (! relocate)
70256ad8
AJ		 3656 continue;
3657 }
3658
3659 break;
3660
bffbf940 3661 case R_X86_64_TLSGD:
67a4f2b7
AO		 3662 case R_X86_64_GOTPC32_TLSDESC:
3663 case R_X86_64_TLSDESC_CALL:
bffbf940 3664 case R_X86_64_GOTTPOFF:
bffbf940
JJ		 3665 tls_type = GOT_UNKNOWN;
3666 if (h == NULL && local_got_offsets)
351f65ca 3667 tls_type = elf_x86_64_local_got_tls_type (input_bfd) [r_symndx];
bffbf940 3668 else if (h != NULL)
351f65ca 3669 tls_type = elf_x86_64_hash_entry (h)->tls_type;
142411ca 3670
351f65ca
L		 3671 if (! elf_x86_64_tls_transition (info, input_bfd,
3672 input_section, contents,
3673 symtab_hdr, sym_hashes,
3674 &r_type, tls_type, rel,
3675 relend, h, r_symndx))
534a31f6 3676 return FALSE;
bffbf940
JJ		 3677
3678 if (r_type == R_X86_64_TPOFF32)
3679 {
142411ca
L		 3680 bfd_vma roff = rel->r_offset;
3681
bffbf940 3682 BFD_ASSERT (! unresolved_reloc);
142411ca 3683
351f65ca 3684 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
bffbf940 3685 {
52bc799a 3686 /* GD->LE transition. For 64bit, change
abcf1d52 3687 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
a3fadc9a 3688 .word 0x6666; rex64; call __tls_get_addr
52bc799a 3689 into:
bffbf940 3690 movq %fs:0, %rax
52bc799a
L		 3691 leaq foo@tpoff(%rax), %rax
3692 For 32bit, change
3693 leaq foo@tlsgd(%rip), %rdi
3694 .word 0x6666; rex64; call __tls_get_addr
3695 into:
3696 movl %fs:0, %eax
bffbf940 3697 leaq foo@tpoff(%rax), %rax */
52bc799a
L		 3698 if (ABI_64_P (output_bfd))
3699 memcpy (contents + roff - 4,
3700 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3701 16);
3702 else
3703 memcpy (contents + roff - 3,
3704 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3705 15);
eb4ff4d6 3706 bfd_put_32 (output_bfd,
351f65ca 3707 elf_x86_64_tpoff (info, relocation),
142411ca 3708 contents + roff + 8);
a3fadc9a 3709 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
bffbf940
JJ		 3710 rel++;
3711 continue;
3712 }
351f65ca 3713 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
67a4f2b7
AO		 3714 {
3715 /* GDesc -> LE transition.
3716 It's originally something like:
3717 leaq x@tlsdesc(%rip), %rax
3718
3719 Change it to:
c9736ba0 3720 movl $x@tpoff, %rax. */
67a4f2b7 3721
c9736ba0 3722 unsigned int val, type;
67a4f2b7 3723
67a4f2b7 3724 type = bfd_get_8 (input_bfd, contents + roff - 3);
67a4f2b7 3725 val = bfd_get_8 (input_bfd, contents + roff - 1);
67a4f2b7
AO		 3726 bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
3727 contents + roff - 3);
3728 bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
3729 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3730 contents + roff - 1);
eb4ff4d6 3731 bfd_put_32 (output_bfd,
351f65ca 3732 elf_x86_64_tpoff (info, relocation),
67a4f2b7
AO		 3733 contents + roff);
3734 continue;
3735 }
351f65ca 3736 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
67a4f2b7
AO		 3737 {
3738 /* GDesc -> LE transition.
3739 It's originally:
3740 call *(%rax)
3741 Turn it into:
142411ca 3742 xchg %ax,%ax. */
10efb593 3743 bfd_put_8 (output_bfd, 0x66, contents + roff);
67a4f2b7
AO		 3744 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3745 continue;
3746 }
351f65ca 3747 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
bffbf940 3748 {
bffbf940
JJ		 3749 /* IE->LE transition:
3750 Originally it can be one of:
3751 movq foo@gottpoff(%rip), %reg
3752 addq foo@gottpoff(%rip), %reg
3753 We change it into:
3754 movq $foo, %reg
3755 leaq foo(%reg), %reg
3756 addq $foo, %reg. */
142411ca
L		 3757
3758 unsigned int val, type, reg;
3759
3760 val = bfd_get_8 (input_bfd, contents + roff - 3);
3761 type = bfd_get_8 (input_bfd, contents + roff - 2);
3762 reg = bfd_get_8 (input_bfd, contents + roff - 1);
bffbf940 3763 reg >>= 3;
bffbf940
JJ		 3764 if (type == 0x8b)
3765 {
3766 /* movq */
3767 if (val == 0x4c)
3768 bfd_put_8 (output_bfd, 0x49,
142411ca 3769 contents + roff - 3);
4a4c5f25
L		 3770 else if (!ABI_64_P (output_bfd) && val == 0x44)
3771 bfd_put_8 (output_bfd, 0x41,
3772 contents + roff - 3);
bffbf940 3773 bfd_put_8 (output_bfd, 0xc7,
142411ca 3774 contents + roff - 2);
bffbf940 3775 bfd_put_8 (output_bfd, 0xc0 | reg,
142411ca 3776 contents + roff - 1);
bffbf940
JJ		 3777 }
3778 else if (reg == 4)
3779 {
3780 /* addq -> addq - addressing with %rsp/%r12 is
3781 special */
3782 if (val == 0x4c)
3783 bfd_put_8 (output_bfd, 0x49,
142411ca 3784 contents + roff - 3);
4a4c5f25
L		 3785 else if (!ABI_64_P (output_bfd) && val == 0x44)
3786 bfd_put_8 (output_bfd, 0x41,
3787 contents + roff - 3);
bffbf940 3788 bfd_put_8 (output_bfd, 0x81,
142411ca 3789 contents + roff - 2);
bffbf940 3790 bfd_put_8 (output_bfd, 0xc0 | reg,
142411ca 3791 contents + roff - 1);
bffbf940
JJ		 3792 }
3793 else
3794 {
3795 /* addq -> leaq */
3796 if (val == 0x4c)
3797 bfd_put_8 (output_bfd, 0x4d,
142411ca 3798 contents + roff - 3);
4a4c5f25
L		 3799 else if (!ABI_64_P (output_bfd) && val == 0x44)
3800 bfd_put_8 (output_bfd, 0x45,
3801 contents + roff - 3);
bffbf940 3802 bfd_put_8 (output_bfd, 0x8d,
142411ca 3803 contents + roff - 2);
bffbf940 3804 bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
142411ca 3805 contents + roff - 1);
bffbf940 3806 }
eb4ff4d6 3807 bfd_put_32 (output_bfd,
351f65ca 3808 elf_x86_64_tpoff (info, relocation),
142411ca 3809 contents + roff);
bffbf940
JJ		 3810 continue;
3811 }
142411ca
L		 3812 else
3813 BFD_ASSERT (FALSE);
bffbf940
JJ		 3814 }
3815
6de2ae4a 3816 if (htab->elf.sgot == NULL)
bffbf940
JJ		 3817 abort ();
3818
3819 if (h != NULL)
67a4f2b7
AO		 3820 {
3821 off = h->got.offset;
351f65ca 3822 offplt = elf_x86_64_hash_entry (h)->tlsdesc_got;
67a4f2b7 3823 }
bffbf940
JJ		 3824 else
3825 {
3826 if (local_got_offsets == NULL)
3827 abort ();
3828
3829 off = local_got_offsets[r_symndx];
67a4f2b7 3830 offplt = local_tlsdesc_gotents[r_symndx];
bffbf940
JJ		 3831 }
3832
3833 if ((off & 1) != 0)
3834 off &= ~1;
26e41594 3835 else
bffbf940
JJ		 3836 {
3837 Elf_Internal_Rela outrel;
bffbf940 3838 int dr_type, indx;
67a4f2b7 3839 asection *sreloc;
bffbf940 3840
6de2ae4a 3841 if (htab->elf.srelgot == NULL)
bffbf940
JJ		 3842 abort ();
3843
67a4f2b7
AO		 3844 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3845
3846 if (GOT_TLS_GDESC_P (tls_type))
3847 {
351f65ca 3848 outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
67a4f2b7 3849 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
6de2ae4a
L		 3850 + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
3851 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
3852 + htab->elf.sgotplt->output_offset
67a4f2b7
AO		 3853 + offplt
3854 + htab->sgotplt_jump_table_size);
6de2ae4a 3855 sreloc = htab->elf.srelplt;
67a4f2b7 3856 if (indx == 0)
351f65ca 3857 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
67a4f2b7
AO		 3858 else
3859 outrel.r_addend = 0;
351f65ca 3860 elf_append_rela (output_bfd, sreloc, &outrel);
67a4f2b7
AO		 3861 }
3862
6de2ae4a 3863 sreloc = htab->elf.srelgot;
67a4f2b7 3864
6de2ae4a
L		 3865 outrel.r_offset = (htab->elf.sgot->output_section->vma
3866 + htab->elf.sgot->output_offset + off);
bffbf940 3867
67a4f2b7 3868 if (GOT_TLS_GD_P (tls_type))
bffbf940 3869 dr_type = R_X86_64_DTPMOD64;
67a4f2b7
AO		 3870 else if (GOT_TLS_GDESC_P (tls_type))
3871 goto dr_done;
bffbf940
JJ		 3872 else
3873 dr_type = R_X86_64_TPOFF64;
3874
6de2ae4a 3875 bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
bffbf940 3876 outrel.r_addend = 0;
67a4f2b7
AO		 3877 if ((dr_type == R_X86_64_TPOFF64
3878 || dr_type == R_X86_64_TLSDESC) && indx == 0)
351f65ca
L		 3879 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
3880 outrel.r_info = htab->r_info (indx, dr_type);
bffbf940 3881
351f65ca 3882 elf_append_rela (output_bfd, sreloc, &outrel);
bffbf940 3883
67a4f2b7 3884 if (GOT_TLS_GD_P (tls_type))
bffbf940
JJ		 3885 {
3886 if (indx == 0)
3887 {
d40d037c 3888 BFD_ASSERT (! unresolved_reloc);
bffbf940 3889 bfd_put_64 (output_bfd,
351f65ca 3890 relocation - elf_x86_64_dtpoff_base (info),
6de2ae4a 3891 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
bffbf940
JJ		 3892 }
3893 else
3894 {
3895 bfd_put_64 (output_bfd, 0,
6de2ae4a 3896 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
351f65ca 3897 outrel.r_info = htab->r_info (indx,
bffbf940
JJ		 3898 R_X86_64_DTPOFF64);
3899 outrel.r_offset += GOT_ENTRY_SIZE;
351f65ca 3900 elf_append_rela (output_bfd, sreloc,
464d3bd4 3901 &outrel);
bffbf940
JJ		 3902 }
3903 }
3904
67a4f2b7 3905 dr_done:
bffbf940
JJ		 3906 if (h != NULL)
3907 h->got.offset |= 1;
3908 else
3909 local_got_offsets[r_symndx] |= 1;
3910 }
3911
67a4f2b7
AO		 3912 if (off >= (bfd_vma) -2
3913 && ! GOT_TLS_GDESC_P (tls_type))
bffbf940 3914 abort ();
351f65ca 3915 if (r_type == ELF32_R_TYPE (rel->r_info))
bffbf940 3916 {
67a4f2b7
AO		 3917 if (r_type == R_X86_64_GOTPC32_TLSDESC
3918 || r_type == R_X86_64_TLSDESC_CALL)
6de2ae4a
L		 3919 relocation = htab->elf.sgotplt->output_section->vma
3920 + htab->elf.sgotplt->output_offset
67a4f2b7
AO		 3921 + offplt + htab->sgotplt_jump_table_size;
3922 else
6de2ae4a
L		 3923 relocation = htab->elf.sgot->output_section->vma
3924 + htab->elf.sgot->output_offset + off;
b34976b6 3925 unresolved_reloc = FALSE;
bffbf940 3926 }
142411ca 3927 else
67a4f2b7 3928 {
142411ca 3929 bfd_vma roff = rel->r_offset;
67a4f2b7 3930
351f65ca 3931 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
142411ca 3932 {
52bc799a 3933 /* GD->IE transition. For 64bit, change
142411ca
L		 3934 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3935 .word 0x6666; rex64; call __tls_get_addr@plt
52bc799a 3936 into:
142411ca 3937 movq %fs:0, %rax
52bc799a
L		 3938 addq foo@gottpoff(%rip), %rax
3939 For 32bit, change
3940 leaq foo@tlsgd(%rip), %rdi
3941 .word 0x6666; rex64; call __tls_get_addr@plt
3942 into:
3943 movl %fs:0, %eax
142411ca 3944 addq foo@gottpoff(%rip), %rax */
52bc799a
L		 3945 if (ABI_64_P (output_bfd))
3946 memcpy (contents + roff - 4,
3947 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3948 16);
3949 else
3950 memcpy (contents + roff - 3,
3951 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3952 15);
142411ca 3953
6de2ae4a
L		 3954 relocation = (htab->elf.sgot->output_section->vma
3955 + htab->elf.sgot->output_offset + off
142411ca
L		 3956 - roff
3957 - input_section->output_section->vma
3958 - input_section->output_offset
3959 - 12);
3960 bfd_put_32 (output_bfd, relocation,
3961 contents + roff + 8);
3962 /* Skip R_X86_64_PLT32. */
3963 rel++;
3964 continue;
3965 }
351f65ca 3966 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
142411ca
L		 3967 {
3968 /* GDesc -> IE transition.
3969 It's originally something like:
3970 leaq x@tlsdesc(%rip), %rax
67a4f2b7 3971
142411ca 3972 Change it to:
c9736ba0 3973 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
67a4f2b7 3974
142411ca
L		 3975 /* Now modify the instruction as appropriate. To
3976 turn a leaq into a movq in the form we use it, it
3977 suffices to change the second byte from 0x8d to
3978 0x8b. */
3979 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
3980
3981 bfd_put_32 (output_bfd,
6de2ae4a
L		 3982 htab->elf.sgot->output_section->vma
3983 + htab->elf.sgot->output_offset + off
142411ca
L		 3984 - rel->r_offset
3985 - input_section->output_section->vma
3986 - input_section->output_offset
3987 - 4,
3988 contents + roff);
3989 continue;
3990 }
351f65ca 3991 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
142411ca
L		 3992 {
3993 /* GDesc -> IE transition.
3994 It's originally:
3995 call *(%rax)
3996
3997 Change it to:
c9736ba0 3998 xchg %ax, %ax. */
142411ca 3999
142411ca
L		 4000 bfd_put_8 (output_bfd, 0x66, contents + roff);
4001 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4002 continue;
4003 }
4004 else
4005 BFD_ASSERT (FALSE);
67a4f2b7 4006 }
bffbf940
JJ		 4007 break;
4008
4009 case R_X86_64_TLSLD:
351f65ca
L		 4010 if (! elf_x86_64_tls_transition (info, input_bfd,
4011 input_section, contents,
4012 symtab_hdr, sym_hashes,
4013 &r_type, GOT_UNKNOWN,
4014 rel, relend, h, r_symndx))
142411ca 4015 return FALSE;
a3fadc9a 4016
142411ca
L		 4017 if (r_type != R_X86_64_TLSLD)
4018 {
bffbf940 4019 /* LD->LE transition:
a3fadc9a 4020 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
52bc799a
L		 4021 For 64bit, we change it into:
4022 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4023 For 32bit, we change it into:
4024 nopl 0x0(%rax); movl %fs:0, %eax. */
142411ca
L		 4025
4026 BFD_ASSERT (r_type == R_X86_64_TPOFF32);
52bc799a
L		 4027 if (ABI_64_P (output_bfd))
4028 memcpy (contents + rel->r_offset - 3,
4029 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4030 else
4031 memcpy (contents + rel->r_offset - 3,
4032 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
a3fadc9a 4033 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
bffbf940
JJ		 4034 rel++;
4035 continue;
4036 }
4037
6de2ae4a 4038 if (htab->elf.sgot == NULL)
bffbf940
JJ		 4039 abort ();
4040
4041 off = htab->tls_ld_got.offset;
4042 if (off & 1)
4043 off &= ~1;
4044 else
4045 {
4046 Elf_Internal_Rela outrel;
bffbf940 4047
6de2ae4a 4048 if (htab->elf.srelgot == NULL)
bffbf940
JJ		 4049 abort ();
4050
6de2ae4a
L		 4051 outrel.r_offset = (htab->elf.sgot->output_section->vma
4052 + htab->elf.sgot->output_offset + off);
bffbf940
JJ		 4053
4054 bfd_put_64 (output_bfd, 0,
6de2ae4a 4055 htab->elf.sgot->contents + off);
bffbf940 4056 bfd_put_64 (output_bfd, 0,
6de2ae4a 4057 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
351f65ca 4058 outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
bffbf940 4059 outrel.r_addend = 0;
351f65ca 4060 elf_append_rela (output_bfd, htab->elf.srelgot,
464d3bd4 4061 &outrel);
bffbf940
JJ		 4062 htab->tls_ld_got.offset |= 1;
4063 }
6de2ae4a
L		 4064 relocation = htab->elf.sgot->output_section->vma
4065 + htab->elf.sgot->output_offset + off;
b34976b6 4066 unresolved_reloc = FALSE;
bffbf940
JJ		 4067 break;
4068
4069 case R_X86_64_DTPOFF32:
1d85728f 4070 if (!info->executable|| (input_section->flags & SEC_CODE) == 0)
351f65ca 4071 relocation -= elf_x86_64_dtpoff_base (info);
bffbf940 4072 else
351f65ca 4073 relocation = elf_x86_64_tpoff (info, relocation);
bffbf940
JJ		 4074 break;
4075
4076 case R_X86_64_TPOFF32:
6769d501 4077 case R_X86_64_TPOFF64:
9b769489 4078 BFD_ASSERT (info->executable);
351f65ca 4079 relocation = elf_x86_64_tpoff (info, relocation);
bffbf940
JJ		 4080 break;
4081
70256ad8
AJ		 4082 default:
4083 break;
4084 }
8d88c4ca 4085
239e1f3a
AM		 4086 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4087 because such sections are not SEC_ALLOC and thus ld.so will
4088 not process them. */
c434dee6 4089 if (unresolved_reloc
239e1f3a 4090 && !((input_section->flags & SEC_DEBUGGING) != 0
1d5316ab
AM		 4091 && h->def_dynamic)
4092 && _bfd_elf_section_offset (output_bfd, info, input_section,
4093 rel->r_offset) != (bfd_vma) -1)
c434dee6 4094 (*_bfd_error_handler)
843fe662 4095 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
d003868e
AM		 4096 input_bfd,
4097 input_section,
c434dee6 4098 (long) rel->r_offset,
843fe662 4099 howto->name,
c434dee6
AJ		 4100 h->root.root.string);
4101
cbe950e9 4102do_relocation:
8d88c4ca 4103 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
c434dee6
AJ		 4104 contents, rel->r_offset,
4105 relocation, rel->r_addend);
8d88c4ca 4106
62d78908 4107check_relocation_error:
8d88c4ca 4108 if (r != bfd_reloc_ok)
8da6118f 4109 {
c434dee6
AJ		 4110 const char *name;
4111
4112 if (h != NULL)
4113 name = h->root.root.string;
4114 else
8da6118f 4115 {
c434dee6
AJ		 4116 name = bfd_elf_string_from_elf_section (input_bfd,
4117 symtab_hdr->sh_link,
4118 sym->st_name);
4119 if (name == NULL)
b34976b6 4120 return FALSE;
c434dee6
AJ		 4121 if (*name == '\0')
4122 name = bfd_section_name (input_bfd, sec);
4123 }
4124
4125 if (r == bfd_reloc_overflow)
4126 {
c434dee6 4127 if (! ((*info->callbacks->reloc_overflow)
dfeffb9f
L		 4128 (info, (h ? &h->root : NULL), name, howto->name,
4129 (bfd_vma) 0, input_bfd, input_section,
4130 rel->r_offset)))
b34976b6 4131 return FALSE;
c434dee6
AJ		 4132 }
4133 else
4134 {
4135 (*_bfd_error_handler)
bb95161d 4136 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
d003868e 4137 input_bfd, input_section,
c434dee6 4138 (long) rel->r_offset, name, (int) r);
b34976b6 4139 return FALSE;
8da6118f
KH		 4140 }
4141 }
8d88c4ca 4142 }
70256ad8 4143
b34976b6 4144 return TRUE;
70256ad8
AJ		 4145}
4146
4147/* Finish up dynamic symbol handling. We set the contents of various
4148 dynamic sections here. */
4149
b34976b6 4150static bfd_boolean
351f65ca
L		 4151elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
4152 struct bfd_link_info *info,
4153 struct elf_link_hash_entry *h,
4154 Elf_Internal_Sym *sym)
70256ad8 4155{
351f65ca 4156 struct elf_x86_64_link_hash_table *htab;
70256ad8 4157
351f65ca 4158 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 4159 if (htab == NULL)
4160 return FALSE;
70256ad8
AJ		 4161
4162 if (h->plt.offset != (bfd_vma) -1)
4163 {
70256ad8
AJ		 4164 bfd_vma plt_index;
4165 bfd_vma got_offset;
4166 Elf_Internal_Rela rela;
947216bf 4167 bfd_byte *loc;
cbe950e9 4168 asection *plt, *gotplt, *relplt;
351f65ca 4169 const struct elf_backend_data *bed;
cbe950e9
L		 4170
4171 /* When building a static executable, use .iplt, .igot.plt and
4172 .rela.iplt sections for STT_GNU_IFUNC symbols. */
6de2ae4a 4173 if (htab->elf.splt != NULL)
cbe950e9 4174 {
6de2ae4a
L		 4175 plt = htab->elf.splt;
4176 gotplt = htab->elf.sgotplt;
4177 relplt = htab->elf.srelplt;
cbe950e9
L		 4178 }
4179 else
4180 {
6de2ae4a
L		 4181 plt = htab->elf.iplt;
4182 gotplt = htab->elf.igotplt;
4183 relplt = htab->elf.irelplt;
cbe950e9 4184 }
70256ad8
AJ		 4185
4186 /* This symbol has an entry in the procedure linkage table. Set
407443a3 4187 it up. */
cbe950e9
L		 4188 if ((h->dynindx == -1
4189 && !((h->forced_local || info->executable)
4190 && h->def_regular
4191 && h->type == STT_GNU_IFUNC))
4192 || plt == NULL
4193 || gotplt == NULL
4194 || relplt == NULL)
f6df62c8 4195 return FALSE;
70256ad8
AJ		 4196
4197 /* Get the index in the procedure linkage table which
4198 corresponds to this symbol. This is the index of this symbol
4199 in all the symbols for which we are making plt entries. The
cbe950e9 4200 first entry in the procedure linkage table is reserved.
6bbec505 4201
cbe950e9 4202 Get the offset into the .got table of the entry that
407443a3 4203 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
cbe950e9
L		 4204 bytes. The first three are reserved for the dynamic linker.
4205
4206 For static executables, we don't reserve anything. */
4207
6de2ae4a 4208 if (plt == htab->elf.splt)
cbe950e9 4209 {
e1f98742
L		 4210 got_offset = h->plt.offset / PLT_ENTRY_SIZE - 1;
4211 got_offset = (got_offset + 3) * GOT_ENTRY_SIZE;
cbe950e9
L		 4212 }
4213 else
4214 {
e1f98742
L		 4215 got_offset = h->plt.offset / PLT_ENTRY_SIZE;
4216 got_offset = got_offset * GOT_ENTRY_SIZE;
cbe950e9 4217 }
70256ad8
AJ		 4218
4219 /* Fill in the entry in the procedure linkage table. */
351f65ca 4220 memcpy (plt->contents + h->plt.offset, elf_x86_64_plt_entry,
70256ad8
AJ		 4221 PLT_ENTRY_SIZE);
4222
4223 /* Insert the relocation positions of the plt section. The magic
4224 numbers at the end of the statements are the positions of the
4225 relocations in the plt section. */
653165cc
AJ		 4226 /* Put offset for jmp *name@GOTPCREL(%rip), since the
4227 instruction uses 6 bytes, subtract this value. */
4228 bfd_put_32 (output_bfd,
cbe950e9
L		 4229 (gotplt->output_section->vma
4230 + gotplt->output_offset
653165cc 4231 + got_offset
cbe950e9
L		 4232 - plt->output_section->vma
4233 - plt->output_offset
653165cc
AJ		 4234 - h->plt.offset
4235 - 6),
cbe950e9
L		 4236 plt->contents + h->plt.offset + 2);
4237
653165cc
AJ		 4238 /* Fill in the entry in the global offset table, initially this
4239 points to the pushq instruction in the PLT which is at offset 6. */
cbe950e9
L		 4240 bfd_put_64 (output_bfd, (plt->output_section->vma
4241 + plt->output_offset
70256ad8 4242 + h->plt.offset + 6),
cbe950e9 4243 gotplt->contents + got_offset);
70256ad8
AJ		 4244
4245 /* Fill in the entry in the .rela.plt section. */
cbe950e9
L		 4246 rela.r_offset = (gotplt->output_section->vma
4247 + gotplt->output_offset
70256ad8 4248 + got_offset);
cbe950e9
L		 4249 if (h->dynindx == -1
4250 || ((info->executable
4251 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4252 && h->def_regular
4253 && h->type == STT_GNU_IFUNC))
4254 {
4255 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4256 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
351f65ca 4257 rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
cbe950e9
L		 4258 rela.r_addend = (h->root.u.def.value
4259 + h->root.u.def.section->output_section->vma
4260 + h->root.u.def.section->output_offset);
e1f98742
L		 4261 /* R_X86_64_IRELATIVE comes last. */
4262 plt_index = htab->next_irelative_index--;
cbe950e9
L		 4263 }
4264 else
4265 {
351f65ca 4266 rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
cbe950e9 4267 rela.r_addend = 0;
e1f98742
L		 4268 plt_index = htab->next_jump_slot_index++;
4269 }
4270
4271 /* Don't fill PLT entry for static executables. */
4272 if (plt == htab->elf.splt)
4273 {
4274 /* Put relocation index. */
4275 bfd_put_32 (output_bfd, plt_index,
4276 plt->contents + h->plt.offset + 7);
4277 /* Put offset for jmp .PLT0. */
4278 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
4279 plt->contents + h->plt.offset + 12);
cbe950e9 4280 }
351f65ca
L		 4281
4282 bed = get_elf_backend_data (output_bfd);
4283 loc = relplt->contents + plt_index * bed->s->sizeof_rela;
82e96e07 4284 bed->s->swap_reloca_out (output_bfd, &rela, loc);
70256ad8 4285
f5385ebf 4286 if (!h->def_regular)
70256ad8
AJ		 4287 {
4288 /* Mark the symbol as undefined, rather than as defined in
47a9f7b3
JJ		 4289 the .plt section. Leave the value if there were any
4290 relocations where pointer equality matters (this is a clue
c434dee6
AJ		 4291 for the dynamic linker, to make function pointer
4292 comparisons work between an application and shared
47a9f7b3
JJ		 4293 library), otherwise set it to zero. If a function is only
4294 called from a binary, there is no need to slow down
4295 shared libraries because of that. */
70256ad8 4296 sym->st_shndx = SHN_UNDEF;
f5385ebf 4297 if (!h->pointer_equality_needed)
47a9f7b3 4298 sym->st_value = 0;
70256ad8
AJ		 4299 }
4300 }
4301
bffbf940 4302 if (h->got.offset != (bfd_vma) -1
351f65ca
L		 4303 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h)->tls_type)
4304 && elf_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
053579d7 4305 {
053579d7
AJ		 4306 Elf_Internal_Rela rela;
4307
4308 /* This symbol has an entry in the global offset table. Set it
bffbf940 4309 up. */
6de2ae4a 4310 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
c434dee6 4311 abort ();
053579d7 4312
6de2ae4a
L		 4313 rela.r_offset = (htab->elf.sgot->output_section->vma
4314 + htab->elf.sgot->output_offset
dc810e39 4315 + (h->got.offset &~ (bfd_vma) 1));
053579d7
AJ		 4316
4317 /* If this is a static link, or it is a -Bsymbolic link and the
4318 symbol is defined locally or was forced to be local because
4319 of a version file, we just want to emit a RELATIVE reloc.
4320 The entry in the global offset table will already have been
4321 initialized in the relocate_section function. */
710ab287 4322 if (h->def_regular
0018b0a3
L		 4323 && h->type == STT_GNU_IFUNC)
4324 {
710ab287
L		 4325 if (info->shared)
4326 {
4327 /* Generate R_X86_64_GLOB_DAT. */
4328 goto do_glob_dat;
4329 }
4330 else
4331 {
90d60710
L		 4332 asection *plt;
4333
710ab287
L		 4334 if (!h->pointer_equality_needed)
4335 abort ();
4336
4337 /* For non-shared object, we can't use .got.plt, which
4338 contains the real function addres if we need pointer
4339 equality. We load the GOT entry with the PLT entry. */
90d60710 4340 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
710ab287
L		 4341 bfd_put_64 (output_bfd, (plt->output_section->vma
4342 + plt->output_offset
4343 + h->plt.offset),
6de2ae4a 4344 htab->elf.sgot->contents + h->got.offset);
710ab287
L		 4345 return TRUE;
4346 }
0018b0a3
L		 4347 }
4348 else if (info->shared
4349 && SYMBOL_REFERENCES_LOCAL (info, h))
053579d7 4350 {
41bed6dd
L		 4351 if (!h->def_regular)
4352 return FALSE;
cc78d0af 4353 BFD_ASSERT((h->got.offset & 1) != 0);
351f65ca 4354 rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
053579d7
AJ		 4355 rela.r_addend = (h->root.u.def.value
4356 + h->root.u.def.section->output_section->vma
4357 + h->root.u.def.section->output_offset);
4358 }
4359 else
4360 {
4361 BFD_ASSERT((h->got.offset & 1) == 0);
710ab287 4362do_glob_dat:
c434dee6 4363 bfd_put_64 (output_bfd, (bfd_vma) 0,
6de2ae4a 4364 htab->elf.sgot->contents + h->got.offset);
351f65ca 4365 rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
053579d7
AJ		 4366 rela.r_addend = 0;
4367 }
4368
351f65ca 4369 elf_append_rela (output_bfd, htab->elf.srelgot, &rela);
053579d7
AJ		 4370 }
4371
f5385ebf 4372 if (h->needs_copy)
70256ad8 4373 {
70256ad8
AJ		 4374 Elf_Internal_Rela rela;
4375
4376 /* This symbol needs a copy reloc. Set it up. */
4377
c434dee6
AJ		 4378 if (h->dynindx == -1
4379 || (h->root.type != bfd_link_hash_defined
4380 && h->root.type != bfd_link_hash_defweak)
4381 || htab->srelbss == NULL)
4382 abort ();
70256ad8
AJ		 4383
4384 rela.r_offset = (h->root.u.def.value
4385 + h->root.u.def.section->output_section->vma
4386 + h->root.u.def.section->output_offset);
351f65ca 4387 rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
70256ad8 4388 rela.r_addend = 0;
351f65ca 4389 elf_append_rela (output_bfd, htab->srelbss, &rela);
70256ad8
AJ		 4390 }
4391
c25bc9fc
L		 4392 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. SYM may
4393 be NULL for local symbols. */
4394 if (sym != NULL
4395 && (strcmp (h->root.root.string, "_DYNAMIC") == 0
4396 || h == htab->elf.hgot))
70256ad8
AJ		 4397 sym->st_shndx = SHN_ABS;
4398
b34976b6 4399 return TRUE;
70256ad8
AJ		 4400}
4401
c25bc9fc
L		 4402/* Finish up local dynamic symbol handling. We set the contents of
4403 various dynamic sections here. */
4404
4405static bfd_boolean
351f65ca 4406elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
c25bc9fc
L		 4407{
4408 struct elf_link_hash_entry *h
4409 = (struct elf_link_hash_entry *) *slot;
4410 struct bfd_link_info *info
4411 = (struct bfd_link_info *) inf;
4412
351f65ca 4413 return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
c25bc9fc
L		 4414 info, h, NULL);
4415}
4416
c434dee6
AJ		 4417/* Used to decide how to sort relocs in an optimal manner for the
4418 dynamic linker, before writing them out. */
4419
4420static enum elf_reloc_type_class
351f65ca 4421elf_x86_64_reloc_type_class (const Elf_Internal_Rela *rela)
c434dee6 4422{
351f65ca 4423 switch ((int) ELF32_R_TYPE (rela->r_info))
c434dee6
AJ		 4424 {
4425 case R_X86_64_RELATIVE:
4426 return reloc_class_relative;
4427 case R_X86_64_JUMP_SLOT:
4428 return reloc_class_plt;
4429 case R_X86_64_COPY:
4430 return reloc_class_copy;
4431 default:
4432 return reloc_class_normal;
4433 }
4434}
4435
70256ad8
AJ		 4436/* Finish up the dynamic sections. */
4437
b34976b6 4438static bfd_boolean
351f65ca
L		 4439elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
4440 struct bfd_link_info *info)
70256ad8 4441{
351f65ca 4442 struct elf_x86_64_link_hash_table *htab;
70256ad8
AJ		 4443 bfd *dynobj;
4444 asection *sdyn;
70256ad8 4445
351f65ca 4446 htab = elf_x86_64_hash_table (info);
4dfe6ac6
NC		 4447 if (htab == NULL)
4448 return FALSE;
4449
c434dee6 4450 dynobj = htab->elf.dynobj;
70256ad8
AJ		 4451 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4452
c434dee6 4453 if (htab->elf.dynamic_sections_created)
70256ad8 4454 {
82e96e07
L		 4455 bfd_byte *dyncon, *dynconend;
4456 const struct elf_backend_data *bed;
4457 bfd_size_type sizeof_dyn;
70256ad8 4458
6de2ae4a 4459 if (sdyn == NULL || htab->elf.sgot == NULL)
c434dee6 4460 abort ();
70256ad8 4461
82e96e07
L		 4462 bed = get_elf_backend_data (dynobj);
4463 sizeof_dyn = bed->s->sizeof_dyn;
4464 dyncon = sdyn->contents;
4465 dynconend = sdyn->contents + sdyn->size;
4466 for (; dyncon < dynconend; dyncon += sizeof_dyn)
70256ad8
AJ		 4467 {
4468 Elf_Internal_Dyn dyn;
70256ad8
AJ		 4469 asection *s;
4470
82e96e07 4471 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
70256ad8
AJ		 4472
4473 switch (dyn.d_tag)
4474 {
4475 default:
053579d7 4476 continue;
70256ad8
AJ		 4477
4478 case DT_PLTGOT:
6de2ae4a 4479 s = htab->elf.sgotplt;
8c37241b 4480 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
c434dee6 4481 break;
70256ad8
AJ		 4482
4483 case DT_JMPREL:
6de2ae4a 4484 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
c434dee6 4485 break;
70256ad8 4486
c434dee6 4487 case DT_PLTRELSZ:
6de2ae4a 4488 s = htab->elf.srelplt->output_section;
eea6121a 4489 dyn.d_un.d_val = s->size;
70256ad8
AJ		 4490 break;
4491
4492 case DT_RELASZ:
c434dee6
AJ		 4493 /* The procedure linkage table relocs (DT_JMPREL) should
4494 not be included in the overall relocs (DT_RELA).
4495 Therefore, we override the DT_RELASZ entry here to
4496 make it not include the JMPREL relocs. Since the
4497 linker script arranges for .rela.plt to follow all
4498 other relocation sections, we don't have to worry
4499 about changing the DT_RELA entry. */
6de2ae4a 4500 if (htab->elf.srelplt != NULL)
70256ad8 4501 {
6de2ae4a 4502 s = htab->elf.srelplt->output_section;
eea6121a 4503 dyn.d_un.d_val -= s->size;
70256ad8
AJ		 4504 }
4505 break;
67a4f2b7
AO		 4506
4507 case DT_TLSDESC_PLT:
6de2ae4a 4508 s = htab->elf.splt;
67a4f2b7
AO		 4509 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
4510 + htab->tlsdesc_plt;
4511 break;
4512
4513 case DT_TLSDESC_GOT:
6de2ae4a 4514 s = htab->elf.sgot;
67a4f2b7
AO		 4515 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
4516 + htab->tlsdesc_got;
4517 break;
70256ad8 4518 }
c434dee6 4519
82e96e07 4520 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
70256ad8
AJ		 4521 }
4522
c434dee6 4523 /* Fill in the special first entry in the procedure linkage table. */
6de2ae4a 4524 if (htab->elf.splt && htab->elf.splt->size > 0)
70256ad8 4525 {
653165cc 4526 /* Fill in the first entry in the procedure linkage table. */
351f65ca 4527 memcpy (htab->elf.splt->contents, elf_x86_64_plt0_entry,
c434dee6 4528 PLT_ENTRY_SIZE);
653165cc
AJ		 4529 /* Add offset for pushq GOT+8(%rip), since the instruction
4530 uses 6 bytes subtract this value. */
4531 bfd_put_32 (output_bfd,
6de2ae4a
L		 4532 (htab->elf.sgotplt->output_section->vma
4533 + htab->elf.sgotplt->output_offset
653165cc 4534 + 8
6de2ae4a
L		 4535 - htab->elf.splt->output_section->vma
4536 - htab->elf.splt->output_offset
653165cc 4537 - 6),
6de2ae4a 4538 htab->elf.splt->contents + 2);
653165cc
AJ		 4539 /* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
4540 the end of the instruction. */
4541 bfd_put_32 (output_bfd,
6de2ae4a
L		 4542 (htab->elf.sgotplt->output_section->vma
4543 + htab->elf.sgotplt->output_offset
653165cc 4544 + 16
6de2ae4a
L		 4545 - htab->elf.splt->output_section->vma
4546 - htab->elf.splt->output_offset
653165cc 4547 - 12),
6de2ae4a 4548 htab->elf.splt->contents + 8);
653165cc 4549
6de2ae4a 4550 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize =
c434dee6 4551 PLT_ENTRY_SIZE;
67a4f2b7
AO		 4552
4553 if (htab->tlsdesc_plt)
4554 {
4555 bfd_put_64 (output_bfd, (bfd_vma) 0,
6de2ae4a 4556 htab->elf.sgot->contents + htab->tlsdesc_got);
67a4f2b7 4557
6de2ae4a 4558 memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
351f65ca 4559 elf_x86_64_plt0_entry,
67a4f2b7
AO		 4560 PLT_ENTRY_SIZE);
4561
4562 /* Add offset for pushq GOT+8(%rip), since the
4563 instruction uses 6 bytes subtract this value. */
4564 bfd_put_32 (output_bfd,
6de2ae4a
L		 4565 (htab->elf.sgotplt->output_section->vma
4566 + htab->elf.sgotplt->output_offset
67a4f2b7 4567 + 8
6de2ae4a
L		 4568 - htab->elf.splt->output_section->vma
4569 - htab->elf.splt->output_offset
67a4f2b7
AO		 4570 - htab->tlsdesc_plt
4571 - 6),
6de2ae4a 4572 htab->elf.splt->contents + htab->tlsdesc_plt + 2);
67a4f2b7
AO		 4573 /* Add offset for jmp *GOT+TDG(%rip), where TGD stands for
4574 htab->tlsdesc_got. The 12 is the offset to the end of
4575 the instruction. */
4576 bfd_put_32 (output_bfd,
6de2ae4a
L		 4577 (htab->elf.sgot->output_section->vma
4578 + htab->elf.sgot->output_offset
67a4f2b7 4579 + htab->tlsdesc_got
6de2ae4a
L		 4580 - htab->elf.splt->output_section->vma
4581 - htab->elf.splt->output_offset
67a4f2b7
AO		 4582 - htab->tlsdesc_plt
4583 - 12),
6de2ae4a 4584 htab->elf.splt->contents + htab->tlsdesc_plt + 8);
67a4f2b7 4585 }
70256ad8 4586 }
70256ad8
AJ		 4587 }
4588
6de2ae4a 4589 if (htab->elf.sgotplt)
70256ad8 4590 {
56d4289c
L		 4591 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
4592 {
4593 (*_bfd_error_handler)
4594 (_("discarded output section: `%A'"), htab->elf.sgotplt);
4595 return FALSE;
4596 }
4597
c434dee6 4598 /* Fill in the first three entries in the global offset table. */
6de2ae4a 4599 if (htab->elf.sgotplt->size > 0)
c434dee6
AJ		 4600 {
4601 /* Set the first entry in the global offset table to the address of
4602 the dynamic section. */
4603 if (sdyn == NULL)
6de2ae4a 4604 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents);
c434dee6
AJ		 4605 else
4606 bfd_put_64 (output_bfd,
4607 sdyn->output_section->vma + sdyn->output_offset,
6de2ae4a 4608 htab->elf.sgotplt->contents);
c434dee6 4609 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6de2ae4a
L		 4610 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
4611 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2);
c434dee6 4612 }
70256ad8 4613
6de2ae4a 4614 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize =
c434dee6
AJ		 4615 GOT_ENTRY_SIZE;
4616 }
70256ad8 4617
e41b3a13
JJ		 4618 /* Adjust .eh_frame for .plt section. */
4619 if (htab->plt_eh_frame != NULL)
4620 {
4621 if (htab->elf.splt != NULL
4622 && htab->elf.splt->size != 0
4623 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
4624 && htab->elf.splt->output_section != NULL
4625 && htab->plt_eh_frame->output_section != NULL)
4626 {
4627 bfd_vma plt_start = htab->elf.splt->output_section->vma;
4628 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
4629 + htab->plt_eh_frame->output_offset
4630 + PLT_FDE_START_OFFSET;
4631 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
4632 htab->plt_eh_frame->contents
4633 + PLT_FDE_START_OFFSET);
4634 }
4635 if (htab->plt_eh_frame->sec_info_type
4636 == ELF_INFO_TYPE_EH_FRAME)
4637 {
4638 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
4639 htab->plt_eh_frame,
4640 htab->plt_eh_frame->contents))
4641 return FALSE;
4642 }
4643 }
4644
6de2ae4a
L		 4645 if (htab->elf.sgot && htab->elf.sgot->size > 0)
4646 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
8c37241b
JJ		 4647 = GOT_ENTRY_SIZE;
4648
c25bc9fc
L		 4649 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4650 htab_traverse (htab->loc_hash_table,
351f65ca 4651 elf_x86_64_finish_local_dynamic_symbol,
c25bc9fc
L		 4652 info);
4653
b34976b6 4654 return TRUE;
8d88c4ca
NC		 4655}
4656
4c45e5c9
JJ		 4657/* Return address for Ith PLT stub in section PLT, for relocation REL
4658 or (bfd_vma) -1 if it should not be included. */
4659
4660static bfd_vma
351f65ca
L		 4661elf_x86_64_plt_sym_val (bfd_vma i, const asection *plt,
4662 const arelent *rel ATTRIBUTE_UNUSED)
4c45e5c9
JJ		 4663{
4664 return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
4665}
8df9fc9d 4666
d2b2c203
DJ		 4667/* Handle an x86-64 specific section when reading an object file. This
4668 is called when elfcode.h finds a section with an unknown type. */
4669
4670static bfd_boolean
351f65ca 4671elf_x86_64_section_from_shdr (bfd *abfd,
6dc132d9
L		 4672 Elf_Internal_Shdr *hdr,
4673 const char *name,
4674 int shindex)
d2b2c203
DJ		 4675{
4676 if (hdr->sh_type != SHT_X86_64_UNWIND)
4677 return FALSE;
4678
6dc132d9 4679 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
d2b2c203
DJ		 4680 return FALSE;
4681
4682 return TRUE;
4683}
4684
3b22753a
L		 4685/* Hook called by the linker routine which adds symbols from an object
4686 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4687 of .bss. */
4688
4689static bfd_boolean
351f65ca
L		 4690elf_x86_64_add_symbol_hook (bfd *abfd,
4691 struct bfd_link_info *info,
4692 Elf_Internal_Sym *sym,
4693 const char **namep ATTRIBUTE_UNUSED,
4694 flagword *flagsp ATTRIBUTE_UNUSED,
4695 asection **secp,
4696 bfd_vma *valp)
3b22753a
L		 4697{
4698 asection *lcomm;
4699
4700 switch (sym->st_shndx)
4701 {
4702 case SHN_X86_64_LCOMMON:
4703 lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
4704 if (lcomm == NULL)
4705 {
4706 lcomm = bfd_make_section_with_flags (abfd,
4707 "LARGE_COMMON",
4708 (SEC_ALLOC
4709 | SEC_IS_COMMON
4710 | SEC_LINKER_CREATED));
4711 if (lcomm == NULL)
4712 return FALSE;
4713 elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
4714 }
4715 *secp = lcomm;
4716 *valp = sym->st_size;
c35bdf6e 4717 return TRUE;
3b22753a 4718 }
d8045f23 4719
c16153ae 4720 if ((abfd->flags & DYNAMIC) == 0
f64b2e8d
NC		 4721 && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
4722 || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
4723 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
d8045f23 4724
3b22753a
L		 4725 return TRUE;
4726}
4727
4728
4729/* Given a BFD section, try to locate the corresponding ELF section
4730 index. */
4731
4732static bfd_boolean
351f65ca
L		 4733elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
4734 asection *sec, int *index_return)
3b22753a
L		 4735{
4736 if (sec == &_bfd_elf_large_com_section)
4737 {
91d6fa6a 4738 *index_return = SHN_X86_64_LCOMMON;
3b22753a
L		 4739 return TRUE;
4740 }
4741 return FALSE;
4742}
4743
4744/* Process a symbol. */
4745
4746static void
351f65ca
L		 4747elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
4748 asymbol *asym)
3b22753a
L		 4749{
4750 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
4751
4752 switch (elfsym->internal_elf_sym.st_shndx)
4753 {
4754 case SHN_X86_64_LCOMMON:
4755 asym->section = &_bfd_elf_large_com_section;
4756 asym->value = elfsym->internal_elf_sym.st_size;
4757 /* Common symbol doesn't set BSF_GLOBAL. */
4758 asym->flags &= ~BSF_GLOBAL;
4759 break;
4760 }
4761}
4762
4763static bfd_boolean
351f65ca 4764elf_x86_64_common_definition (Elf_Internal_Sym *sym)
3b22753a
L		 4765{
4766 return (sym->st_shndx == SHN_COMMON
4767 || sym->st_shndx == SHN_X86_64_LCOMMON);
4768}
4769
4770static unsigned int
351f65ca 4771elf_x86_64_common_section_index (asection *sec)
3b22753a
L		 4772{
4773 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
4774 return SHN_COMMON;
4775 else
4776 return SHN_X86_64_LCOMMON;
4777}
4778
4779static asection *
351f65ca 4780elf_x86_64_common_section (asection *sec)
3b22753a
L		 4781{
4782 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
4783 return bfd_com_section_ptr;
4784 else
4785 return &_bfd_elf_large_com_section;
4786}
4787
4788static bfd_boolean
351f65ca
L		 4789elf_x86_64_merge_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
4790 struct elf_link_hash_entry **sym_hash ATTRIBUTE_UNUSED,
4791 struct elf_link_hash_entry *h,
4792 Elf_Internal_Sym *sym,
4793 asection **psec,
4794 bfd_vma *pvalue ATTRIBUTE_UNUSED,
4795 unsigned int *pold_alignment ATTRIBUTE_UNUSED,
4796 bfd_boolean *skip ATTRIBUTE_UNUSED,
4797 bfd_boolean *override ATTRIBUTE_UNUSED,
4798 bfd_boolean *type_change_ok ATTRIBUTE_UNUSED,
4799 bfd_boolean *size_change_ok ATTRIBUTE_UNUSED,
71e7aa7d
L		 4800 bfd_boolean *newdyn ATTRIBUTE_UNUSED,
4801 bfd_boolean *newdef,
351f65ca
L		 4802 bfd_boolean *newdyncommon ATTRIBUTE_UNUSED,
4803 bfd_boolean *newweak ATTRIBUTE_UNUSED,
4804 bfd *abfd ATTRIBUTE_UNUSED,
4805 asection **sec,
71e7aa7d
L		 4806 bfd_boolean *olddyn ATTRIBUTE_UNUSED,
4807 bfd_boolean *olddef,
351f65ca
L		 4808 bfd_boolean *olddyncommon ATTRIBUTE_UNUSED,
4809 bfd_boolean *oldweak ATTRIBUTE_UNUSED,
4810 bfd *oldbfd,
4811 asection **oldsec)
3b22753a
L		 4812{
4813 /* A normal common symbol and a large common symbol result in a
00492999
L		 4814 normal common symbol. We turn the large common symbol into a
4815 normal one. */
71e7aa7d 4816 if (!*olddef
3b22753a 4817 && h->root.type == bfd_link_hash_common
71e7aa7d 4818 && !*newdef
3b22753a 4819 && bfd_is_com_section (*sec)
00492999 4820 && *oldsec != *sec)
3b22753a 4821 {
00492999
L		 4822 if (sym->st_shndx == SHN_COMMON
4823 && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) != 0)
4824 {
4825 h->root.u.c.p->section
4826 = bfd_make_section_old_way (oldbfd, "COMMON");
4827 h->root.u.c.p->section->flags = SEC_ALLOC;
4828 }
4829 else if (sym->st_shndx == SHN_X86_64_LCOMMON
4830 && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) == 0)
9a2e389a 4831 *psec = *sec = bfd_com_section_ptr;
3b22753a
L		 4832 }
4833
4834 return TRUE;
4835}
4836
4837static int
351f65ca
L		 4838elf_x86_64_additional_program_headers (bfd *abfd,
4839 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3b22753a
L		 4840{
4841 asection *s;
9a2e389a 4842 int count = 0;
3b22753a
L		 4843
4844 /* Check to see if we need a large readonly segment. */
4845 s = bfd_get_section_by_name (abfd, ".lrodata");
4846 if (s && (s->flags & SEC_LOAD))
4847 count++;
4848
4849 /* Check to see if we need a large data segment. Since .lbss sections
4850 is placed right after the .bss section, there should be no need for
4851 a large data segment just because of .lbss. */
4852 s = bfd_get_section_by_name (abfd, ".ldata");
4853 if (s && (s->flags & SEC_LOAD))
4854 count++;
4855
4856 return count;
4857}
4858
fdc90cb4
JJ		 4859/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
4860
4861static bfd_boolean
351f65ca 4862elf_x86_64_hash_symbol (struct elf_link_hash_entry *h)
fdc90cb4
JJ		 4863{
4864 if (h->plt.offset != (bfd_vma) -1
4865 && !h->def_regular
4866 && !h->pointer_equality_needed)
4867 return FALSE;
4868
4869 return _bfd_elf_hash_symbol (h);
4870}
4871
c543bf9a
L		 4872/* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
4873
4874static bfd_boolean
4875elf_x86_64_relocs_compatible (const bfd_target *input,
4876 const bfd_target *output)
4877{
4878 return ((xvec_get_elf_backend_data (input)->s->elfclass
4879 == xvec_get_elf_backend_data (output)->s->elfclass)
4880 && _bfd_elf_relocs_compatible (input, output));
4881}
4882
9a2e389a 4883static const struct bfd_elf_special_section
351f65ca 4884 elf_x86_64_special_sections[]=
3b22753a 4885{
0112cd26
NC		 4886 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4887 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
4888 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
4889 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4890 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4891 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
4892 { NULL, 0, 0, 0, 0 }
3b22753a
L		 4893};
4894
70256ad8
AJ		 4895#define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
4896#define TARGET_LITTLE_NAME "elf64-x86-64"
4897#define ELF_ARCH bfd_arch_i386
ae95ffa6 4898#define ELF_TARGET_ID X86_64_ELF_DATA
70256ad8 4899#define ELF_MACHINE_CODE EM_X86_64
f7661549 4900#define ELF_MAXPAGESIZE 0x200000
2043964e 4901#define ELF_MINPAGESIZE 0x1000
24718e3b 4902#define ELF_COMMONPAGESIZE 0x1000
70256ad8
AJ		 4903
4904#define elf_backend_can_gc_sections 1
51b64d56 4905#define elf_backend_can_refcount 1
70256ad8
AJ		 4906#define elf_backend_want_got_plt 1
4907#define elf_backend_plt_readonly 1
4908#define elf_backend_want_plt_sym 0
4909#define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
b491616a 4910#define elf_backend_rela_normal 1
e41b3a13 4911#define elf_backend_plt_alignment 4
70256ad8 4912
351f65ca 4913#define elf_info_to_howto elf_x86_64_info_to_howto
70256ad8 4914
70256ad8 4915#define bfd_elf64_bfd_link_hash_table_create \
351f65ca 4916 elf_x86_64_link_hash_table_create
c25bc9fc 4917#define bfd_elf64_bfd_link_hash_table_free \
351f65ca
L		 4918 elf_x86_64_link_hash_table_free
4919#define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
157090f7 4920#define bfd_elf64_bfd_reloc_name_lookup \
351f65ca 4921 elf_x86_64_reloc_name_lookup
70256ad8 4922
351f65ca 4923#define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
c543bf9a 4924#define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
351f65ca
L		 4925#define elf_backend_check_relocs elf_x86_64_check_relocs
4926#define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
4927#define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
4928#define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
4929#define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
4930#define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
4931#define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
4932#define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
4933#define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
8fd79e71
L		 4934#ifdef CORE_HEADER
4935#define elf_backend_write_core_note elf_x86_64_write_core_note
4936#endif
351f65ca
L		 4937#define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
4938#define elf_backend_relocate_section elf_x86_64_relocate_section
4939#define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
4940#define elf_backend_always_size_sections elf_x86_64_always_size_sections
74541ad4 4941#define elf_backend_init_index_section _bfd_elf_init_1_index_section
351f65ca 4942#define elf_backend_plt_sym_val elf_x86_64_plt_sym_val
407443a3 4943#define elf_backend_object_p elf64_x86_64_elf_object_p
351f65ca 4944#define bfd_elf64_mkobject elf_x86_64_mkobject
8d88c4ca 4945
d2b2c203 4946#define elf_backend_section_from_shdr \
351f65ca 4947 elf_x86_64_section_from_shdr
d2b2c203 4948
3b22753a 4949#define elf_backend_section_from_bfd_section \
351f65ca 4950 elf_x86_64_elf_section_from_bfd_section
3b22753a 4951#define elf_backend_add_symbol_hook \
351f65ca 4952 elf_x86_64_add_symbol_hook
3b22753a 4953#define elf_backend_symbol_processing \
351f65ca 4954 elf_x86_64_symbol_processing
3b22753a 4955#define elf_backend_common_section_index \
351f65ca 4956 elf_x86_64_common_section_index
3b22753a 4957#define elf_backend_common_section \
351f65ca 4958 elf_x86_64_common_section
3b22753a 4959#define elf_backend_common_definition \
351f65ca 4960 elf_x86_64_common_definition
3b22753a 4961#define elf_backend_merge_symbol \
351f65ca 4962 elf_x86_64_merge_symbol
3b22753a 4963#define elf_backend_special_sections \
351f65ca 4964 elf_x86_64_special_sections
3b22753a 4965#define elf_backend_additional_program_headers \
351f65ca 4966 elf_x86_64_additional_program_headers
fdc90cb4 4967#define elf_backend_hash_symbol \
351f65ca 4968 elf_x86_64_hash_symbol
3b22753a 4969
d8045f23
NC		 4970#define elf_backend_post_process_headers _bfd_elf_set_osabi
4971
8d88c4ca 4972#include "elf64-target.h"
9d7cbccd
NC		 4973
4974/* FreeBSD support. */
4975
4976#undef TARGET_LITTLE_SYM
4977#define TARGET_LITTLE_SYM bfd_elf64_x86_64_freebsd_vec
4978#undef TARGET_LITTLE_NAME
4979#define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
4980
d1036acb
L		 4981#undef ELF_OSABI
4982#define ELF_OSABI ELFOSABI_FREEBSD
9d7cbccd 4983
9d7cbccd
NC		 4984#undef elf64_bed
4985#define elf64_bed elf64_x86_64_fbsd_bed
4986
4987#include "elf64-target.h"
8a9036a4 4988
a6cc6b3b
RO		 4989/* Solaris 2 support. */
4990
4991#undef TARGET_LITTLE_SYM
4992#define TARGET_LITTLE_SYM bfd_elf64_x86_64_sol2_vec
4993#undef TARGET_LITTLE_NAME
4994#define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
4995
4996/* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
4997 objects won't be recognized. */
4998#undef ELF_OSABI
4999
5000#undef elf64_bed
5001#define elf64_bed elf64_x86_64_sol2_bed
5002
7dc98aea
RO		 5003/* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5004 boundary. */
5005#undef elf_backend_static_tls_alignment
5006#define elf_backend_static_tls_alignment 16
5007
a6cc6b3b
RO		 5008/* The Solaris 2 ABI requires a plt symbol on all platforms.
5009
5010 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5011 File, p.63. */
5012#undef elf_backend_want_plt_sym
5013#define elf_backend_want_plt_sym 1
5014
5015#include "elf64-target.h"
5016
8a9036a4
L		 5017/* Intel L1OM support. */
5018
5019static bfd_boolean
5020elf64_l1om_elf_object_p (bfd *abfd)
5021{
5022 /* Set the right machine number for an L1OM elf64 file. */
5023 bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
5024 return TRUE;
5025}
5026
5027#undef TARGET_LITTLE_SYM
5028#define TARGET_LITTLE_SYM bfd_elf64_l1om_vec
5029#undef TARGET_LITTLE_NAME
5030#define TARGET_LITTLE_NAME "elf64-l1om"
5031#undef ELF_ARCH
5032#define ELF_ARCH bfd_arch_l1om
5033
5034#undef ELF_MACHINE_CODE
5035#define ELF_MACHINE_CODE EM_L1OM
5036
5037#undef ELF_OSABI
5038
5039#undef elf64_bed
5040#define elf64_bed elf64_l1om_bed
5041
5042#undef elf_backend_object_p
5043#define elf_backend_object_p elf64_l1om_elf_object_p
5044
7dc98aea 5045#undef elf_backend_static_tls_alignment
8a9036a4 5046
1a0c107f
L		 5047#undef elf_backend_want_plt_sym
5048#define elf_backend_want_plt_sym 0
5049
8a9036a4
L		 5050#include "elf64-target.h"
5051
5052/* FreeBSD L1OM support. */
5053
5054#undef TARGET_LITTLE_SYM
5055#define TARGET_LITTLE_SYM bfd_elf64_l1om_freebsd_vec
5056#undef TARGET_LITTLE_NAME
5057#define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
5058
5059#undef ELF_OSABI
5060#define ELF_OSABI ELFOSABI_FREEBSD
5061
5062#undef elf64_bed
5063#define elf64_bed elf64_l1om_fbsd_bed
5064
8a9036a4 5065#include "elf64-target.h"
351f65ca 5066
7a9068fe
L		 5067/* Intel K1OM support. */
5068
5069static bfd_boolean
5070elf64_k1om_elf_object_p (bfd *abfd)
5071{
5072 /* Set the right machine number for an K1OM elf64 file. */
5073 bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
5074 return TRUE;
5075}
5076
5077#undef TARGET_LITTLE_SYM
5078#define TARGET_LITTLE_SYM bfd_elf64_k1om_vec
5079#undef TARGET_LITTLE_NAME
5080#define TARGET_LITTLE_NAME "elf64-k1om"
5081#undef ELF_ARCH
5082#define ELF_ARCH bfd_arch_k1om
5083
5084#undef ELF_MACHINE_CODE
5085#define ELF_MACHINE_CODE EM_K1OM
5086
5087#undef ELF_OSABI
5088
5089#undef elf64_bed
5090#define elf64_bed elf64_k1om_bed
5091
5092#undef elf_backend_object_p
5093#define elf_backend_object_p elf64_k1om_elf_object_p
5094
5095#undef elf_backend_static_tls_alignment
5096
5097#undef elf_backend_want_plt_sym
5098#define elf_backend_want_plt_sym 0
5099
5100#include "elf64-target.h"
5101
5102/* FreeBSD K1OM support. */
5103
5104#undef TARGET_LITTLE_SYM
5105#define TARGET_LITTLE_SYM bfd_elf64_k1om_freebsd_vec
5106#undef TARGET_LITTLE_NAME
5107#define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
5108
5109#undef ELF_OSABI
5110#define ELF_OSABI ELFOSABI_FREEBSD
5111
5112#undef elf64_bed
5113#define elf64_bed elf64_k1om_fbsd_bed
5114
5115#include "elf64-target.h"
5116
351f65ca
L		 5117/* 32bit x86-64 support. */
5118
5119static bfd_boolean
5120elf32_x86_64_elf_object_p (bfd *abfd)
5121{
5122 /* Set the right machine number for an x86-64 elf32 file. */
5123 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32);
5124 return TRUE;
5125}
5126
5127#undef TARGET_LITTLE_SYM
5128#define TARGET_LITTLE_SYM bfd_elf32_x86_64_vec
5129#undef TARGET_LITTLE_NAME
5130#define TARGET_LITTLE_NAME "elf32-x86-64"
5131
5132#undef ELF_ARCH
5133#define ELF_ARCH bfd_arch_i386
5134
5135#undef ELF_MACHINE_CODE
5136#define ELF_MACHINE_CODE EM_X86_64
5137
5138#define bfd_elf32_bfd_link_hash_table_create \
5139 elf_x86_64_link_hash_table_create
5140#define bfd_elf32_bfd_link_hash_table_free \
5141 elf_x86_64_link_hash_table_free
5142#define bfd_elf32_bfd_reloc_type_lookup \
5143 elf_x86_64_reloc_type_lookup
5144#define bfd_elf32_bfd_reloc_name_lookup \
5145 elf_x86_64_reloc_name_lookup
5146#define bfd_elf32_mkobject \
5147 elf_x86_64_mkobject
5148
5149#undef ELF_OSABI
5150
351f65ca
L		 5151#undef elf_backend_object_p
5152#define elf_backend_object_p \
5153 elf32_x86_64_elf_object_p
5154
5155#undef elf_backend_bfd_from_remote_memory
5156#define elf_backend_bfd_from_remote_memory \
5157 _bfd_elf32_bfd_from_remote_memory
5158
5159#undef elf_backend_size_info
5160#define elf_backend_size_info \
5161 _bfd_elf32_size_info
5162
5163#include "elf32-target.h"
A mirror of the official binutils-gdb repository