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