projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
AArch64: Add target description/feature for MTE registers
[deliverable/binutils-gdb.git] / gdb / aarch64-linux-tdep.c
CommitLineData
1ae3db19
MS		 1/* Target-dependent code for GNU/Linux AArch64.
2
3666a048 3 Copyright (C) 2009-2021 Free Software Foundation, Inc.
1ae3db19
MS		 4 Contributed by ARM Ltd.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21#include "defs.h"
22
d55e5aa6 23#include "gdbarch.h"
1ae3db19
MS		 24#include "glibc-tdep.h"
25#include "linux-tdep.h"
4de283e4
TT		 26#include "aarch64-tdep.h"
27#include "aarch64-linux-tdep.h"
1ae3db19 28#include "osabi.h"
d55e5aa6 29#include "solib-svr4.h"
d55e5aa6 30#include "symtab.h"
d55e5aa6 31#include "tramp-frame.h"
4de283e4 32#include "trad-frame.h"
be155ebb 33#include "target/target.h"
4c5e7a93 34#include "expop.h"
4de283e4 35
4de283e4
TT		 36#include "regcache.h"
37#include "regset.h"
38
4de283e4
TT		 39#include "stap-probe.h"
40#include "parser-defs.h"
08248ca9 41#include "user-regs.h"
f68f11b7 42#include "xml-syscall.h"
4de283e4
TT		 43#include <ctype.h>
44
45#include "record-full.h"
46#include "linux-record.h"
99afc88b 47
04245125
LM		 48#include "arch/aarch64-mte-linux.h"
49
1ae3db19
MS		 50/* Signal frame handling.
51
f2205de0
HZ		 52 +------------+ ^
53 | saved lr | |
54 +->| saved fp |--+
55 | | |
56 | | |
57 | +------------+
58 | | saved lr |
59 +--| saved fp |
60 ^ | |
61 | | |
62 | +------------+
63 ^ | |
64 | | signal |
65 | | | SIGTRAMP_FRAME (struct rt_sigframe)
66 | | saved regs |
67 +--| saved sp |--> interrupted_sp
68 | | saved pc |--> interrupted_pc
69 | | |
70 | +------------+
71 | | saved lr |--> default_restorer (movz x8, NR_sys_rt_sigreturn; svc 0)
72 +--| saved fp |<- FP
73 | | NORMAL_FRAME
74 | |<- SP
75 +------------+
1ae3db19
MS		 76
77 On signal delivery, the kernel will create a signal handler stack
78 frame and setup the return address in LR to point at restorer stub.
79 The signal stack frame is defined by:
80
81 struct rt_sigframe
82 {
83 siginfo_t info;
84 struct ucontext uc;
85 };
86
1ae3db19
MS		 87 The ucontext has the following form:
88 struct ucontext
89 {
90 unsigned long uc_flags;
91 struct ucontext *uc_link;
92 stack_t uc_stack;
93 sigset_t uc_sigmask;
94 struct sigcontext uc_mcontext;
95 };
96
1ae3db19
MS		 97 struct sigcontext
98 {
99 unsigned long fault_address;
100 unsigned long regs[31];
101 unsigned long sp; / * 31 * /
102 unsigned long pc; / * 32 * /
103 unsigned long pstate; / * 33 * /
104 __u8 __reserved[4096]
105 };
106
05c71722
AH		 107 The reserved space in sigcontext contains additional structures, each starting
108 with a aarch64_ctx, which specifies a unique identifier and the total size of
109 the structure. The final structure in reserved will start will a null
110 aarch64_ctx. The penultimate entry in reserved may be a extra_context which
111 then points to a further block of reserved space.
112
113 struct aarch64_ctx {
114 u32 magic;
115 u32 size;
116 };
117
1ae3db19
MS		 118 The restorer stub will always have the form:
119
120 d28015a8 movz x8, #0xad
121 d4000001 svc #0x0
122
f2205de0
HZ		 123 This is a system call sys_rt_sigreturn.
124
1ae3db19
MS		 125 We detect signal frames by snooping the return code for the restorer
126 instruction sequence.
127
128 The handler then needs to recover the saved register set from
129 ucontext.uc_mcontext. */
130
131/* These magic numbers need to reflect the layout of the kernel
132 defined struct rt_sigframe and ucontext. */
133#define AARCH64_SIGCONTEXT_REG_SIZE 8
134#define AARCH64_RT_SIGFRAME_UCONTEXT_OFFSET 128
135#define AARCH64_UCONTEXT_SIGCONTEXT_OFFSET 176
136#define AARCH64_SIGCONTEXT_XO_OFFSET 8
05c71722
AH		 137#define AARCH64_SIGCONTEXT_RESERVED_OFFSET 288
138
74b3c713
AH		 139#define AARCH64_SIGCONTEXT_RESERVED_SIZE 4096
140
05c71722
AH		 141/* Unique identifiers that may be used for aarch64_ctx.magic. */
142#define AARCH64_EXTRA_MAGIC 0x45585401
143#define AARCH64_FPSIMD_MAGIC 0x46508001
144#define AARCH64_SVE_MAGIC 0x53564501
145
146/* Defines for the extra_context that follows an AARCH64_EXTRA_MAGIC. */
147#define AARCH64_EXTRA_DATAP_OFFSET 8
148
149/* Defines for the fpsimd that follows an AARCH64_FPSIMD_MAGIC. */
150#define AARCH64_FPSIMD_FPSR_OFFSET 8
151#define AARCH64_FPSIMD_FPCR_OFFSET 12
152#define AARCH64_FPSIMD_V0_OFFSET 16
153#define AARCH64_FPSIMD_VREG_SIZE 16
154
155/* Defines for the sve structure that follows an AARCH64_SVE_MAGIC. */
156#define AARCH64_SVE_CONTEXT_VL_OFFSET 8
157#define AARCH64_SVE_CONTEXT_REGS_OFFSET 16
158#define AARCH64_SVE_CONTEXT_P_REGS_OFFSET(vq) (32 * vq * 16)
159#define AARCH64_SVE_CONTEXT_FFR_OFFSET(vq) \
160 (AARCH64_SVE_CONTEXT_P_REGS_OFFSET (vq) + (16 * vq * 2))
161#define AARCH64_SVE_CONTEXT_SIZE(vq) \
162 (AARCH64_SVE_CONTEXT_FFR_OFFSET (vq) + (vq * 2))
163
164
165/* Read an aarch64_ctx, returning the magic value, and setting *SIZE to the
166 size, or return 0 on error. */
167
168static uint32_t
169read_aarch64_ctx (CORE_ADDR ctx_addr, enum bfd_endian byte_order,
170 uint32_t *size)
171{
172 uint32_t magic = 0;
173 gdb_byte buf[4];
174
175 if (target_read_memory (ctx_addr, buf, 4) != 0)
176 return 0;
177 magic = extract_unsigned_integer (buf, 4, byte_order);
178
179 if (target_read_memory (ctx_addr + 4, buf, 4) != 0)
180 return 0;
181 *size = extract_unsigned_integer (buf, 4, byte_order);
182
183 return magic;
184}
1ae3db19 185
6afcd2d4
LM		 186/* Given CACHE, use the trad_frame* functions to restore the FPSIMD
187 registers from a signal frame.
188
189 VREG_NUM is the number of the V register being restored, OFFSET is the
190 address containing the register value, BYTE_ORDER is the endianness and
191 HAS_SVE tells us if we have a valid SVE context or not. */
192
193static void
194aarch64_linux_restore_vreg (struct trad_frame_cache *cache, int num_regs,
195 int vreg_num, CORE_ADDR offset,
196 enum bfd_endian byte_order, bool has_sve)
197{
198 /* WARNING: SIMD state is laid out in memory in target-endian format.
199
200 So we have a couple cases to consider:
201
202 1 - If the target is big endian, then SIMD state is big endian,
203 requiring a byteswap.
204
205 2 - If the target is little endian, then SIMD state is little endian, so
206 no byteswap is needed. */
207
208 if (byte_order == BFD_ENDIAN_BIG)
209 {
210 gdb_byte buf[V_REGISTER_SIZE];
211
212 if (target_read_memory (offset, buf, V_REGISTER_SIZE) != 0)
213 {
214 size_t size = V_REGISTER_SIZE/2;
215
216 /* Read the two halves of the V register in reverse byte order. */
217 CORE_ADDR u64 = extract_unsigned_integer (buf, size,
218 byte_order);
219 CORE_ADDR l64 = extract_unsigned_integer (buf + size, size,
220 byte_order);
221
222 /* Copy the reversed bytes to the buffer. */
223 store_unsigned_integer (buf, size, BFD_ENDIAN_LITTLE, l64);
224 store_unsigned_integer (buf + size , size, BFD_ENDIAN_LITTLE, u64);
225
226 /* Now we can store the correct bytes for the V register. */
227 trad_frame_set_reg_value_bytes (cache, AARCH64_V0_REGNUM + vreg_num,
ccbe4c82 228 {buf, V_REGISTER_SIZE});
6afcd2d4
LM		 229 trad_frame_set_reg_value_bytes (cache,
230 num_regs + AARCH64_Q0_REGNUM
ccbe4c82 231 + vreg_num, {buf, Q_REGISTER_SIZE});
6afcd2d4
LM		 232 trad_frame_set_reg_value_bytes (cache,
233 num_regs + AARCH64_D0_REGNUM
ccbe4c82 234 + vreg_num, {buf, D_REGISTER_SIZE});
6afcd2d4
LM		 235 trad_frame_set_reg_value_bytes (cache,
236 num_regs + AARCH64_S0_REGNUM
ccbe4c82 237 + vreg_num, {buf, S_REGISTER_SIZE});
6afcd2d4
LM		 238 trad_frame_set_reg_value_bytes (cache,
239 num_regs + AARCH64_H0_REGNUM
ccbe4c82 240 + vreg_num, {buf, H_REGISTER_SIZE});
6afcd2d4
LM		 241 trad_frame_set_reg_value_bytes (cache,
242 num_regs + AARCH64_B0_REGNUM
ccbe4c82 243 + vreg_num, {buf, B_REGISTER_SIZE});
6afcd2d4
LM		 244
245 if (has_sve)
246 trad_frame_set_reg_value_bytes (cache,
247 num_regs + AARCH64_SVE_V0_REGNUM
ccbe4c82 248 + vreg_num, {buf, V_REGISTER_SIZE});
6afcd2d4
LM		 249 }
250 return;
251 }
252
253 /* Little endian, just point at the address containing the register
254 value. */
255 trad_frame_set_reg_addr (cache, AARCH64_V0_REGNUM + vreg_num, offset);
256 trad_frame_set_reg_addr (cache, num_regs + AARCH64_Q0_REGNUM + vreg_num,
257 offset);
258 trad_frame_set_reg_addr (cache, num_regs + AARCH64_D0_REGNUM + vreg_num,
259 offset);
260 trad_frame_set_reg_addr (cache, num_regs + AARCH64_S0_REGNUM + vreg_num,
261 offset);
262 trad_frame_set_reg_addr (cache, num_regs + AARCH64_H0_REGNUM + vreg_num,
263 offset);
264 trad_frame_set_reg_addr (cache, num_regs + AARCH64_B0_REGNUM + vreg_num,
265 offset);
266
267 if (has_sve)
268 trad_frame_set_reg_addr (cache, num_regs + AARCH64_SVE_V0_REGNUM
269 + vreg_num, offset);
270
271}
272
1ae3db19
MS		 273/* Implement the "init" method of struct tramp_frame. */
274
275static void
276aarch64_linux_sigframe_init (const struct tramp_frame *self,
277 struct frame_info *this_frame,
278 struct trad_frame_cache *this_cache,
279 CORE_ADDR func)
280{
05c71722
AH		 281 struct gdbarch *gdbarch = get_frame_arch (this_frame);
282 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
283 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1ae3db19 284 CORE_ADDR sp = get_frame_register_unsigned (this_frame, AARCH64_SP_REGNUM);
05c71722
AH		 285 CORE_ADDR sigcontext_addr = (sp + AARCH64_RT_SIGFRAME_UCONTEXT_OFFSET
286 + AARCH64_UCONTEXT_SIGCONTEXT_OFFSET );
287 CORE_ADDR section = sigcontext_addr + AARCH64_SIGCONTEXT_RESERVED_OFFSET;
74b3c713 288 CORE_ADDR section_end = section + AARCH64_SIGCONTEXT_RESERVED_SIZE;
05c71722
AH		 289 CORE_ADDR fpsimd = 0;
290 CORE_ADDR sve_regs = 0;
291 uint32_t size, magic;
74b3c713 292 bool extra_found = false;
05c71722
AH		 293 int num_regs = gdbarch_num_regs (gdbarch);
294
295 /* Read in the integer registers. */
1ae3db19 296
05c71722 297 for (int i = 0; i < 31; i++)
1ae3db19
MS		 298 {
299 trad_frame_set_reg_addr (this_cache,
300 AARCH64_X0_REGNUM + i,
301 sigcontext_addr + AARCH64_SIGCONTEXT_XO_OFFSET
05c71722 302 + i * AARCH64_SIGCONTEXT_REG_SIZE);
1ae3db19 303 }
f2205de0
HZ		 304 trad_frame_set_reg_addr (this_cache, AARCH64_SP_REGNUM,
305 sigcontext_addr + AARCH64_SIGCONTEXT_XO_OFFSET
306 + 31 * AARCH64_SIGCONTEXT_REG_SIZE);
307 trad_frame_set_reg_addr (this_cache, AARCH64_PC_REGNUM,
308 sigcontext_addr + AARCH64_SIGCONTEXT_XO_OFFSET
309 + 32 * AARCH64_SIGCONTEXT_REG_SIZE);
310
74b3c713
AH		 311 /* Search for the FP and SVE sections, stopping at null. */
312 while ((magic = read_aarch64_ctx (section, byte_order, &size)) != 0
313 && size != 0)
05c71722
AH		 314 {
315 switch (magic)
316 {
317 case AARCH64_FPSIMD_MAGIC:
318 fpsimd = section;
319 section += size;
320 break;
321
322 case AARCH64_SVE_MAGIC:
323 {
324 /* Check if the section is followed by a full SVE dump, and set
325 sve_regs if it is. */
326 gdb_byte buf[4];
327 uint16_t vq;
328
329 if (!tdep->has_sve ())
330 break;
331
332 if (target_read_memory (section + AARCH64_SVE_CONTEXT_VL_OFFSET,
333 buf, 2) != 0)
334 {
335 section += size;
336 break;
337 }
338 vq = sve_vq_from_vl (extract_unsigned_integer (buf, 2, byte_order));
339
340 if (vq != tdep->vq)
2398abf8
TT		 341 error (_("Invalid vector length in signal frame %d vs %s."), vq,
342 pulongest (tdep->vq));
05c71722
AH		 343
344 if (size >= AARCH64_SVE_CONTEXT_SIZE (vq))
345 sve_regs = section + AARCH64_SVE_CONTEXT_REGS_OFFSET;
346
347 section += size;
348 break;
349 }
350
351 case AARCH64_EXTRA_MAGIC:
352 {
353 /* Extra is always the last valid section in reserved and points to
354 an additional block of memory filled with more sections. Reset
355 the address to the extra section and continue looking for more
356 structures. */
357 gdb_byte buf[8];
358
359 if (target_read_memory (section + AARCH64_EXTRA_DATAP_OFFSET,
360 buf, 8) != 0)
361 {
362 section += size;
363 break;
364 }
365
366 section = extract_unsigned_integer (buf, 8, byte_order);
74b3c713 367 extra_found = true;
05c71722
AH		 368 break;
369 }
370
371 default:
74b3c713 372 section += size;
05c71722
AH		 373 break;
374 }
74b3c713
AH		 375
376 /* Prevent searching past the end of the reserved section. The extra
377 section does not have a hard coded limit - we have to rely on it ending
378 with nulls. */
379 if (!extra_found && section > section_end)
380 break;
05c71722
AH		 381 }
382
383 if (sve_regs != 0)
384 {
385 CORE_ADDR offset;
386
387 for (int i = 0; i < 32; i++)
388 {
389 offset = sve_regs + (i * tdep->vq * 16);
390 trad_frame_set_reg_addr (this_cache, AARCH64_SVE_Z0_REGNUM + i,
391 offset);
392 trad_frame_set_reg_addr (this_cache,
393 num_regs + AARCH64_SVE_V0_REGNUM + i,
394 offset);
395 trad_frame_set_reg_addr (this_cache, num_regs + AARCH64_Q0_REGNUM + i,
396 offset);
397 trad_frame_set_reg_addr (this_cache, num_regs + AARCH64_D0_REGNUM + i,
398 offset);
399 trad_frame_set_reg_addr (this_cache, num_regs + AARCH64_S0_REGNUM + i,
400 offset);
401 trad_frame_set_reg_addr (this_cache, num_regs + AARCH64_H0_REGNUM + i,
402 offset);
403 trad_frame_set_reg_addr (this_cache, num_regs + AARCH64_B0_REGNUM + i,
404 offset);
405 }
406
407 offset = sve_regs + AARCH64_SVE_CONTEXT_P_REGS_OFFSET (tdep->vq);
408 for (int i = 0; i < 16; i++)
409 trad_frame_set_reg_addr (this_cache, AARCH64_SVE_P0_REGNUM + i,
410 offset + (i * tdep->vq * 2));
411
412 offset = sve_regs + AARCH64_SVE_CONTEXT_FFR_OFFSET (tdep->vq);
413 trad_frame_set_reg_addr (this_cache, AARCH64_SVE_FFR_REGNUM, offset);
414 }
415
416 if (fpsimd != 0)
417 {
418 trad_frame_set_reg_addr (this_cache, AARCH64_FPSR_REGNUM,
419 fpsimd + AARCH64_FPSIMD_FPSR_OFFSET);
420 trad_frame_set_reg_addr (this_cache, AARCH64_FPCR_REGNUM,
421 fpsimd + AARCH64_FPSIMD_FPCR_OFFSET);
422
423 /* If there was no SVE section then set up the V registers. */
424 if (sve_regs == 0)
6afcd2d4
LM		 425 {
426 for (int i = 0; i < 32; i++)
427 {
428 CORE_ADDR offset = (fpsimd + AARCH64_FPSIMD_V0_OFFSET
05c71722
AH		 429 + (i * AARCH64_FPSIMD_VREG_SIZE));
430
6afcd2d4
LM		 431 aarch64_linux_restore_vreg (this_cache, num_regs, i, offset,
432 byte_order, tdep->has_sve ());
433 }
434 }
05c71722
AH		 435 }
436
f2205de0 437 trad_frame_set_id (this_cache, frame_id_build (sp, func));
1ae3db19
MS		 438}
439
440static const struct tramp_frame aarch64_linux_rt_sigframe =
441{
442 SIGTRAMP_FRAME,
443 4,
444 {
445 /* movz x8, 0x8b (S=1,o=10,h=0,i=0x8b,r=8)
446 Soo1 0010 1hhi iiii iiii iiii iiir rrrr */
7bc02706 447 {0xd2801168, ULONGEST_MAX},
1ae3db19
MS		 448
449 /* svc 0x0 (o=0, l=1)
450 1101 0100 oooi iiii iiii iiii iii0 00ll */
7bc02706
TT		 451 {0xd4000001, ULONGEST_MAX},
452 {TRAMP_SENTINEL_INSN, ULONGEST_MAX}
1ae3db19
MS		 453 },
454 aarch64_linux_sigframe_init
455};
456
d4d793bf 457/* Register maps. */
1ae3db19 458
d4d793bf
AA		 459static const struct regcache_map_entry aarch64_linux_gregmap[] =
460 {
461 { 31, AARCH64_X0_REGNUM, 8 }, /* x0 ... x30 */
462 { 1, AARCH64_SP_REGNUM, 8 },
463 { 1, AARCH64_PC_REGNUM, 8 },
464 { 1, AARCH64_CPSR_REGNUM, 8 },
465 { 0 }
466 };
1ae3db19 467
d4d793bf
AA		 468static const struct regcache_map_entry aarch64_linux_fpregmap[] =
469 {
470 { 32, AARCH64_V0_REGNUM, 16 }, /* v0 ... v31 */
471 { 1, AARCH64_FPSR_REGNUM, 4 },
472 { 1, AARCH64_FPCR_REGNUM, 4 },
473 { 0 }
474 };
1ae3db19 475
d4d793bf 476/* Register set definitions. */
a069a2bd 477
d4d793bf 478const struct regset aarch64_linux_gregset =
a069a2bd 479 {
d4d793bf
AA		 480 aarch64_linux_gregmap,
481 regcache_supply_regset, regcache_collect_regset
a069a2bd
AA		 482 };
483
d4d793bf 484const struct regset aarch64_linux_fpregset =
a069a2bd 485 {
d4d793bf
AA		 486 aarch64_linux_fpregmap,
487 regcache_supply_regset, regcache_collect_regset
a069a2bd
AA		 488 };
489
b7fd65b9
AH		 490/* The fields in an SVE header at the start of a SVE regset. */
491
492#define SVE_HEADER_SIZE_LENGTH 4
493#define SVE_HEADER_MAX_SIZE_LENGTH 4
494#define SVE_HEADER_VL_LENGTH 2
495#define SVE_HEADER_MAX_VL_LENGTH 2
496#define SVE_HEADER_FLAGS_LENGTH 2
497#define SVE_HEADER_RESERVED_LENGTH 2
498
499#define SVE_HEADER_SIZE_OFFSET 0
500#define SVE_HEADER_MAX_SIZE_OFFSET \
501 (SVE_HEADER_SIZE_OFFSET + SVE_HEADER_SIZE_LENGTH)
502#define SVE_HEADER_VL_OFFSET \
503 (SVE_HEADER_MAX_SIZE_OFFSET + SVE_HEADER_MAX_SIZE_LENGTH)
504#define SVE_HEADER_MAX_VL_OFFSET \
505 (SVE_HEADER_VL_OFFSET + SVE_HEADER_VL_LENGTH)
506#define SVE_HEADER_FLAGS_OFFSET \
507 (SVE_HEADER_MAX_VL_OFFSET + SVE_HEADER_MAX_VL_LENGTH)
508#define SVE_HEADER_RESERVED_OFFSET \
509 (SVE_HEADER_FLAGS_OFFSET + SVE_HEADER_FLAGS_LENGTH)
510#define SVE_HEADER_SIZE \
511 (SVE_HEADER_RESERVED_OFFSET + SVE_HEADER_RESERVED_LENGTH)
512
0c76e06d
AH		 513#define SVE_HEADER_FLAG_SVE 1
514
b7fd65b9
AH		 515/* Get VQ value from SVE section in the core dump. */
516
517static uint64_t
518aarch64_linux_core_read_vq (struct gdbarch *gdbarch, bfd *abfd)
519{
520 gdb_byte header[SVE_HEADER_SIZE];
521 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
522 asection *sve_section = bfd_get_section_by_name (abfd, ".reg-aarch-sve");
523
524 if (sve_section == nullptr)
525 {
526 /* No SVE state. */
527 return 0;
528 }
529
fd361982 530 size_t size = bfd_section_size (sve_section);
b7fd65b9
AH		 531
532 /* Check extended state size. */
533 if (size < SVE_HEADER_SIZE)
534 {
535 warning (_("'.reg-aarch-sve' section in core file too small."));
536 return 0;
537 }
538
539 if (!bfd_get_section_contents (abfd, sve_section, header, 0, SVE_HEADER_SIZE))
540 {
541 warning (_("Couldn't read sve header from "
542 "'.reg-aarch-sve' section in core file."));
543 return 0;
544 }
545
546 uint64_t vl = extract_unsigned_integer (header + SVE_HEADER_VL_OFFSET,
547 SVE_HEADER_VL_LENGTH, byte_order);
548 uint64_t vq = sve_vq_from_vl (vl);
549
550 if (vq > AARCH64_MAX_SVE_VQ)
551 {
552 warning (_("SVE Vector length in core file not supported by this version"
49514353 553 " of GDB. (VQ=%s)"), pulongest (vq));
b7fd65b9
AH		 554 return 0;
555 }
556 else if (vq == 0)
557 {
49514353
TT		 558 warning (_("SVE Vector length in core file is invalid. (VQ=%s"),
559 pulongest (vq));
b7fd65b9
AH		 560 return 0;
561 }
562
563 return vq;
564}
565
0c76e06d
AH		 566/* Supply register REGNUM from BUF to REGCACHE, using the register map
567 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
568 If BUF is NULL, set the registers to "unavailable" status. */
569
570static void
571aarch64_linux_supply_sve_regset (const struct regset *regset,
572 struct regcache *regcache,
573 int regnum, const void *buf, size_t size)
574{
575 gdb_byte *header = (gdb_byte *) buf;
576 struct gdbarch *gdbarch = regcache->arch ();
577 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
578
579 if (buf == nullptr)
580 return regcache->supply_regset (regset, regnum, nullptr, size);
581 gdb_assert (size > SVE_HEADER_SIZE);
582
583 /* BUF contains an SVE header followed by a register dump of either the
584 passed in SVE regset or a NEON fpregset. */
585
586 /* Extract required fields from the header. */
0c0a40e0 587 ULONGEST vl = extract_unsigned_integer (header + SVE_HEADER_VL_OFFSET,
0c76e06d
AH		 588 SVE_HEADER_VL_LENGTH, byte_order);
589 uint16_t flags = extract_unsigned_integer (header + SVE_HEADER_FLAGS_OFFSET,
590 SVE_HEADER_FLAGS_LENGTH,
591 byte_order);
592
593 if (regnum == -1 || regnum == AARCH64_SVE_VG_REGNUM)
594 {
595 gdb_byte vg_target[8];
596 store_integer ((gdb_byte *)&vg_target, sizeof (uint64_t), byte_order,
597 sve_vg_from_vl (vl));
598 regcache->raw_supply (AARCH64_SVE_VG_REGNUM, &vg_target);
599 }
600
601 if (flags & SVE_HEADER_FLAG_SVE)
602 {
603 /* Register dump is a SVE structure. */
604 regcache->supply_regset (regset, regnum,
605 (gdb_byte *) buf + SVE_HEADER_SIZE,
606 size - SVE_HEADER_SIZE);
607 }
608 else
609 {
610 /* Register dump is a fpsimd structure. First clear the SVE
611 registers. */
612 for (int i = 0; i < AARCH64_SVE_Z_REGS_NUM; i++)
613 regcache->raw_supply_zeroed (AARCH64_SVE_Z0_REGNUM + i);
614 for (int i = 0; i < AARCH64_SVE_P_REGS_NUM; i++)
615 regcache->raw_supply_zeroed (AARCH64_SVE_P0_REGNUM + i);
616 regcache->raw_supply_zeroed (AARCH64_SVE_FFR_REGNUM);
617
618 /* Then supply the fpsimd registers. */
619 regcache->supply_regset (&aarch64_linux_fpregset, regnum,
620 (gdb_byte *) buf + SVE_HEADER_SIZE,
621 size - SVE_HEADER_SIZE);
622 }
623}
624
625/* Collect register REGNUM from REGCACHE to BUF, using the register
626 map in REGSET. If REGNUM is -1, do this for all registers in
627 REGSET. */
628
629static void
630aarch64_linux_collect_sve_regset (const struct regset *regset,
631 const struct regcache *regcache,
632 int regnum, void *buf, size_t size)
633{
634 gdb_byte *header = (gdb_byte *) buf;
635 struct gdbarch *gdbarch = regcache->arch ();
636 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
637 uint64_t vq = gdbarch_tdep (gdbarch)->vq;
638
639 gdb_assert (buf != NULL);
640 gdb_assert (size > SVE_HEADER_SIZE);
641
642 /* BUF starts with a SVE header prior to the register dump. */
643
644 store_unsigned_integer (header + SVE_HEADER_SIZE_OFFSET,
645 SVE_HEADER_SIZE_LENGTH, byte_order, size);
646 store_unsigned_integer (header + SVE_HEADER_MAX_SIZE_OFFSET,
647 SVE_HEADER_MAX_SIZE_LENGTH, byte_order, size);
648 store_unsigned_integer (header + SVE_HEADER_VL_OFFSET, SVE_HEADER_VL_LENGTH,
649 byte_order, sve_vl_from_vq (vq));
650 store_unsigned_integer (header + SVE_HEADER_MAX_VL_OFFSET,
651 SVE_HEADER_MAX_VL_LENGTH, byte_order,
652 sve_vl_from_vq (vq));
653 store_unsigned_integer (header + SVE_HEADER_FLAGS_OFFSET,
654 SVE_HEADER_FLAGS_LENGTH, byte_order,
655 SVE_HEADER_FLAG_SVE);
656 store_unsigned_integer (header + SVE_HEADER_RESERVED_OFFSET,
657 SVE_HEADER_RESERVED_LENGTH, byte_order, 0);
658
659 /* The SVE register dump follows. */
660 regcache->collect_regset (regset, regnum, (gdb_byte *) buf + SVE_HEADER_SIZE,
661 size - SVE_HEADER_SIZE);
662}
663
89203d40 664/* Implement the "iterate_over_regset_sections" gdbarch method. */
1ae3db19 665
4108500a
AA		 666static void
667aarch64_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
668 iterate_over_regset_sections_cb *cb,
669 void *cb_data,
670 const struct regcache *regcache)
1ae3db19 671{
0c76e06d
AH		 672 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
673
a616bb94
AH		 674 cb (".reg", AARCH64_LINUX_SIZEOF_GREGSET, AARCH64_LINUX_SIZEOF_GREGSET,
675 &aarch64_linux_gregset, NULL, cb_data);
0c76e06d
AH		 676
677 if (tdep->has_sve ())
678 {
679 /* Create this on the fly in order to handle vector register sizes. */
680 const struct regcache_map_entry sve_regmap[] =
681 {
1885053b
TT		 682 { 32, AARCH64_SVE_Z0_REGNUM, (int) (tdep->vq * 16) },
683 { 16, AARCH64_SVE_P0_REGNUM, (int) (tdep->vq * 16 / 8) },
0c76e06d
AH		 684 { 1, AARCH64_SVE_FFR_REGNUM, 4 },
685 { 1, AARCH64_FPSR_REGNUM, 4 },
686 { 1, AARCH64_FPCR_REGNUM, 4 },
687 { 0 }
688 };
689
690 const struct regset aarch64_linux_sve_regset =
691 {
692 sve_regmap,
693 aarch64_linux_supply_sve_regset, aarch64_linux_collect_sve_regset,
694 REGSET_VARIABLE_SIZE
695 };
696
697 cb (".reg-aarch-sve",
698 SVE_HEADER_SIZE + regcache_map_entry_size (aarch64_linux_fpregmap),
699 SVE_HEADER_SIZE + regcache_map_entry_size (sve_regmap),
700 &aarch64_linux_sve_regset, "SVE registers", cb_data);
701 }
702 else
703 cb (".reg2", AARCH64_LINUX_SIZEOF_FPREGSET, AARCH64_LINUX_SIZEOF_FPREGSET,
704 &aarch64_linux_fpregset, NULL, cb_data);
59c28372
AH		 705
706
707 if (tdep->has_pauth ())
708 {
709 /* Create this on the fly in order to handle the variable location. */
710 const struct regcache_map_entry pauth_regmap[] =
711 {
712 { 2, AARCH64_PAUTH_DMASK_REGNUM (tdep->pauth_reg_base), 8},
713 { 0 }
714 };
715
716 const struct regset aarch64_linux_pauth_regset =
717 {
718 pauth_regmap, regcache_supply_regset, regcache_collect_regset
719 };
720
721 cb (".reg-aarch-pauth", AARCH64_LINUX_SIZEOF_PAUTH,
722 AARCH64_LINUX_SIZEOF_PAUTH, &aarch64_linux_pauth_regset,
723 "pauth registers", cb_data);
724 }
1ae3db19
MS		 725}
726
b7fd65b9 727/* Implement the "core_read_description" gdbarch method. */
cd3af38d
JW		 728
729static const struct target_desc *
730aarch64_linux_core_read_description (struct gdbarch *gdbarch,
731 struct target_ops *target, bfd *abfd)
732{
0f83012e 733 CORE_ADDR hwcap = linux_get_hwcap (target);
c1bd443b 734 CORE_ADDR hwcap2 = linux_get_hwcap2 (target);
cd3af38d 735
c1bd443b
LM		 736 bool pauth_p = hwcap & AARCH64_HWCAP_PACA;
737 bool mte_p = hwcap2 & HWCAP2_MTE;
6dc0ebde 738 return aarch64_read_description (aarch64_linux_core_read_vq (gdbarch, abfd),
c1bd443b 739 pauth_p, mte_p);
cd3af38d
JW		 740}
741
08248ca9
SDJ		 742/* Implementation of `gdbarch_stap_is_single_operand', as defined in
743 gdbarch.h. */
744
745static int
746aarch64_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
747{
748 return (*s == '#' || isdigit (*s) /* Literal number. */
749 || *s == '[' /* Register indirection. */
750 || isalpha (*s)); /* Register value. */
751}
752
753/* This routine is used to parse a special token in AArch64's assembly.
754
755 The special tokens parsed by it are:
756
757 - Register displacement (e.g, [fp, #-8])
758
759 It returns one if the special token has been parsed successfully,
760 or zero if the current token is not considered special. */
761
4c5e7a93 762static expr::operation_up
08248ca9
SDJ		 763aarch64_stap_parse_special_token (struct gdbarch *gdbarch,
764 struct stap_parse_info *p)
765{
766 if (*p->arg == '[')
767 {
768 /* Temporary holder for lookahead. */
769 const char *tmp = p->arg;
770 char *endp;
771 /* Used to save the register name. */
772 const char *start;
08248ca9
SDJ		 773 int len;
774 int got_minus = 0;
775 long displacement;
08248ca9
SDJ		 776
777 ++tmp;
778 start = tmp;
779
780 /* Register name. */
781 while (isalnum (*tmp))
782 ++tmp;
783
784 if (*tmp != ',')
4c5e7a93 785 return {};
08248ca9
SDJ		 786
787 len = tmp - start;
4c5e7a93 788 std::string regname (start, len);
08248ca9 789
4c5e7a93 790 if (user_reg_map_name_to_regnum (gdbarch, regname.c_str (), len) == -1)
08248ca9 791 error (_("Invalid register name `%s' on expression `%s'."),
4c5e7a93 792 regname.c_str (), p->saved_arg);
08248ca9
SDJ		 793
794 ++tmp;
f1735a53 795 tmp = skip_spaces (tmp);
08248ca9
SDJ		 796 /* Now we expect a number. It can begin with '#' or simply
797 a digit. */
798 if (*tmp == '#')
799 ++tmp;
800
801 if (*tmp == '-')
802 {
803 ++tmp;
804 got_minus = 1;
805 }
806 else if (*tmp == '+')
807 ++tmp;
808
809 if (!isdigit (*tmp))
4c5e7a93 810 return {};
08248ca9
SDJ		 811
812 displacement = strtol (tmp, &endp, 10);
813 tmp = endp;
814
815 /* Skipping last `]'. */
816 if (*tmp++ != ']')
4c5e7a93
TT		 817 return {};
818 p->arg = tmp;
819
820 using namespace expr;
08248ca9
SDJ		 821
822 /* The displacement. */
4c5e7a93 823 struct type *long_type = builtin_type (gdbarch)->builtin_long;
08248ca9 824 if (got_minus)
4c5e7a93
TT		 825 displacement = -displacement;
826 operation_up disp = make_operation<long_const_operation> (long_type,
827 displacement);
08248ca9
SDJ		 828
829 /* The register name. */
4c5e7a93
TT		 830 operation_up reg
831 = make_operation<register_operation> (std::move (regname));
08248ca9 832
4c5e7a93
TT		 833 operation_up sum
834 = make_operation<add_operation> (std::move (reg), std::move (disp));
08248ca9
SDJ		 835
836 /* Casting to the expected type. */
4c5e7a93
TT		 837 struct type *arg_ptr_type = lookup_pointer_type (p->arg_type);
838 sum = make_operation<unop_cast_operation> (std::move (sum),
839 arg_ptr_type);
840 return make_operation<unop_ind_operation> (std::move (sum));
08248ca9 841 }
4c5e7a93 842 return {};
08248ca9
SDJ		 843}
844
99afc88b
OJ		 845/* AArch64 process record-replay constructs: syscall, signal etc. */
846
6bd434d6 847static linux_record_tdep aarch64_linux_record_tdep;
99afc88b
OJ		 848
849/* Enum that defines the AArch64 linux specific syscall identifiers used for
850 process record/replay. */
851
852enum aarch64_syscall {
853 aarch64_sys_io_setup = 0,
854 aarch64_sys_io_destroy = 1,
855 aarch64_sys_io_submit = 2,
856 aarch64_sys_io_cancel = 3,
857 aarch64_sys_io_getevents = 4,
858 aarch64_sys_setxattr = 5,
859 aarch64_sys_lsetxattr = 6,
860 aarch64_sys_fsetxattr = 7,
861 aarch64_sys_getxattr = 8,
862 aarch64_sys_lgetxattr = 9,
863 aarch64_sys_fgetxattr = 10,
864 aarch64_sys_listxattr = 11,
865 aarch64_sys_llistxattr = 12,
866 aarch64_sys_flistxattr = 13,
867 aarch64_sys_removexattr = 14,
868 aarch64_sys_lremovexattr = 15,
869 aarch64_sys_fremovexattr = 16,
870 aarch64_sys_getcwd = 17,
871 aarch64_sys_lookup_dcookie = 18,
872 aarch64_sys_eventfd2 = 19,
873 aarch64_sys_epoll_create1 = 20,
874 aarch64_sys_epoll_ctl = 21,
875 aarch64_sys_epoll_pwait = 22,
876 aarch64_sys_dup = 23,
877 aarch64_sys_dup3 = 24,
878 aarch64_sys_fcntl = 25,
879 aarch64_sys_inotify_init1 = 26,
880 aarch64_sys_inotify_add_watch = 27,
881 aarch64_sys_inotify_rm_watch = 28,
882 aarch64_sys_ioctl = 29,
883 aarch64_sys_ioprio_set = 30,
884 aarch64_sys_ioprio_get = 31,
885 aarch64_sys_flock = 32,
c955ae73
YQ		 886 aarch64_sys_mknodat = 33,
887 aarch64_sys_mkdirat = 34,
888 aarch64_sys_unlinkat = 35,
889 aarch64_sys_symlinkat = 36,
890 aarch64_sys_linkat = 37,
891 aarch64_sys_renameat = 38,
99afc88b
OJ		 892 aarch64_sys_umount2 = 39,
893 aarch64_sys_mount = 40,
894 aarch64_sys_pivot_root = 41,
895 aarch64_sys_nfsservctl = 42,
896 aarch64_sys_statfs = 43,
897 aarch64_sys_fstatfs = 44,
898 aarch64_sys_truncate = 45,
899 aarch64_sys_ftruncate = 46,
900 aarch64_sys_fallocate = 47,
c955ae73 901 aarch64_sys_faccessat = 48,
99afc88b
OJ		 902 aarch64_sys_chdir = 49,
903 aarch64_sys_fchdir = 50,
904 aarch64_sys_chroot = 51,
905 aarch64_sys_fchmod = 52,
906 aarch64_sys_fchmodat = 53,
907 aarch64_sys_fchownat = 54,
908 aarch64_sys_fchown = 55,
c955ae73 909 aarch64_sys_openat = 56,
99afc88b
OJ		 910 aarch64_sys_close = 57,
911 aarch64_sys_vhangup = 58,
912 aarch64_sys_pipe2 = 59,
913 aarch64_sys_quotactl = 60,
914 aarch64_sys_getdents64 = 61,
915 aarch64_sys_lseek = 62,
916 aarch64_sys_read = 63,
917 aarch64_sys_write = 64,
918 aarch64_sys_readv = 65,
919 aarch64_sys_writev = 66,
920 aarch64_sys_pread64 = 67,
921 aarch64_sys_pwrite64 = 68,
922 aarch64_sys_preadv = 69,
923 aarch64_sys_pwritev = 70,
924 aarch64_sys_sendfile = 71,
925 aarch64_sys_pselect6 = 72,
926 aarch64_sys_ppoll = 73,
927 aarch64_sys_signalfd4 = 74,
928 aarch64_sys_vmsplice = 75,
929 aarch64_sys_splice = 76,
930 aarch64_sys_tee = 77,
c955ae73
YQ		 931 aarch64_sys_readlinkat = 78,
932 aarch64_sys_newfstatat = 79,
99afc88b
OJ		 933 aarch64_sys_fstat = 80,
934 aarch64_sys_sync = 81,
935 aarch64_sys_fsync = 82,
936 aarch64_sys_fdatasync = 83,
937 aarch64_sys_sync_file_range2 = 84,
938 aarch64_sys_sync_file_range = 84,
939 aarch64_sys_timerfd_create = 85,
940 aarch64_sys_timerfd_settime = 86,
941 aarch64_sys_timerfd_gettime = 87,
942 aarch64_sys_utimensat = 88,
943 aarch64_sys_acct = 89,
944 aarch64_sys_capget = 90,
945 aarch64_sys_capset = 91,
946 aarch64_sys_personality = 92,
947 aarch64_sys_exit = 93,
948 aarch64_sys_exit_group = 94,
949 aarch64_sys_waitid = 95,
950 aarch64_sys_set_tid_address = 96,
951 aarch64_sys_unshare = 97,
952 aarch64_sys_futex = 98,
953 aarch64_sys_set_robust_list = 99,
954 aarch64_sys_get_robust_list = 100,
955 aarch64_sys_nanosleep = 101,
956 aarch64_sys_getitimer = 102,
957 aarch64_sys_setitimer = 103,
958 aarch64_sys_kexec_load = 104,
959 aarch64_sys_init_module = 105,
960 aarch64_sys_delete_module = 106,
961 aarch64_sys_timer_create = 107,
962 aarch64_sys_timer_gettime = 108,
963 aarch64_sys_timer_getoverrun = 109,
964 aarch64_sys_timer_settime = 110,
965 aarch64_sys_timer_delete = 111,
966 aarch64_sys_clock_settime = 112,
967 aarch64_sys_clock_gettime = 113,
968 aarch64_sys_clock_getres = 114,
969 aarch64_sys_clock_nanosleep = 115,
970 aarch64_sys_syslog = 116,
971 aarch64_sys_ptrace = 117,
972 aarch64_sys_sched_setparam = 118,
973 aarch64_sys_sched_setscheduler = 119,
974 aarch64_sys_sched_getscheduler = 120,
975 aarch64_sys_sched_getparam = 121,
976 aarch64_sys_sched_setaffinity = 122,
977 aarch64_sys_sched_getaffinity = 123,
978 aarch64_sys_sched_yield = 124,
979 aarch64_sys_sched_get_priority_max = 125,
980 aarch64_sys_sched_get_priority_min = 126,
981 aarch64_sys_sched_rr_get_interval = 127,
982 aarch64_sys_kill = 129,
983 aarch64_sys_tkill = 130,
984 aarch64_sys_tgkill = 131,
985 aarch64_sys_sigaltstack = 132,
986 aarch64_sys_rt_sigsuspend = 133,
987 aarch64_sys_rt_sigaction = 134,
988 aarch64_sys_rt_sigprocmask = 135,
989 aarch64_sys_rt_sigpending = 136,
990 aarch64_sys_rt_sigtimedwait = 137,
991 aarch64_sys_rt_sigqueueinfo = 138,
992 aarch64_sys_rt_sigreturn = 139,
993 aarch64_sys_setpriority = 140,
994 aarch64_sys_getpriority = 141,
995 aarch64_sys_reboot = 142,
996 aarch64_sys_setregid = 143,
997 aarch64_sys_setgid = 144,
998 aarch64_sys_setreuid = 145,
999 aarch64_sys_setuid = 146,
1000 aarch64_sys_setresuid = 147,
1001 aarch64_sys_getresuid = 148,
1002 aarch64_sys_setresgid = 149,
1003 aarch64_sys_getresgid = 150,
1004 aarch64_sys_setfsuid = 151,
1005 aarch64_sys_setfsgid = 152,
1006 aarch64_sys_times = 153,
1007 aarch64_sys_setpgid = 154,
1008 aarch64_sys_getpgid = 155,
1009 aarch64_sys_getsid = 156,
1010 aarch64_sys_setsid = 157,
1011 aarch64_sys_getgroups = 158,
1012 aarch64_sys_setgroups = 159,
1013 aarch64_sys_uname = 160,
1014 aarch64_sys_sethostname = 161,
1015 aarch64_sys_setdomainname = 162,
1016 aarch64_sys_getrlimit = 163,
1017 aarch64_sys_setrlimit = 164,
1018 aarch64_sys_getrusage = 165,
1019 aarch64_sys_umask = 166,
1020 aarch64_sys_prctl = 167,
1021 aarch64_sys_getcpu = 168,
1022 aarch64_sys_gettimeofday = 169,
1023 aarch64_sys_settimeofday = 170,
1024 aarch64_sys_adjtimex = 171,
1025 aarch64_sys_getpid = 172,
1026 aarch64_sys_getppid = 173,
1027 aarch64_sys_getuid = 174,
1028 aarch64_sys_geteuid = 175,
1029 aarch64_sys_getgid = 176,
1030 aarch64_sys_getegid = 177,
1031 aarch64_sys_gettid = 178,
1032 aarch64_sys_sysinfo = 179,
1033 aarch64_sys_mq_open = 180,
1034 aarch64_sys_mq_unlink = 181,
1035 aarch64_sys_mq_timedsend = 182,
1036 aarch64_sys_mq_timedreceive = 183,
1037 aarch64_sys_mq_notify = 184,
1038 aarch64_sys_mq_getsetattr = 185,
1039 aarch64_sys_msgget = 186,
1040 aarch64_sys_msgctl = 187,
1041 aarch64_sys_msgrcv = 188,
1042 aarch64_sys_msgsnd = 189,
1043 aarch64_sys_semget = 190,
1044 aarch64_sys_semctl = 191,
1045 aarch64_sys_semtimedop = 192,
1046 aarch64_sys_semop = 193,
1047 aarch64_sys_shmget = 194,
1048 aarch64_sys_shmctl = 195,
1049 aarch64_sys_shmat = 196,
1050 aarch64_sys_shmdt = 197,
1051 aarch64_sys_socket = 198,
1052 aarch64_sys_socketpair = 199,
1053 aarch64_sys_bind = 200,
1054 aarch64_sys_listen = 201,
1055 aarch64_sys_accept = 202,
1056 aarch64_sys_connect = 203,
1057 aarch64_sys_getsockname = 204,
1058 aarch64_sys_getpeername = 205,
1059 aarch64_sys_sendto = 206,
1060 aarch64_sys_recvfrom = 207,
1061 aarch64_sys_setsockopt = 208,
1062 aarch64_sys_getsockopt = 209,
1063 aarch64_sys_shutdown = 210,
1064 aarch64_sys_sendmsg = 211,
1065 aarch64_sys_recvmsg = 212,
1066 aarch64_sys_readahead = 213,
1067 aarch64_sys_brk = 214,
1068 aarch64_sys_munmap = 215,
1069 aarch64_sys_mremap = 216,
1070 aarch64_sys_add_key = 217,
1071 aarch64_sys_request_key = 218,
1072 aarch64_sys_keyctl = 219,
1073 aarch64_sys_clone = 220,
1074 aarch64_sys_execve = 221,
1075 aarch64_sys_mmap = 222,
1076 aarch64_sys_fadvise64 = 223,
1077 aarch64_sys_swapon = 224,
1078 aarch64_sys_swapoff = 225,
1079 aarch64_sys_mprotect = 226,
1080 aarch64_sys_msync = 227,
1081 aarch64_sys_mlock = 228,
1082 aarch64_sys_munlock = 229,
1083 aarch64_sys_mlockall = 230,
1084 aarch64_sys_munlockall = 231,
1085 aarch64_sys_mincore = 232,
1086 aarch64_sys_madvise = 233,
1087 aarch64_sys_remap_file_pages = 234,
1088 aarch64_sys_mbind = 235,
1089 aarch64_sys_get_mempolicy = 236,
1090 aarch64_sys_set_mempolicy = 237,
1091 aarch64_sys_migrate_pages = 238,
1092 aarch64_sys_move_pages = 239,
1093 aarch64_sys_rt_tgsigqueueinfo = 240,
1094 aarch64_sys_perf_event_open = 241,
1095 aarch64_sys_accept4 = 242,
1096 aarch64_sys_recvmmsg = 243,
1097 aarch64_sys_wait4 = 260,
1098 aarch64_sys_prlimit64 = 261,
1099 aarch64_sys_fanotify_init = 262,
1100 aarch64_sys_fanotify_mark = 263,
1101 aarch64_sys_name_to_handle_at = 264,
1102 aarch64_sys_open_by_handle_at = 265,
1103 aarch64_sys_clock_adjtime = 266,
1104 aarch64_sys_syncfs = 267,
1105 aarch64_sys_setns = 268,
1106 aarch64_sys_sendmmsg = 269,
1107 aarch64_sys_process_vm_readv = 270,
1108 aarch64_sys_process_vm_writev = 271,
1109 aarch64_sys_kcmp = 272,
1110 aarch64_sys_finit_module = 273,
1111 aarch64_sys_sched_setattr = 274,
1112 aarch64_sys_sched_getattr = 275,
1113};
1114
1115/* aarch64_canonicalize_syscall maps syscall ids from the native AArch64
1116 linux set of syscall ids into a canonical set of syscall ids used by
1117 process record. */
1118
1119static enum gdb_syscall
1120aarch64_canonicalize_syscall (enum aarch64_syscall syscall_number)
1121{
1122#define SYSCALL_MAP(SYSCALL) case aarch64_sys_##SYSCALL: \
1123 return gdb_sys_##SYSCALL
1124
c955ae73
YQ		 1125#define UNSUPPORTED_SYSCALL_MAP(SYSCALL) case aarch64_sys_##SYSCALL: \
1126 return gdb_sys_no_syscall
1127
99afc88b
OJ		 1128 switch (syscall_number)
1129 {
1130 SYSCALL_MAP (io_setup);
1131 SYSCALL_MAP (io_destroy);
1132 SYSCALL_MAP (io_submit);
1133 SYSCALL_MAP (io_cancel);
1134 SYSCALL_MAP (io_getevents);
1135
1136 SYSCALL_MAP (setxattr);
1137 SYSCALL_MAP (lsetxattr);
1138 SYSCALL_MAP (fsetxattr);
1139 SYSCALL_MAP (getxattr);
1140 SYSCALL_MAP (lgetxattr);
1141 SYSCALL_MAP (fgetxattr);
1142 SYSCALL_MAP (listxattr);
1143 SYSCALL_MAP (llistxattr);
1144 SYSCALL_MAP (flistxattr);
1145 SYSCALL_MAP (removexattr);
1146 SYSCALL_MAP (lremovexattr);
1147 SYSCALL_MAP (fremovexattr);
1148 SYSCALL_MAP (getcwd);
1149 SYSCALL_MAP (lookup_dcookie);
d5219069
YQ		 1150 SYSCALL_MAP (eventfd2);
1151 SYSCALL_MAP (epoll_create1);
99afc88b
OJ		 1152 SYSCALL_MAP (epoll_ctl);
1153 SYSCALL_MAP (epoll_pwait);
1154 SYSCALL_MAP (dup);
d5219069 1155 SYSCALL_MAP (dup3);
99afc88b 1156 SYSCALL_MAP (fcntl);
d5219069 1157 SYSCALL_MAP (inotify_init1);
99afc88b
OJ		 1158 SYSCALL_MAP (inotify_add_watch);
1159 SYSCALL_MAP (inotify_rm_watch);
1160 SYSCALL_MAP (ioctl);
1161 SYSCALL_MAP (ioprio_set);
1162 SYSCALL_MAP (ioprio_get);
1163 SYSCALL_MAP (flock);
c955ae73
YQ		 1164 SYSCALL_MAP (mknodat);
1165 SYSCALL_MAP (mkdirat);
1166 SYSCALL_MAP (unlinkat);
1167 SYSCALL_MAP (symlinkat);
1168 SYSCALL_MAP (linkat);
1169 SYSCALL_MAP (renameat);
1170 UNSUPPORTED_SYSCALL_MAP (umount2);
99afc88b 1171 SYSCALL_MAP (mount);
c955ae73 1172 SYSCALL_MAP (pivot_root);
99afc88b
OJ		 1173 SYSCALL_MAP (nfsservctl);
1174 SYSCALL_MAP (statfs);
1175 SYSCALL_MAP (truncate);
1176 SYSCALL_MAP (ftruncate);
d5219069 1177 SYSCALL_MAP (fallocate);
c955ae73 1178 SYSCALL_MAP (faccessat);
99afc88b
OJ		 1179 SYSCALL_MAP (fchdir);
1180 SYSCALL_MAP (chroot);
1181 SYSCALL_MAP (fchmod);
1182 SYSCALL_MAP (fchmodat);
1183 SYSCALL_MAP (fchownat);
1184 SYSCALL_MAP (fchown);
c955ae73 1185 SYSCALL_MAP (openat);
99afc88b
OJ		 1186 SYSCALL_MAP (close);
1187 SYSCALL_MAP (vhangup);
d5219069 1188 SYSCALL_MAP (pipe2);
99afc88b
OJ		 1189 SYSCALL_MAP (quotactl);
1190 SYSCALL_MAP (getdents64);
1191 SYSCALL_MAP (lseek);
1192 SYSCALL_MAP (read);
1193 SYSCALL_MAP (write);
1194 SYSCALL_MAP (readv);
1195 SYSCALL_MAP (writev);
1196 SYSCALL_MAP (pread64);
1197 SYSCALL_MAP (pwrite64);
c955ae73
YQ		 1198 UNSUPPORTED_SYSCALL_MAP (preadv);
1199 UNSUPPORTED_SYSCALL_MAP (pwritev);
99afc88b
OJ		 1200 SYSCALL_MAP (sendfile);
1201 SYSCALL_MAP (pselect6);
1202 SYSCALL_MAP (ppoll);
c955ae73 1203 UNSUPPORTED_SYSCALL_MAP (signalfd4);
99afc88b
OJ		 1204 SYSCALL_MAP (vmsplice);
1205 SYSCALL_MAP (splice);
1206 SYSCALL_MAP (tee);
c955ae73
YQ		 1207 SYSCALL_MAP (readlinkat);
1208 SYSCALL_MAP (newfstatat);
1209
99afc88b
OJ		 1210 SYSCALL_MAP (fstat);
1211 SYSCALL_MAP (sync);
1212 SYSCALL_MAP (fsync);
1213 SYSCALL_MAP (fdatasync);
1214 SYSCALL_MAP (sync_file_range);
c955ae73
YQ		 1215 UNSUPPORTED_SYSCALL_MAP (timerfd_create);
1216 UNSUPPORTED_SYSCALL_MAP (timerfd_settime);
1217 UNSUPPORTED_SYSCALL_MAP (timerfd_gettime);
1218 UNSUPPORTED_SYSCALL_MAP (utimensat);
99afc88b
OJ		 1219 SYSCALL_MAP (acct);
1220 SYSCALL_MAP (capget);
1221 SYSCALL_MAP (capset);
1222 SYSCALL_MAP (personality);
1223 SYSCALL_MAP (exit);
1224 SYSCALL_MAP (exit_group);
1225 SYSCALL_MAP (waitid);
1226 SYSCALL_MAP (set_tid_address);
1227 SYSCALL_MAP (unshare);
1228 SYSCALL_MAP (futex);
1229 SYSCALL_MAP (set_robust_list);
1230 SYSCALL_MAP (get_robust_list);
1231 SYSCALL_MAP (nanosleep);
1232
1233 SYSCALL_MAP (getitimer);
1234 SYSCALL_MAP (setitimer);
1235 SYSCALL_MAP (kexec_load);
1236 SYSCALL_MAP (init_module);
1237 SYSCALL_MAP (delete_module);
1238 SYSCALL_MAP (timer_create);
1239 SYSCALL_MAP (timer_settime);
1240 SYSCALL_MAP (timer_gettime);
1241 SYSCALL_MAP (timer_getoverrun);
1242 SYSCALL_MAP (timer_delete);
1243 SYSCALL_MAP (clock_settime);
1244 SYSCALL_MAP (clock_gettime);
1245 SYSCALL_MAP (clock_getres);
1246 SYSCALL_MAP (clock_nanosleep);
1247 SYSCALL_MAP (syslog);
1248 SYSCALL_MAP (ptrace);
1249 SYSCALL_MAP (sched_setparam);
1250 SYSCALL_MAP (sched_setscheduler);
1251 SYSCALL_MAP (sched_getscheduler);
1252 SYSCALL_MAP (sched_getparam);
1253 SYSCALL_MAP (sched_setaffinity);
1254 SYSCALL_MAP (sched_getaffinity);
1255 SYSCALL_MAP (sched_yield);
1256 SYSCALL_MAP (sched_get_priority_max);
1257 SYSCALL_MAP (sched_get_priority_min);
1258 SYSCALL_MAP (sched_rr_get_interval);
1259 SYSCALL_MAP (kill);
1260 SYSCALL_MAP (tkill);
1261 SYSCALL_MAP (tgkill);
1262 SYSCALL_MAP (sigaltstack);
1263 SYSCALL_MAP (rt_sigsuspend);
1264 SYSCALL_MAP (rt_sigaction);
1265 SYSCALL_MAP (rt_sigprocmask);
1266 SYSCALL_MAP (rt_sigpending);
1267 SYSCALL_MAP (rt_sigtimedwait);
1268 SYSCALL_MAP (rt_sigqueueinfo);
1269 SYSCALL_MAP (rt_sigreturn);
1270 SYSCALL_MAP (setpriority);
1271 SYSCALL_MAP (getpriority);
1272 SYSCALL_MAP (reboot);
1273 SYSCALL_MAP (setregid);
1274 SYSCALL_MAP (setgid);
1275 SYSCALL_MAP (setreuid);
1276 SYSCALL_MAP (setuid);
1277 SYSCALL_MAP (setresuid);
1278 SYSCALL_MAP (getresuid);
1279 SYSCALL_MAP (setresgid);
1280 SYSCALL_MAP (getresgid);
1281 SYSCALL_MAP (setfsuid);
1282 SYSCALL_MAP (setfsgid);
1283 SYSCALL_MAP (times);
1284 SYSCALL_MAP (setpgid);
1285 SYSCALL_MAP (getpgid);
1286 SYSCALL_MAP (getsid);
1287 SYSCALL_MAP (setsid);
1288 SYSCALL_MAP (getgroups);
1289 SYSCALL_MAP (setgroups);
1290 SYSCALL_MAP (uname);
1291 SYSCALL_MAP (sethostname);
1292 SYSCALL_MAP (setdomainname);
1293 SYSCALL_MAP (getrlimit);
1294 SYSCALL_MAP (setrlimit);
1295 SYSCALL_MAP (getrusage);
1296 SYSCALL_MAP (umask);
1297 SYSCALL_MAP (prctl);
c955ae73 1298 SYSCALL_MAP (getcpu);
99afc88b
OJ		 1299 SYSCALL_MAP (gettimeofday);
1300 SYSCALL_MAP (settimeofday);
1301 SYSCALL_MAP (adjtimex);
1302 SYSCALL_MAP (getpid);
1303 SYSCALL_MAP (getppid);
1304 SYSCALL_MAP (getuid);
1305 SYSCALL_MAP (geteuid);
1306 SYSCALL_MAP (getgid);
1307 SYSCALL_MAP (getegid);
1308 SYSCALL_MAP (gettid);
1309 SYSCALL_MAP (sysinfo);
1310 SYSCALL_MAP (mq_open);
1311 SYSCALL_MAP (mq_unlink);
1312 SYSCALL_MAP (mq_timedsend);
1313 SYSCALL_MAP (mq_timedreceive);
1314 SYSCALL_MAP (mq_notify);
1315 SYSCALL_MAP (mq_getsetattr);
1316 SYSCALL_MAP (msgget);
1317 SYSCALL_MAP (msgctl);
1318 SYSCALL_MAP (msgrcv);
1319 SYSCALL_MAP (msgsnd);
1320 SYSCALL_MAP (semget);
1321 SYSCALL_MAP (semctl);
1322 SYSCALL_MAP (semtimedop);
1323 SYSCALL_MAP (semop);
1324 SYSCALL_MAP (shmget);
1325 SYSCALL_MAP (shmctl);
1326 SYSCALL_MAP (shmat);
1327 SYSCALL_MAP (shmdt);
1328 SYSCALL_MAP (socket);
1329 SYSCALL_MAP (socketpair);
1330 SYSCALL_MAP (bind);
1331 SYSCALL_MAP (listen);
1332 SYSCALL_MAP (accept);
1333 SYSCALL_MAP (connect);
1334 SYSCALL_MAP (getsockname);
1335 SYSCALL_MAP (getpeername);
1336 SYSCALL_MAP (sendto);
1337 SYSCALL_MAP (recvfrom);
1338 SYSCALL_MAP (setsockopt);
1339 SYSCALL_MAP (getsockopt);
1340 SYSCALL_MAP (shutdown);
1341 SYSCALL_MAP (sendmsg);
1342 SYSCALL_MAP (recvmsg);
1343 SYSCALL_MAP (readahead);
1344 SYSCALL_MAP (brk);
1345 SYSCALL_MAP (munmap);
1346 SYSCALL_MAP (mremap);
1347 SYSCALL_MAP (add_key);
1348 SYSCALL_MAP (request_key);
1349 SYSCALL_MAP (keyctl);
1350 SYSCALL_MAP (clone);
1351 SYSCALL_MAP (execve);
1352
1353 case aarch64_sys_mmap:
1354 return gdb_sys_mmap2;
1355
1356 SYSCALL_MAP (fadvise64);
1357 SYSCALL_MAP (swapon);
1358 SYSCALL_MAP (swapoff);
1359 SYSCALL_MAP (mprotect);
1360 SYSCALL_MAP (msync);
1361 SYSCALL_MAP (mlock);
1362 SYSCALL_MAP (munlock);
1363 SYSCALL_MAP (mlockall);
1364 SYSCALL_MAP (munlockall);
1365 SYSCALL_MAP (mincore);
1366 SYSCALL_MAP (madvise);
1367 SYSCALL_MAP (remap_file_pages);
1368 SYSCALL_MAP (mbind);
1369 SYSCALL_MAP (get_mempolicy);
1370 SYSCALL_MAP (set_mempolicy);
1371 SYSCALL_MAP (migrate_pages);
1372 SYSCALL_MAP (move_pages);
c955ae73
YQ		 1373 UNSUPPORTED_SYSCALL_MAP (rt_tgsigqueueinfo);
1374 UNSUPPORTED_SYSCALL_MAP (perf_event_open);
1375 UNSUPPORTED_SYSCALL_MAP (accept4);
1376 UNSUPPORTED_SYSCALL_MAP (recvmmsg);
1377
1378 SYSCALL_MAP (wait4);
1379
1380 UNSUPPORTED_SYSCALL_MAP (prlimit64);
1381 UNSUPPORTED_SYSCALL_MAP (fanotify_init);
1382 UNSUPPORTED_SYSCALL_MAP (fanotify_mark);
1383 UNSUPPORTED_SYSCALL_MAP (name_to_handle_at);
1384 UNSUPPORTED_SYSCALL_MAP (open_by_handle_at);
1385 UNSUPPORTED_SYSCALL_MAP (clock_adjtime);
1386 UNSUPPORTED_SYSCALL_MAP (syncfs);
1387 UNSUPPORTED_SYSCALL_MAP (setns);
1388 UNSUPPORTED_SYSCALL_MAP (sendmmsg);
1389 UNSUPPORTED_SYSCALL_MAP (process_vm_readv);
1390 UNSUPPORTED_SYSCALL_MAP (process_vm_writev);
1391 UNSUPPORTED_SYSCALL_MAP (kcmp);
1392 UNSUPPORTED_SYSCALL_MAP (finit_module);
1393 UNSUPPORTED_SYSCALL_MAP (sched_setattr);
1394 UNSUPPORTED_SYSCALL_MAP (sched_getattr);
99afc88b 1395 default:
cb65d272 1396 return gdb_sys_no_syscall;
99afc88b
OJ		 1397 }
1398}
1399
ea638c43
AH		 1400/* Retrieve the syscall number at a ptrace syscall-stop, either on syscall entry
1401 or exit. Return -1 upon error. */
1402
1403static LONGEST
1404aarch64_linux_get_syscall_number (struct gdbarch *gdbarch, thread_info *thread)
1405{
1406 struct regcache *regs = get_thread_regcache (thread);
1407 LONGEST ret;
1408
1409 /* Get the system call number from register x8. */
1410 regs->cooked_read (AARCH64_X0_REGNUM + 8, &ret);
1411
1412 /* On exit from a successful execve, we will be in a new process and all the
1413 registers will be cleared - x0 to x30 will be 0, except for a 1 in x7.
1414 This function will only ever get called when stopped at the entry or exit
1415 of a syscall, so by checking for 0 in x0 (arg0/retval), x1 (arg1), x8
1416 (syscall), x29 (FP) and x30 (LR) we can infer:
30baf67b 1417 1) Either inferior is at exit from successful execve.
ea638c43
AH		 1418 2) Or inferior is at entry to a call to io_setup with invalid arguments and
1419 a corrupted FP and LR.
1420 It should be safe enough to assume case 1. */
1421 if (ret == 0)
1422 {
1423 LONGEST x1 = -1, fp = -1, lr = -1;
1424 regs->cooked_read (AARCH64_X0_REGNUM + 1, &x1);
1425 regs->cooked_read (AARCH64_FP_REGNUM, &fp);
1426 regs->cooked_read (AARCH64_LR_REGNUM, &lr);
1427 if (x1 == 0 && fp ==0 && lr == 0)
1428 return aarch64_sys_execve;
1429 }
1430
1431 return ret;
1432}
1433
99afc88b
OJ		 1434/* Record all registers but PC register for process-record. */
1435
1436static int
1437aarch64_all_but_pc_registers_record (struct regcache *regcache)
1438{
1439 int i;
1440
1441 for (i = AARCH64_X0_REGNUM; i < AARCH64_PC_REGNUM; i++)
1442 if (record_full_arch_list_add_reg (regcache, i))
1443 return -1;
1444
1445 if (record_full_arch_list_add_reg (regcache, AARCH64_CPSR_REGNUM))
1446 return -1;
1447
1448 return 0;
1449}
1450
1451/* Handler for aarch64 system call instruction recording. */
1452
1453static int
1454aarch64_linux_syscall_record (struct regcache *regcache,
1455 unsigned long svc_number)
1456{
1457 int ret = 0;
1458 enum gdb_syscall syscall_gdb;
1459
1f713e48
SM		 1460 syscall_gdb =
1461 aarch64_canonicalize_syscall ((enum aarch64_syscall) svc_number);
99afc88b
OJ		 1462
1463 if (syscall_gdb < 0)
1464 {
1465 printf_unfiltered (_("Process record and replay target doesn't "
1466 "support syscall number %s\n"),
1467 plongest (svc_number));
1468 return -1;
1469 }
1470
1471 if (syscall_gdb == gdb_sys_sigreturn
1472 || syscall_gdb == gdb_sys_rt_sigreturn)
1473 {
1474 if (aarch64_all_but_pc_registers_record (regcache))
1475 return -1;
1476 return 0;
1477 }
1478
1479 ret = record_linux_system_call (syscall_gdb, regcache,
1480 &aarch64_linux_record_tdep);
1481 if (ret != 0)
1482 return ret;
1483
1484 /* Record the return value of the system call. */
1485 if (record_full_arch_list_add_reg (regcache, AARCH64_X0_REGNUM))
1486 return -1;
1487 /* Record LR. */
1488 if (record_full_arch_list_add_reg (regcache, AARCH64_LR_REGNUM))
1489 return -1;
1490 /* Record CPSR. */
1491 if (record_full_arch_list_add_reg (regcache, AARCH64_CPSR_REGNUM))
1492 return -1;
1493
1494 return 0;
1495}
1496
7045b1ca
YQ		 1497/* Implement the "gcc_target_options" gdbarch method. */
1498
953cff56 1499static std::string
7045b1ca
YQ		 1500aarch64_linux_gcc_target_options (struct gdbarch *gdbarch)
1501{
1502 /* GCC doesn't know "-m64". */
953cff56 1503 return {};
7045b1ca
YQ		 1504}
1505
1ae3db19
MS		 1506static void
1507aarch64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1508{
08248ca9
SDJ		 1509 static const char *const stap_integer_prefixes[] = { "#", "", NULL };
1510 static const char *const stap_register_prefixes[] = { "", NULL };
1511 static const char *const stap_register_indirection_prefixes[] = { "[",
1512 NULL };
1513 static const char *const stap_register_indirection_suffixes[] = { "]",
1514 NULL };
1ae3db19
MS		 1515 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1516
1517 tdep->lowest_pc = 0x8000;
1518
480af54c 1519 linux_init_abi (info, gdbarch, 1);
05feb193 1520
1ae3db19
MS		 1521 set_solib_svr4_fetch_link_map_offsets (gdbarch,
1522 svr4_lp64_fetch_link_map_offsets);
1523
45e25a36
MS		 1524 /* Enable TLS support. */
1525 set_gdbarch_fetch_tls_load_module_address (gdbarch,
dda83cd7 1526 svr4_fetch_objfile_link_map);
45e25a36 1527
1ae3db19
MS		 1528 /* Shared library handling. */
1529 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
6dcaef99 1530 set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
1ae3db19 1531
1ae3db19
MS		 1532 tramp_frame_prepend_unwinder (gdbarch, &aarch64_linux_rt_sigframe);
1533
1534 /* Enable longjmp. */
1535 tdep->jb_pc = 11;
1536
4108500a
AA		 1537 set_gdbarch_iterate_over_regset_sections
1538 (gdbarch, aarch64_linux_iterate_over_regset_sections);
cd3af38d
JW		 1539 set_gdbarch_core_read_description
1540 (gdbarch, aarch64_linux_core_read_description);
08248ca9
SDJ		 1541
1542 /* SystemTap related. */
1543 set_gdbarch_stap_integer_prefixes (gdbarch, stap_integer_prefixes);
1544 set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
1545 set_gdbarch_stap_register_indirection_prefixes (gdbarch,
1546 stap_register_indirection_prefixes);
1547 set_gdbarch_stap_register_indirection_suffixes (gdbarch,
1548 stap_register_indirection_suffixes);
1549 set_gdbarch_stap_is_single_operand (gdbarch, aarch64_stap_is_single_operand);
1550 set_gdbarch_stap_parse_special_token (gdbarch,
1551 aarch64_stap_parse_special_token);
f68f11b7 1552
99afc88b
OJ		 1553 /* Reversible debugging, process record. */
1554 set_gdbarch_process_record (gdbarch, aarch64_process_record);
1555 /* Syscall record. */
1556 tdep->aarch64_syscall_record = aarch64_linux_syscall_record;
1557
8727de56
OJ		 1558 /* The top byte of a user space address known as the "tag",
1559 is ignored by the kernel and can be regarded as additional
1560 data associated with the address. */
1561 set_gdbarch_significant_addr_bit (gdbarch, 56);
1562
99afc88b
OJ		 1563 /* Initialize the aarch64_linux_record_tdep. */
1564 /* These values are the size of the type that will be used in a system
1565 call. They are obtained from Linux Kernel source. */
1566 aarch64_linux_record_tdep.size_pointer
1567 = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1568 aarch64_linux_record_tdep.size__old_kernel_stat = 32;
1569 aarch64_linux_record_tdep.size_tms = 32;
1570 aarch64_linux_record_tdep.size_loff_t = 8;
1571 aarch64_linux_record_tdep.size_flock = 32;
1572 aarch64_linux_record_tdep.size_oldold_utsname = 45;
1573 aarch64_linux_record_tdep.size_ustat = 32;
7571f7f2
MK		 1574 aarch64_linux_record_tdep.size_old_sigaction = 32;
1575 aarch64_linux_record_tdep.size_old_sigset_t = 8;
99afc88b
OJ		 1576 aarch64_linux_record_tdep.size_rlimit = 16;
1577 aarch64_linux_record_tdep.size_rusage = 144;
1578 aarch64_linux_record_tdep.size_timeval = 16;
1579 aarch64_linux_record_tdep.size_timezone = 8;
1580 aarch64_linux_record_tdep.size_old_gid_t = 2;
1581 aarch64_linux_record_tdep.size_old_uid_t = 2;
1582 aarch64_linux_record_tdep.size_fd_set = 128;
72aded86 1583 aarch64_linux_record_tdep.size_old_dirent = 280;
99afc88b
OJ		 1584 aarch64_linux_record_tdep.size_statfs = 120;
1585 aarch64_linux_record_tdep.size_statfs64 = 120;
1586 aarch64_linux_record_tdep.size_sockaddr = 16;
1587 aarch64_linux_record_tdep.size_int
1588 = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
1589 aarch64_linux_record_tdep.size_long
1590 = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
1591 aarch64_linux_record_tdep.size_ulong
1592 = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
1593 aarch64_linux_record_tdep.size_msghdr = 56;
1594 aarch64_linux_record_tdep.size_itimerval = 32;
1595 aarch64_linux_record_tdep.size_stat = 144;
1596 aarch64_linux_record_tdep.size_old_utsname = 325;
1597 aarch64_linux_record_tdep.size_sysinfo = 112;
1598 aarch64_linux_record_tdep.size_msqid_ds = 120;
1599 aarch64_linux_record_tdep.size_shmid_ds = 112;
1600 aarch64_linux_record_tdep.size_new_utsname = 390;
1601 aarch64_linux_record_tdep.size_timex = 208;
1602 aarch64_linux_record_tdep.size_mem_dqinfo = 24;
1603 aarch64_linux_record_tdep.size_if_dqblk = 72;
1604 aarch64_linux_record_tdep.size_fs_quota_stat = 80;
1605 aarch64_linux_record_tdep.size_timespec = 16;
1606 aarch64_linux_record_tdep.size_pollfd = 8;
1607 aarch64_linux_record_tdep.size_NFS_FHSIZE = 32;
1608 aarch64_linux_record_tdep.size_knfsd_fh = 132;
1609 aarch64_linux_record_tdep.size_TASK_COMM_LEN = 16;
7571f7f2
MK		 1610 aarch64_linux_record_tdep.size_sigaction = 32;
1611 aarch64_linux_record_tdep.size_sigset_t = 8;
99afc88b
OJ		 1612 aarch64_linux_record_tdep.size_siginfo_t = 128;
1613 aarch64_linux_record_tdep.size_cap_user_data_t = 8;
1614 aarch64_linux_record_tdep.size_stack_t = 24;
1615 aarch64_linux_record_tdep.size_off_t = 8;
1616 aarch64_linux_record_tdep.size_stat64 = 144;
1617 aarch64_linux_record_tdep.size_gid_t = 4;
1618 aarch64_linux_record_tdep.size_uid_t = 4;
1619 aarch64_linux_record_tdep.size_PAGE_SIZE = 4096;
1620 aarch64_linux_record_tdep.size_flock64 = 32;
1621 aarch64_linux_record_tdep.size_user_desc = 16;
1622 aarch64_linux_record_tdep.size_io_event = 32;
1623 aarch64_linux_record_tdep.size_iocb = 64;
1624 aarch64_linux_record_tdep.size_epoll_event = 12;
1625 aarch64_linux_record_tdep.size_itimerspec = 32;
1626 aarch64_linux_record_tdep.size_mq_attr = 64;
d9b19c49 1627 aarch64_linux_record_tdep.size_termios = 36;
99afc88b
OJ		 1628 aarch64_linux_record_tdep.size_termios2 = 44;
1629 aarch64_linux_record_tdep.size_pid_t = 4;
1630 aarch64_linux_record_tdep.size_winsize = 8;
1631 aarch64_linux_record_tdep.size_serial_struct = 72;
1632 aarch64_linux_record_tdep.size_serial_icounter_struct = 80;
1633 aarch64_linux_record_tdep.size_hayes_esp_config = 12;
1634 aarch64_linux_record_tdep.size_size_t = 8;
1635 aarch64_linux_record_tdep.size_iovec = 16;
b80d067f 1636 aarch64_linux_record_tdep.size_time_t = 8;
99afc88b
OJ		 1637
1638 /* These values are the second argument of system call "sys_ioctl".
1639 They are obtained from Linux Kernel source. */
1640 aarch64_linux_record_tdep.ioctl_TCGETS = 0x5401;
1641 aarch64_linux_record_tdep.ioctl_TCSETS = 0x5402;
1642 aarch64_linux_record_tdep.ioctl_TCSETSW = 0x5403;
1643 aarch64_linux_record_tdep.ioctl_TCSETSF = 0x5404;
1644 aarch64_linux_record_tdep.ioctl_TCGETA = 0x5405;
1645 aarch64_linux_record_tdep.ioctl_TCSETA = 0x5406;
1646 aarch64_linux_record_tdep.ioctl_TCSETAW = 0x5407;
1647 aarch64_linux_record_tdep.ioctl_TCSETAF = 0x5408;
1648 aarch64_linux_record_tdep.ioctl_TCSBRK = 0x5409;
1649 aarch64_linux_record_tdep.ioctl_TCXONC = 0x540a;
1650 aarch64_linux_record_tdep.ioctl_TCFLSH = 0x540b;
1651 aarch64_linux_record_tdep.ioctl_TIOCEXCL = 0x540c;
1652 aarch64_linux_record_tdep.ioctl_TIOCNXCL = 0x540d;
1653 aarch64_linux_record_tdep.ioctl_TIOCSCTTY = 0x540e;
1654 aarch64_linux_record_tdep.ioctl_TIOCGPGRP = 0x540f;
1655 aarch64_linux_record_tdep.ioctl_TIOCSPGRP = 0x5410;
1656 aarch64_linux_record_tdep.ioctl_TIOCOUTQ = 0x5411;
1657 aarch64_linux_record_tdep.ioctl_TIOCSTI = 0x5412;
1658 aarch64_linux_record_tdep.ioctl_TIOCGWINSZ = 0x5413;
1659 aarch64_linux_record_tdep.ioctl_TIOCSWINSZ = 0x5414;
1660 aarch64_linux_record_tdep.ioctl_TIOCMGET = 0x5415;
1661 aarch64_linux_record_tdep.ioctl_TIOCMBIS = 0x5416;
1662 aarch64_linux_record_tdep.ioctl_TIOCMBIC = 0x5417;
1663 aarch64_linux_record_tdep.ioctl_TIOCMSET = 0x5418;
1664 aarch64_linux_record_tdep.ioctl_TIOCGSOFTCAR = 0x5419;
1665 aarch64_linux_record_tdep.ioctl_TIOCSSOFTCAR = 0x541a;
1666 aarch64_linux_record_tdep.ioctl_FIONREAD = 0x541b;
1667 aarch64_linux_record_tdep.ioctl_TIOCINQ = 0x541b;
1668 aarch64_linux_record_tdep.ioctl_TIOCLINUX = 0x541c;
1669 aarch64_linux_record_tdep.ioctl_TIOCCONS = 0x541d;
1670 aarch64_linux_record_tdep.ioctl_TIOCGSERIAL = 0x541e;
1671 aarch64_linux_record_tdep.ioctl_TIOCSSERIAL = 0x541f;
1672 aarch64_linux_record_tdep.ioctl_TIOCPKT = 0x5420;
1673 aarch64_linux_record_tdep.ioctl_FIONBIO = 0x5421;
1674 aarch64_linux_record_tdep.ioctl_TIOCNOTTY = 0x5422;
1675 aarch64_linux_record_tdep.ioctl_TIOCSETD = 0x5423;
1676 aarch64_linux_record_tdep.ioctl_TIOCGETD = 0x5424;
1677 aarch64_linux_record_tdep.ioctl_TCSBRKP = 0x5425;
1678 aarch64_linux_record_tdep.ioctl_TIOCTTYGSTRUCT = 0x5426;
1679 aarch64_linux_record_tdep.ioctl_TIOCSBRK = 0x5427;
1680 aarch64_linux_record_tdep.ioctl_TIOCCBRK = 0x5428;
1681 aarch64_linux_record_tdep.ioctl_TIOCGSID = 0x5429;
1682 aarch64_linux_record_tdep.ioctl_TCGETS2 = 0x802c542a;
1683 aarch64_linux_record_tdep.ioctl_TCSETS2 = 0x402c542b;
1684 aarch64_linux_record_tdep.ioctl_TCSETSW2 = 0x402c542c;
1685 aarch64_linux_record_tdep.ioctl_TCSETSF2 = 0x402c542d;
1686 aarch64_linux_record_tdep.ioctl_TIOCGPTN = 0x80045430;
1687 aarch64_linux_record_tdep.ioctl_TIOCSPTLCK = 0x40045431;
1688 aarch64_linux_record_tdep.ioctl_FIONCLEX = 0x5450;
1689 aarch64_linux_record_tdep.ioctl_FIOCLEX = 0x5451;
1690 aarch64_linux_record_tdep.ioctl_FIOASYNC = 0x5452;
1691 aarch64_linux_record_tdep.ioctl_TIOCSERCONFIG = 0x5453;
1692 aarch64_linux_record_tdep.ioctl_TIOCSERGWILD = 0x5454;
1693 aarch64_linux_record_tdep.ioctl_TIOCSERSWILD = 0x5455;
1694 aarch64_linux_record_tdep.ioctl_TIOCGLCKTRMIOS = 0x5456;
1695 aarch64_linux_record_tdep.ioctl_TIOCSLCKTRMIOS = 0x5457;
1696 aarch64_linux_record_tdep.ioctl_TIOCSERGSTRUCT = 0x5458;
1697 aarch64_linux_record_tdep.ioctl_TIOCSERGETLSR = 0x5459;
1698 aarch64_linux_record_tdep.ioctl_TIOCSERGETMULTI = 0x545a;
1699 aarch64_linux_record_tdep.ioctl_TIOCSERSETMULTI = 0x545b;
1700 aarch64_linux_record_tdep.ioctl_TIOCMIWAIT = 0x545c;
1701 aarch64_linux_record_tdep.ioctl_TIOCGICOUNT = 0x545d;
1702 aarch64_linux_record_tdep.ioctl_TIOCGHAYESESP = 0x545e;
1703 aarch64_linux_record_tdep.ioctl_TIOCSHAYESESP = 0x545f;
1704 aarch64_linux_record_tdep.ioctl_FIOQSIZE = 0x5460;
1705
1706 /* These values are the second argument of system call "sys_fcntl"
1707 and "sys_fcntl64". They are obtained from Linux Kernel source. */
1708 aarch64_linux_record_tdep.fcntl_F_GETLK = 5;
1709 aarch64_linux_record_tdep.fcntl_F_GETLK64 = 12;
1710 aarch64_linux_record_tdep.fcntl_F_SETLK64 = 13;
1711 aarch64_linux_record_tdep.fcntl_F_SETLKW64 = 14;
1712
1713 /* The AArch64 syscall calling convention: reg x0-x6 for arguments,
1714 reg x8 for syscall number and return value in reg x0. */
1715 aarch64_linux_record_tdep.arg1 = AARCH64_X0_REGNUM + 0;
1716 aarch64_linux_record_tdep.arg2 = AARCH64_X0_REGNUM + 1;
1717 aarch64_linux_record_tdep.arg3 = AARCH64_X0_REGNUM + 2;
1718 aarch64_linux_record_tdep.arg4 = AARCH64_X0_REGNUM + 3;
1719 aarch64_linux_record_tdep.arg5 = AARCH64_X0_REGNUM + 4;
1720 aarch64_linux_record_tdep.arg6 = AARCH64_X0_REGNUM + 5;
1721 aarch64_linux_record_tdep.arg7 = AARCH64_X0_REGNUM + 6;
1722
f68f11b7
YQ		 1723 /* `catch syscall' */
1724 set_xml_syscall_file_name (gdbarch, "syscalls/aarch64-linux.xml");
1725 set_gdbarch_get_syscall_number (gdbarch, aarch64_linux_get_syscall_number);
b6542f81
YQ		 1726
1727 /* Displaced stepping. */
e935475c 1728 set_gdbarch_max_insn_length (gdbarch, 4 * AARCH64_DISPLACED_MODIFIED_INSNS);
b6542f81
YQ		 1729 set_gdbarch_displaced_step_copy_insn (gdbarch,
1730 aarch64_displaced_step_copy_insn);
1731 set_gdbarch_displaced_step_fixup (gdbarch, aarch64_displaced_step_fixup);
b6542f81
YQ		 1732 set_gdbarch_displaced_step_hw_singlestep (gdbarch,
1733 aarch64_displaced_step_hw_singlestep);
7045b1ca
YQ		 1734
1735 set_gdbarch_gcc_target_options (gdbarch, aarch64_linux_gcc_target_options);
1ae3db19
MS		 1736}
1737
6c265988 1738void _initialize_aarch64_linux_tdep ();
1ae3db19 1739void
6c265988 1740_initialize_aarch64_linux_tdep ()
1ae3db19
MS		 1741{
1742 gdbarch_register_osabi (bfd_arch_aarch64, 0, GDB_OSABI_LINUX,
1743 aarch64_linux_init_abi);
1744}
GDB Binutils - Deliverables
This page took 0.560348 seconds and 4 git commands to generate.