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