GDB (xrefs)
Loading...
Searching...
No Matches
aarch64-linux-tdep.c
Go to the documentation of this file.
1/* Target-dependent code for GNU/Linux AArch64.
2
3 Copyright (C) 2009-2023 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#include "auxv.h"
37
38#include "regcache.h"
39#include "regset.h"
40
41#include "stap-probe.h"
42#include "parser-defs.h"
43#include "user-regs.h"
44#include "xml-syscall.h"
45#include <ctype.h>
46
47#include "record-full.h"
48#include "linux-record.h"
49
51
52#include "arch-utils.h"
53#include "value.h"
54
55#include "gdbsupport/selftest.h"
56
57#include "elf/common.h"
58#include "elf/aarch64.h"
59
60/* Signal frame handling.
61
62 +------------+ ^
63 | saved lr | |
64 +->| saved fp |--+
65 | | |
66 | | |
67 | +------------+
68 | | saved lr |
69 +--| saved fp |
70 ^ | |
71 | | |
72 | +------------+
73 ^ | |
74 | | signal |
75 | | | SIGTRAMP_FRAME (struct rt_sigframe)
76 | | saved regs |
77 +--| saved sp |--> interrupted_sp
78 | | saved pc |--> interrupted_pc
79 | | |
80 | +------------+
81 | | saved lr |--> default_restorer (movz x8, NR_sys_rt_sigreturn; svc 0)
82 +--| saved fp |<- FP
83 | | NORMAL_FRAME
84 | |<- SP
85 +------------+
86
87 On signal delivery, the kernel will create a signal handler stack
88 frame and setup the return address in LR to point at restorer stub.
89 The signal stack frame is defined by:
90
91 struct rt_sigframe
92 {
93 siginfo_t info;
94 struct ucontext uc;
95 };
96
97 The ucontext has the following form:
98 struct ucontext
99 {
100 unsigned long uc_flags;
101 struct ucontext *uc_link;
102 stack_t uc_stack;
103 sigset_t uc_sigmask;
104 struct sigcontext uc_mcontext;
105 };
106
107 struct sigcontext
108 {
109 unsigned long fault_address;
110 unsigned long regs[31];
111 unsigned long sp; / * 31 * /
112 unsigned long pc; / * 32 * /
113 unsigned long pstate; / * 33 * /
114 __u8 __reserved[4096]
115 };
116
117 The reserved space in sigcontext contains additional structures, each starting
118 with a aarch64_ctx, which specifies a unique identifier and the total size of
119 the structure. The final structure in reserved will start will a null
120 aarch64_ctx. The penultimate entry in reserved may be a extra_context which
121 then points to a further block of reserved space.
122
123 struct aarch64_ctx {
124 u32 magic;
125 u32 size;
126 };
127
128 The restorer stub will always have the form:
129
130 d28015a8 movz x8, #0xad
131 d4000001 svc #0x0
132
133 This is a system call sys_rt_sigreturn.
134
135 We detect signal frames by snooping the return code for the restorer
136 instruction sequence.
137
138 The handler then needs to recover the saved register set from
139 ucontext.uc_mcontext. */
140
141/* These magic numbers need to reflect the layout of the kernel
142 defined struct rt_sigframe and ucontext. */
143#define AARCH64_SIGCONTEXT_REG_SIZE 8
144#define AARCH64_RT_SIGFRAME_UCONTEXT_OFFSET 128
145#define AARCH64_UCONTEXT_SIGCONTEXT_OFFSET 176
146#define AARCH64_SIGCONTEXT_XO_OFFSET 8
147#define AARCH64_SIGCONTEXT_RESERVED_OFFSET 288
148
149#define AARCH64_SIGCONTEXT_RESERVED_SIZE 4096
150
151/* Unique identifiers that may be used for aarch64_ctx.magic. */
152#define AARCH64_EXTRA_MAGIC 0x45585401
153#define AARCH64_FPSIMD_MAGIC 0x46508001
154#define AARCH64_SVE_MAGIC 0x53564501
155
156/* Defines for the extra_context that follows an AARCH64_EXTRA_MAGIC. */
157#define AARCH64_EXTRA_DATAP_OFFSET 8
158
159/* Defines for the fpsimd that follows an AARCH64_FPSIMD_MAGIC. */
160#define AARCH64_FPSIMD_FPSR_OFFSET 8
161#define AARCH64_FPSIMD_FPCR_OFFSET 12
162#define AARCH64_FPSIMD_V0_OFFSET 16
163#define AARCH64_FPSIMD_VREG_SIZE 16
164
165/* Defines for the sve structure that follows an AARCH64_SVE_MAGIC. */
166#define AARCH64_SVE_CONTEXT_VL_OFFSET 8
167#define AARCH64_SVE_CONTEXT_REGS_OFFSET 16
168#define AARCH64_SVE_CONTEXT_P_REGS_OFFSET(vq) (32 * vq * 16)
169#define AARCH64_SVE_CONTEXT_FFR_OFFSET(vq) \
170 (AARCH64_SVE_CONTEXT_P_REGS_OFFSET (vq) + (16 * vq * 2))
171#define AARCH64_SVE_CONTEXT_SIZE(vq) \
172 (AARCH64_SVE_CONTEXT_FFR_OFFSET (vq) + (vq * 2))
173
174
175/* Read an aarch64_ctx, returning the magic value, and setting *SIZE to the
176 size, or return 0 on error. */
177
178static uint32_t
179read_aarch64_ctx (CORE_ADDR ctx_addr, enum bfd_endian byte_order,
180 uint32_t *size)
181{
182 uint32_t magic = 0;
183 gdb_byte buf[4];
184
185 if (target_read_memory (ctx_addr, buf, 4) != 0)
186 return 0;
187 magic = extract_unsigned_integer (buf, 4, byte_order);
188
189 if (target_read_memory (ctx_addr + 4, buf, 4) != 0)
190 return 0;
191 *size = extract_unsigned_integer (buf, 4, byte_order);
192
193 return magic;
194}
195
196/* Given CACHE, use the trad_frame* functions to restore the FPSIMD
197 registers from a signal frame.
198
199 VREG_NUM is the number of the V register being restored, OFFSET is the
200 address containing the register value, BYTE_ORDER is the endianness and
201 HAS_SVE tells us if we have a valid SVE context or not. */
202
203static void
204aarch64_linux_restore_vreg (struct trad_frame_cache *cache, int num_regs,
205 int vreg_num, CORE_ADDR offset,
206 enum bfd_endian byte_order, bool has_sve)
207{
208 /* WARNING: SIMD state is laid out in memory in target-endian format.
209
210 So we have a couple cases to consider:
211
212 1 - If the target is big endian, then SIMD state is big endian,
213 requiring a byteswap.
214
215 2 - If the target is little endian, then SIMD state is little endian, so
216 no byteswap is needed. */
217
218 if (byte_order == BFD_ENDIAN_BIG)
219 {
220 gdb_byte buf[V_REGISTER_SIZE];
221
222 if (target_read_memory (offset, buf, V_REGISTER_SIZE) != 0)
223 {
224 size_t size = V_REGISTER_SIZE/2;
225
226 /* Read the two halves of the V register in reverse byte order. */
227 CORE_ADDR u64 = extract_unsigned_integer (buf, size,
228 byte_order);
229 CORE_ADDR l64 = extract_unsigned_integer (buf + size, size,
230 byte_order);
231
232 /* Copy the reversed bytes to the buffer. */
233 store_unsigned_integer (buf, size, BFD_ENDIAN_LITTLE, l64);
234 store_unsigned_integer (buf + size , size, BFD_ENDIAN_LITTLE, u64);
235
236 /* Now we can store the correct bytes for the V register. */
238 {buf, V_REGISTER_SIZE});
240 num_regs + AARCH64_Q0_REGNUM
241 + vreg_num, {buf, Q_REGISTER_SIZE});
243 num_regs + AARCH64_D0_REGNUM
244 + vreg_num, {buf, D_REGISTER_SIZE});
246 num_regs + AARCH64_S0_REGNUM
247 + vreg_num, {buf, S_REGISTER_SIZE});
249 num_regs + AARCH64_H0_REGNUM
250 + vreg_num, {buf, H_REGISTER_SIZE});
252 num_regs + AARCH64_B0_REGNUM
253 + vreg_num, {buf, B_REGISTER_SIZE});
254
255 if (has_sve)
257 num_regs + AARCH64_SVE_V0_REGNUM
258 + vreg_num, {buf, V_REGISTER_SIZE});
259 }
260 return;
261 }
262
263 /* Little endian, just point at the address containing the register
264 value. */
265 trad_frame_set_reg_addr (cache, AARCH64_V0_REGNUM + vreg_num, offset);
266 trad_frame_set_reg_addr (cache, num_regs + AARCH64_Q0_REGNUM + vreg_num,
267 offset);
268 trad_frame_set_reg_addr (cache, num_regs + AARCH64_D0_REGNUM + vreg_num,
269 offset);
270 trad_frame_set_reg_addr (cache, num_regs + AARCH64_S0_REGNUM + vreg_num,
271 offset);
272 trad_frame_set_reg_addr (cache, num_regs + AARCH64_H0_REGNUM + vreg_num,
273 offset);
274 trad_frame_set_reg_addr (cache, num_regs + AARCH64_B0_REGNUM + vreg_num,
275 offset);
276
277 if (has_sve)
279 + vreg_num, offset);
280
281}
282
283/* Implement the "init" method of struct tramp_frame. */
284
285static void
287 frame_info_ptr this_frame,
288 struct trad_frame_cache *this_cache,
289 CORE_ADDR func)
290{
291 struct gdbarch *gdbarch = get_frame_arch (this_frame);
292 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
293 aarch64_gdbarch_tdep *tdep = gdbarch_tdep<aarch64_gdbarch_tdep> (gdbarch);
294 CORE_ADDR sp = get_frame_register_unsigned (this_frame, AARCH64_SP_REGNUM);
295 CORE_ADDR sigcontext_addr = (sp + AARCH64_RT_SIGFRAME_UCONTEXT_OFFSET
297 CORE_ADDR section = sigcontext_addr + AARCH64_SIGCONTEXT_RESERVED_OFFSET;
298 CORE_ADDR section_end = section + AARCH64_SIGCONTEXT_RESERVED_SIZE;
299 CORE_ADDR fpsimd = 0;
300 CORE_ADDR sve_regs = 0;
301 uint32_t size, magic;
302 bool extra_found = false;
303 int num_regs = gdbarch_num_regs (gdbarch);
304
305 /* Read in the integer registers. */
306
307 for (int i = 0; i < 31; i++)
308 {
309 trad_frame_set_reg_addr (this_cache,
311 sigcontext_addr + AARCH64_SIGCONTEXT_XO_OFFSET
313 }
315 sigcontext_addr + AARCH64_SIGCONTEXT_XO_OFFSET
318 sigcontext_addr + AARCH64_SIGCONTEXT_XO_OFFSET
320
321 /* Search for the FP and SVE sections, stopping at null. */
322 while ((magic = read_aarch64_ctx (section, byte_order, &size)) != 0
323 && size != 0)
324 {
325 switch (magic)
326 {
328 fpsimd = section;
329 section += size;
330 break;
331
333 {
334 /* Check if the section is followed by a full SVE dump, and set
335 sve_regs if it is. */
336 gdb_byte buf[4];
337 uint16_t vq;
338
339 if (!tdep->has_sve ())
340 break;
341
343 buf, 2) != 0)
344 {
345 section += size;
346 break;
347 }
348 vq = sve_vq_from_vl (extract_unsigned_integer (buf, 2, byte_order));
349
350 if (vq != tdep->vq)
351 error (_("Invalid vector length in signal frame %d vs %s."), vq,
352 pulongest (tdep->vq));
353
354 if (size >= AARCH64_SVE_CONTEXT_SIZE (vq))
355 sve_regs = section + AARCH64_SVE_CONTEXT_REGS_OFFSET;
356
357 section += size;
358 break;
359 }
360
362 {
363 /* Extra is always the last valid section in reserved and points to
364 an additional block of memory filled with more sections. Reset
365 the address to the extra section and continue looking for more
366 structures. */
367 gdb_byte buf[8];
368
370 buf, 8) != 0)
371 {
372 section += size;
373 break;
374 }
375
376 section = extract_unsigned_integer (buf, 8, byte_order);
377 extra_found = true;
378 break;
379 }
380
381 default:
382 section += size;
383 break;
384 }
385
386 /* Prevent searching past the end of the reserved section. The extra
387 section does not have a hard coded limit - we have to rely on it ending
388 with nulls. */
389 if (!extra_found && section > section_end)
390 break;
391 }
392
393 if (sve_regs != 0)
394 {
395 CORE_ADDR offset;
396
397 for (int i = 0; i < 32; i++)
398 {
399 offset = sve_regs + (i * tdep->vq * 16);
401 offset);
402 trad_frame_set_reg_addr (this_cache,
403 num_regs + AARCH64_SVE_V0_REGNUM + i,
404 offset);
405 trad_frame_set_reg_addr (this_cache, num_regs + AARCH64_Q0_REGNUM + i,
406 offset);
407 trad_frame_set_reg_addr (this_cache, num_regs + AARCH64_D0_REGNUM + i,
408 offset);
409 trad_frame_set_reg_addr (this_cache, num_regs + AARCH64_S0_REGNUM + i,
410 offset);
411 trad_frame_set_reg_addr (this_cache, num_regs + AARCH64_H0_REGNUM + i,
412 offset);
413 trad_frame_set_reg_addr (this_cache, num_regs + AARCH64_B0_REGNUM + i,
414 offset);
415 }
416
417 offset = sve_regs + AARCH64_SVE_CONTEXT_P_REGS_OFFSET (tdep->vq);
418 for (int i = 0; i < 16; i++)
420 offset + (i * tdep->vq * 2));
421
422 offset = sve_regs + AARCH64_SVE_CONTEXT_FFR_OFFSET (tdep->vq);
424 }
425
426 if (fpsimd != 0)
427 {
432
433 /* If there was no SVE section then set up the V registers. */
434 if (sve_regs == 0)
435 {
436 for (int i = 0; i < 32; i++)
437 {
438 CORE_ADDR offset = (fpsimd + AARCH64_FPSIMD_V0_OFFSET
440
441 aarch64_linux_restore_vreg (this_cache, num_regs, i, offset,
442 byte_order, tdep->has_sve ());
443 }
444 }
445 }
446
447 trad_frame_set_id (this_cache, frame_id_build (sp, func));
448}
449
451{
453 4,
454 {
455 /* movz x8, 0x8b (S=1,o=10,h=0,i=0x8b,r=8)
456 Soo1 0010 1hhi iiii iiii iiii iiir rrrr */
457 {0xd2801168, ULONGEST_MAX},
458
459 /* svc 0x0 (o=0, l=1)
460 1101 0100 oooi iiii iiii iiii iii0 00ll */
461 {0xd4000001, ULONGEST_MAX},
463 },
465};
466
467/* Register maps. */
468
470 {
471 { 31, AARCH64_X0_REGNUM, 8 }, /* x0 ... x30 */
472 { 1, AARCH64_SP_REGNUM, 8 },
473 { 1, AARCH64_PC_REGNUM, 8 },
474 { 1, AARCH64_CPSR_REGNUM, 8 },
475 { 0 }
476 };
477
479 {
480 { 32, AARCH64_V0_REGNUM, 16 }, /* v0 ... v31 */
481 { 1, AARCH64_FPSR_REGNUM, 4 },
482 { 1, AARCH64_FPCR_REGNUM, 4 },
483 { 0 }
484 };
485
486/* Register set definitions. */
487
489 {
492 };
493
495 {
498 };
499
500/* The fields in an SVE header at the start of a SVE regset. */
501
502#define SVE_HEADER_SIZE_LENGTH 4
503#define SVE_HEADER_MAX_SIZE_LENGTH 4
504#define SVE_HEADER_VL_LENGTH 2
505#define SVE_HEADER_MAX_VL_LENGTH 2
506#define SVE_HEADER_FLAGS_LENGTH 2
507#define SVE_HEADER_RESERVED_LENGTH 2
508
509#define SVE_HEADER_SIZE_OFFSET 0
510#define SVE_HEADER_MAX_SIZE_OFFSET \
511 (SVE_HEADER_SIZE_OFFSET + SVE_HEADER_SIZE_LENGTH)
512#define SVE_HEADER_VL_OFFSET \
513 (SVE_HEADER_MAX_SIZE_OFFSET + SVE_HEADER_MAX_SIZE_LENGTH)
514#define SVE_HEADER_MAX_VL_OFFSET \
515 (SVE_HEADER_VL_OFFSET + SVE_HEADER_VL_LENGTH)
516#define SVE_HEADER_FLAGS_OFFSET \
517 (SVE_HEADER_MAX_VL_OFFSET + SVE_HEADER_MAX_VL_LENGTH)
518#define SVE_HEADER_RESERVED_OFFSET \
519 (SVE_HEADER_FLAGS_OFFSET + SVE_HEADER_FLAGS_LENGTH)
520#define SVE_HEADER_SIZE \
521 (SVE_HEADER_RESERVED_OFFSET + SVE_HEADER_RESERVED_LENGTH)
522
523#define SVE_HEADER_FLAG_SVE 1
524
525/* Get VQ value from SVE section in the core dump. */
526
527static uint64_t
529{
530 gdb_byte header[SVE_HEADER_SIZE];
531 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
532 asection *sve_section = bfd_get_section_by_name (abfd, ".reg-aarch-sve");
533
534 if (sve_section == nullptr)
535 {
536 /* No SVE state. */
537 return 0;
538 }
539
540 size_t size = bfd_section_size (sve_section);
541
542 /* Check extended state size. */
543 if (size < SVE_HEADER_SIZE)
544 {
545 warning (_("'.reg-aarch-sve' section in core file too small."));
546 return 0;
547 }
548
549 if (!bfd_get_section_contents (abfd, sve_section, header, 0, SVE_HEADER_SIZE))
550 {
551 warning (_("Couldn't read sve header from "
552 "'.reg-aarch-sve' section in core file."));
553 return 0;
554 }
555
556 uint64_t vl = extract_unsigned_integer (header + SVE_HEADER_VL_OFFSET,
557 SVE_HEADER_VL_LENGTH, byte_order);
558 uint64_t vq = sve_vq_from_vl (vl);
559
560 if (vq > AARCH64_MAX_SVE_VQ)
561 {
562 warning (_("SVE Vector length in core file not supported by this version"
563 " of GDB. (VQ=%s)"), pulongest (vq));
564 return 0;
565 }
566 else if (vq == 0)
567 {
568 warning (_("SVE Vector length in core file is invalid. (VQ=%s"),
569 pulongest (vq));
570 return 0;
571 }
572
573 return vq;
574}
575
576/* Supply register REGNUM from BUF to REGCACHE, using the register map
577 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
578 If BUF is NULL, set the registers to "unavailable" status. */
579
580static void
582 struct regcache *regcache,
583 int regnum, const void *buf, size_t size)
584{
585 gdb_byte *header = (gdb_byte *) buf;
586 struct gdbarch *gdbarch = regcache->arch ();
587 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
588
589 if (buf == nullptr)
590 return regcache->supply_regset (regset, regnum, nullptr, size);
591 gdb_assert (size > SVE_HEADER_SIZE);
592
593 /* BUF contains an SVE header followed by a register dump of either the
594 passed in SVE regset or a NEON fpregset. */
595
596 /* Extract required fields from the header. */
597 ULONGEST vl = extract_unsigned_integer (header + SVE_HEADER_VL_OFFSET,
598 SVE_HEADER_VL_LENGTH, byte_order);
601 byte_order);
602
603 if (regnum == -1 || regnum == AARCH64_SVE_VG_REGNUM)
604 {
605 gdb_byte vg_target[8];
606 store_integer ((gdb_byte *)&vg_target, sizeof (uint64_t), byte_order,
607 sve_vg_from_vl (vl));
609 }
610
612 {
613 /* Register dump is a SVE structure. */
615 (gdb_byte *) buf + SVE_HEADER_SIZE,
617 }
618 else
619 {
620 /* Register dump is a fpsimd structure. First clear the SVE
621 registers. */
622 for (int i = 0; i < AARCH64_SVE_Z_REGS_NUM; i++)
624 for (int i = 0; i < AARCH64_SVE_P_REGS_NUM; i++)
627
628 /* Then supply the fpsimd registers. */
630 (gdb_byte *) buf + SVE_HEADER_SIZE,
632 }
633}
634
635/* Collect register REGNUM from REGCACHE to BUF, using the register
636 map in REGSET. If REGNUM is -1, do this for all registers in
637 REGSET. */
638
639static void
641 const struct regcache *regcache,
642 int regnum, void *buf, size_t size)
643{
644 gdb_byte *header = (gdb_byte *) buf;
645 struct gdbarch *gdbarch = regcache->arch ();
646 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
647 aarch64_gdbarch_tdep *tdep = gdbarch_tdep<aarch64_gdbarch_tdep> (gdbarch);
648 uint64_t vq = tdep->vq;
649
650 gdb_assert (buf != NULL);
651 gdb_assert (size > SVE_HEADER_SIZE);
652
653 /* BUF starts with a SVE header prior to the register dump. */
654
656 SVE_HEADER_SIZE_LENGTH, byte_order, size);
658 SVE_HEADER_MAX_SIZE_LENGTH, byte_order, size);
660 byte_order, sve_vl_from_vq (vq));
662 SVE_HEADER_MAX_VL_LENGTH, byte_order,
663 sve_vl_from_vq (vq));
665 SVE_HEADER_FLAGS_LENGTH, byte_order,
668 SVE_HEADER_RESERVED_LENGTH, byte_order, 0);
669
670 /* The SVE register dump follows. */
671 regcache->collect_regset (regset, regnum, (gdb_byte *) buf + SVE_HEADER_SIZE,
673}
674
675/* Implement the "iterate_over_regset_sections" gdbarch method. */
676
677static void
680 void *cb_data,
681 const struct regcache *regcache)
682{
683 aarch64_gdbarch_tdep *tdep = gdbarch_tdep<aarch64_gdbarch_tdep> (gdbarch);
684
686 &aarch64_linux_gregset, NULL, cb_data);
687
688 if (tdep->has_sve ())
689 {
690 /* Create this on the fly in order to handle vector register sizes. */
691 const struct regcache_map_entry sve_regmap[] =
692 {
693 { 32, AARCH64_SVE_Z0_REGNUM, (int) (tdep->vq * 16) },
694 { 16, AARCH64_SVE_P0_REGNUM, (int) (tdep->vq * 16 / 8) },
695 { 1, AARCH64_SVE_FFR_REGNUM, (int) (tdep->vq * 16 / 8) },
696 { 1, AARCH64_FPSR_REGNUM, 4 },
697 { 1, AARCH64_FPCR_REGNUM, 4 },
698 { 0 }
699 };
700
701 const struct regset aarch64_linux_sve_regset =
702 {
703 sve_regmap,
706 };
707
708 cb (".reg-aarch-sve",
711 &aarch64_linux_sve_regset, "SVE registers", cb_data);
712 }
713 else
715 &aarch64_linux_fpregset, NULL, cb_data);
716
717
718 if (tdep->has_pauth ())
719 {
720 /* Create this on the fly in order to handle the variable location. */
721 const struct regcache_map_entry pauth_regmap[] =
722 {
724 { 0 }
725 };
726
727 const struct regset aarch64_linux_pauth_regset =
728 {
730 };
731
732 cb (".reg-aarch-pauth", AARCH64_LINUX_SIZEOF_PAUTH,
733 AARCH64_LINUX_SIZEOF_PAUTH, &aarch64_linux_pauth_regset,
734 "pauth registers", cb_data);
735 }
736
737 /* Handle MTE registers. */
738 if (tdep->has_mte ())
739 {
740 /* Create this on the fly in order to handle the variable location. */
741 const struct regcache_map_entry mte_regmap[] =
742 {
743 { 1, tdep->mte_reg_base, 8},
744 { 0 }
745 };
746
747 const struct regset aarch64_linux_mte_regset =
748 {
750 };
751
752 cb (".reg-aarch-mte", AARCH64_LINUX_SIZEOF_MTE_REGSET,
753 AARCH64_LINUX_SIZEOF_MTE_REGSET, &aarch64_linux_mte_regset,
754 "MTE registers", cb_data);
755 }
756
757 /* Handle the TLS registers. */
758 if (tdep->has_tls ())
759 {
760 gdb_assert (tdep->tls_regnum_base != -1);
761 gdb_assert (tdep->tls_register_count > 0);
762
763 int sizeof_tls_regset
765
766 const struct regcache_map_entry tls_regmap[] =
767 {
768 { tdep->tls_register_count, tdep->tls_regnum_base,
770 { 0 }
771 };
772
773 const struct regset aarch64_linux_tls_regset =
774 {
777 };
778
779 cb (".reg-aarch-tls", sizeof_tls_regset, sizeof_tls_regset,
780 &aarch64_linux_tls_regset, "TLS register", cb_data);
781 }
782}
783
784/* Implement the "core_read_description" gdbarch method. */
785
786static const struct target_desc *
788 struct target_ops *target, bfd *abfd)
789{
790 gdb::optional<gdb::byte_vector> auxv = target_read_auxv_raw (target);
791 CORE_ADDR hwcap = linux_get_hwcap (auxv, target, gdbarch);
792 CORE_ADDR hwcap2 = linux_get_hwcap2 (auxv, target, gdbarch);
793
796 features.pauth = hwcap & AARCH64_HWCAP_PACA;
797 features.mte = hwcap2 & HWCAP2_MTE;
798
799 /* Handle the TLS section. */
800 asection *tls = bfd_get_section_by_name (abfd, ".reg-aarch-tls");
801 if (tls != nullptr)
802 {
803 size_t size = bfd_section_size (tls);
804 /* Convert the size to the number of actual registers, by
805 dividing by 8. */
807 }
808
810}
811
812/* Implementation of `gdbarch_stap_is_single_operand', as defined in
813 gdbarch.h. */
814
815static int
817{
818 return (*s == '#' || isdigit (*s) /* Literal number. */
819 || *s == '[' /* Register indirection. */
820 || isalpha (*s)); /* Register value. */
821}
822
823/* This routine is used to parse a special token in AArch64's assembly.
824
825 The special tokens parsed by it are:
826
827 - Register displacement (e.g, [fp, #-8])
828
829 It returns one if the special token has been parsed successfully,
830 or zero if the current token is not considered special. */
831
834 struct stap_parse_info *p)
835{
836 if (*p->arg == '[')
837 {
838 /* Temporary holder for lookahead. */
839 const char *tmp = p->arg;
840 char *endp;
841 /* Used to save the register name. */
842 const char *start;
843 int len;
844 int got_minus = 0;
845 long displacement;
846
847 ++tmp;
848 start = tmp;
849
850 /* Register name. */
851 while (isalnum (*tmp))
852 ++tmp;
853
854 if (*tmp != ',')
855 return {};
856
857 len = tmp - start;
858 std::string regname (start, len);
859
860 if (user_reg_map_name_to_regnum (gdbarch, regname.c_str (), len) == -1)
861 error (_("Invalid register name `%s' on expression `%s'."),
862 regname.c_str (), p->saved_arg);
863
864 ++tmp;
865 tmp = skip_spaces (tmp);
866 /* Now we expect a number. It can begin with '#' or simply
867 a digit. */
868 if (*tmp == '#')
869 ++tmp;
870
871 if (*tmp == '-')
872 {
873 ++tmp;
874 got_minus = 1;
875 }
876 else if (*tmp == '+')
877 ++tmp;
878
879 if (!isdigit (*tmp))
880 return {};
881
882 displacement = strtol (tmp, &endp, 10);
883 tmp = endp;
884
885 /* Skipping last `]'. */
886 if (*tmp++ != ']')
887 return {};
888 p->arg = tmp;
889
890 using namespace expr;
891
892 /* The displacement. */
893 struct type *long_type = builtin_type (gdbarch)->builtin_long;
894 if (got_minus)
895 displacement = -displacement;
896 operation_up disp = make_operation<long_const_operation> (long_type,
897 displacement);
898
899 /* The register name. */
900 operation_up reg
901 = make_operation<register_operation> (std::move (regname));
902
903 operation_up sum
904 = make_operation<add_operation> (std::move (reg), std::move (disp));
905
906 /* Casting to the expected type. */
907 struct type *arg_ptr_type = lookup_pointer_type (p->arg_type);
908 sum = make_operation<unop_cast_operation> (std::move (sum),
909 arg_ptr_type);
910 return make_operation<unop_ind_operation> (std::move (sum));
911 }
912 return {};
913}
914
915/* AArch64 process record-replay constructs: syscall, signal etc. */
916
918
919/* Enum that defines the AArch64 linux specific syscall identifiers used for
920 process record/replay. */
921
1185
1186/* aarch64_canonicalize_syscall maps syscall ids from the native AArch64
1187 linux set of syscall ids into a canonical set of syscall ids used by
1188 process record. */
1189
1190static enum gdb_syscall
1192{
1193#define SYSCALL_MAP(SYSCALL) case aarch64_sys_##SYSCALL: \
1194 return gdb_sys_##SYSCALL
1195
1196#define UNSUPPORTED_SYSCALL_MAP(SYSCALL) case aarch64_sys_##SYSCALL: \
1197 return gdb_sys_no_syscall
1198
1199 switch (syscall_number)
1200 {
1201 SYSCALL_MAP (io_setup);
1202 SYSCALL_MAP (io_destroy);
1203 SYSCALL_MAP (io_submit);
1204 SYSCALL_MAP (io_cancel);
1205 SYSCALL_MAP (io_getevents);
1206
1207 SYSCALL_MAP (setxattr);
1208 SYSCALL_MAP (lsetxattr);
1209 SYSCALL_MAP (fsetxattr);
1210 SYSCALL_MAP (getxattr);
1211 SYSCALL_MAP (lgetxattr);
1212 SYSCALL_MAP (fgetxattr);
1213 SYSCALL_MAP (listxattr);
1214 SYSCALL_MAP (llistxattr);
1215 SYSCALL_MAP (flistxattr);
1216 SYSCALL_MAP (removexattr);
1217 SYSCALL_MAP (lremovexattr);
1218 SYSCALL_MAP (fremovexattr);
1219 SYSCALL_MAP (getcwd);
1220 SYSCALL_MAP (lookup_dcookie);
1221 SYSCALL_MAP (eventfd2);
1222 SYSCALL_MAP (epoll_create1);
1223 SYSCALL_MAP (epoll_ctl);
1224 SYSCALL_MAP (epoll_pwait);
1225 SYSCALL_MAP (dup);
1226 SYSCALL_MAP (dup3);
1227 SYSCALL_MAP (fcntl);
1228 SYSCALL_MAP (inotify_init1);
1229 SYSCALL_MAP (inotify_add_watch);
1230 SYSCALL_MAP (inotify_rm_watch);
1231 SYSCALL_MAP (ioctl);
1232 SYSCALL_MAP (ioprio_set);
1233 SYSCALL_MAP (ioprio_get);
1234 SYSCALL_MAP (flock);
1235 SYSCALL_MAP (mknodat);
1236 SYSCALL_MAP (mkdirat);
1237 SYSCALL_MAP (unlinkat);
1238 SYSCALL_MAP (symlinkat);
1239 SYSCALL_MAP (linkat);
1240 SYSCALL_MAP (renameat);
1241 UNSUPPORTED_SYSCALL_MAP (umount2);
1242 SYSCALL_MAP (mount);
1243 SYSCALL_MAP (pivot_root);
1244 SYSCALL_MAP (nfsservctl);
1245 SYSCALL_MAP (statfs);
1246 SYSCALL_MAP (truncate);
1247 SYSCALL_MAP (ftruncate);
1248 SYSCALL_MAP (fallocate);
1249 SYSCALL_MAP (faccessat);
1250 SYSCALL_MAP (fchdir);
1251 SYSCALL_MAP (chroot);
1252 SYSCALL_MAP (fchmod);
1253 SYSCALL_MAP (fchmodat);
1254 SYSCALL_MAP (fchownat);
1255 SYSCALL_MAP (fchown);
1256 SYSCALL_MAP (openat);
1257 SYSCALL_MAP (close);
1258 SYSCALL_MAP (vhangup);
1259 SYSCALL_MAP (pipe2);
1260 SYSCALL_MAP (quotactl);
1261 SYSCALL_MAP (getdents64);
1262 SYSCALL_MAP (lseek);
1263 SYSCALL_MAP (read);
1264 SYSCALL_MAP (write);
1265 SYSCALL_MAP (readv);
1266 SYSCALL_MAP (writev);
1267 SYSCALL_MAP (pread64);
1268 SYSCALL_MAP (pwrite64);
1269 UNSUPPORTED_SYSCALL_MAP (preadv);
1270 UNSUPPORTED_SYSCALL_MAP (pwritev);
1271 SYSCALL_MAP (sendfile);
1272 SYSCALL_MAP (pselect6);
1273 SYSCALL_MAP (ppoll);
1274 UNSUPPORTED_SYSCALL_MAP (signalfd4);
1275 SYSCALL_MAP (vmsplice);
1276 SYSCALL_MAP (splice);
1277 SYSCALL_MAP (tee);
1278 SYSCALL_MAP (readlinkat);
1279 SYSCALL_MAP (newfstatat);
1280
1281 SYSCALL_MAP (fstat);
1282 SYSCALL_MAP (sync);
1283 SYSCALL_MAP (fsync);
1284 SYSCALL_MAP (fdatasync);
1285 SYSCALL_MAP (sync_file_range);
1286 UNSUPPORTED_SYSCALL_MAP (timerfd_create);
1287 UNSUPPORTED_SYSCALL_MAP (timerfd_settime);
1288 UNSUPPORTED_SYSCALL_MAP (timerfd_gettime);
1289 UNSUPPORTED_SYSCALL_MAP (utimensat);
1290 SYSCALL_MAP (acct);
1291 SYSCALL_MAP (capget);
1292 SYSCALL_MAP (capset);
1293 SYSCALL_MAP (personality);
1294 SYSCALL_MAP (exit);
1295 SYSCALL_MAP (exit_group);
1296 SYSCALL_MAP (waitid);
1297 SYSCALL_MAP (set_tid_address);
1298 SYSCALL_MAP (unshare);
1299 SYSCALL_MAP (futex);
1300 SYSCALL_MAP (set_robust_list);
1301 SYSCALL_MAP (get_robust_list);
1302 SYSCALL_MAP (nanosleep);
1303
1304 SYSCALL_MAP (getitimer);
1305 SYSCALL_MAP (setitimer);
1306 SYSCALL_MAP (kexec_load);
1307 SYSCALL_MAP (init_module);
1308 SYSCALL_MAP (delete_module);
1309 SYSCALL_MAP (timer_create);
1310 SYSCALL_MAP (timer_settime);
1311 SYSCALL_MAP (timer_gettime);
1312 SYSCALL_MAP (timer_getoverrun);
1313 SYSCALL_MAP (timer_delete);
1314 SYSCALL_MAP (clock_settime);
1315 SYSCALL_MAP (clock_gettime);
1316 SYSCALL_MAP (clock_getres);
1317 SYSCALL_MAP (clock_nanosleep);
1318 SYSCALL_MAP (syslog);
1320 SYSCALL_MAP (sched_setparam);
1321 SYSCALL_MAP (sched_setscheduler);
1322 SYSCALL_MAP (sched_getscheduler);
1323 SYSCALL_MAP (sched_getparam);
1324 SYSCALL_MAP (sched_setaffinity);
1325 SYSCALL_MAP (sched_getaffinity);
1326 SYSCALL_MAP (sched_yield);
1327 SYSCALL_MAP (sched_get_priority_max);
1328 SYSCALL_MAP (sched_get_priority_min);
1329 SYSCALL_MAP (sched_rr_get_interval);
1330 SYSCALL_MAP (kill);
1331 SYSCALL_MAP (tkill);
1332 SYSCALL_MAP (tgkill);
1333 SYSCALL_MAP (sigaltstack);
1334 SYSCALL_MAP (rt_sigsuspend);
1335 SYSCALL_MAP (rt_sigaction);
1336 SYSCALL_MAP (rt_sigprocmask);
1337 SYSCALL_MAP (rt_sigpending);
1338 SYSCALL_MAP (rt_sigtimedwait);
1339 SYSCALL_MAP (rt_sigqueueinfo);
1340 SYSCALL_MAP (rt_sigreturn);
1341 SYSCALL_MAP (setpriority);
1342 SYSCALL_MAP (getpriority);
1343 SYSCALL_MAP (reboot);
1344 SYSCALL_MAP (setregid);
1345 SYSCALL_MAP (setgid);
1346 SYSCALL_MAP (setreuid);
1347 SYSCALL_MAP (setuid);
1348 SYSCALL_MAP (setresuid);
1349 SYSCALL_MAP (getresuid);
1350 SYSCALL_MAP (setresgid);
1351 SYSCALL_MAP (getresgid);
1352 SYSCALL_MAP (setfsuid);
1353 SYSCALL_MAP (setfsgid);
1354 SYSCALL_MAP (times);
1355 SYSCALL_MAP (setpgid);
1356 SYSCALL_MAP (getpgid);
1357 SYSCALL_MAP (getsid);
1358 SYSCALL_MAP (setsid);
1359 SYSCALL_MAP (getgroups);
1360 SYSCALL_MAP (setgroups);
1361 SYSCALL_MAP (uname);
1362 SYSCALL_MAP (sethostname);
1363 SYSCALL_MAP (setdomainname);
1364 SYSCALL_MAP (getrlimit);
1365 SYSCALL_MAP (setrlimit);
1366 SYSCALL_MAP (getrusage);
1367 SYSCALL_MAP (umask);
1368 SYSCALL_MAP (prctl);
1369 SYSCALL_MAP (getcpu);
1370 SYSCALL_MAP (gettimeofday);
1371 SYSCALL_MAP (settimeofday);
1372 SYSCALL_MAP (adjtimex);
1373 SYSCALL_MAP (getpid);
1374 SYSCALL_MAP (getppid);
1375 SYSCALL_MAP (getuid);
1376 SYSCALL_MAP (geteuid);
1377 SYSCALL_MAP (getgid);
1378 SYSCALL_MAP (getegid);
1379 SYSCALL_MAP (gettid);
1380 SYSCALL_MAP (sysinfo);
1381 SYSCALL_MAP (mq_open);
1382 SYSCALL_MAP (mq_unlink);
1383 SYSCALL_MAP (mq_timedsend);
1384 SYSCALL_MAP (mq_timedreceive);
1385 SYSCALL_MAP (mq_notify);
1386 SYSCALL_MAP (mq_getsetattr);
1387 SYSCALL_MAP (msgget);
1388 SYSCALL_MAP (msgctl);
1389 SYSCALL_MAP (msgrcv);
1390 SYSCALL_MAP (msgsnd);
1391 SYSCALL_MAP (semget);
1392 SYSCALL_MAP (semctl);
1393 SYSCALL_MAP (semtimedop);
1394 SYSCALL_MAP (semop);
1395 SYSCALL_MAP (shmget);
1396 SYSCALL_MAP (shmctl);
1397 SYSCALL_MAP (shmat);
1398 SYSCALL_MAP (shmdt);
1399 SYSCALL_MAP (socket);
1400 SYSCALL_MAP (socketpair);
1401 SYSCALL_MAP (bind);
1402 SYSCALL_MAP (listen);
1403 SYSCALL_MAP (accept);
1404 SYSCALL_MAP (connect);
1405 SYSCALL_MAP (getsockname);
1406 SYSCALL_MAP (getpeername);
1407 SYSCALL_MAP (sendto);
1408 SYSCALL_MAP (recvfrom);
1409 SYSCALL_MAP (setsockopt);
1410 SYSCALL_MAP (getsockopt);
1411 SYSCALL_MAP (shutdown);
1412 SYSCALL_MAP (sendmsg);
1413 SYSCALL_MAP (recvmsg);
1414 SYSCALL_MAP (readahead);
1415 SYSCALL_MAP (brk);
1416 SYSCALL_MAP (munmap);
1417 SYSCALL_MAP (mremap);
1418 SYSCALL_MAP (add_key);
1419 SYSCALL_MAP (request_key);
1420 SYSCALL_MAP (keyctl);
1421 SYSCALL_MAP (clone);
1422 SYSCALL_MAP (execve);
1423
1424 case aarch64_sys_mmap:
1425 return gdb_sys_mmap2;
1426
1427 SYSCALL_MAP (fadvise64);
1428 SYSCALL_MAP (swapon);
1429 SYSCALL_MAP (swapoff);
1430 SYSCALL_MAP (mprotect);
1431 SYSCALL_MAP (msync);
1432 SYSCALL_MAP (mlock);
1433 SYSCALL_MAP (munlock);
1434 SYSCALL_MAP (mlockall);
1435 SYSCALL_MAP (munlockall);
1436 SYSCALL_MAP (mincore);
1437 SYSCALL_MAP (madvise);
1438 SYSCALL_MAP (remap_file_pages);
1439 SYSCALL_MAP (mbind);
1440 SYSCALL_MAP (get_mempolicy);
1441 SYSCALL_MAP (set_mempolicy);
1442 SYSCALL_MAP (migrate_pages);
1443 SYSCALL_MAP (move_pages);
1444 UNSUPPORTED_SYSCALL_MAP (rt_tgsigqueueinfo);
1445 UNSUPPORTED_SYSCALL_MAP (perf_event_open);
1446 UNSUPPORTED_SYSCALL_MAP (accept4);
1447 UNSUPPORTED_SYSCALL_MAP (recvmmsg);
1448
1449 SYSCALL_MAP (wait4);
1450
1451 UNSUPPORTED_SYSCALL_MAP (prlimit64);
1452 UNSUPPORTED_SYSCALL_MAP (fanotify_init);
1453 UNSUPPORTED_SYSCALL_MAP (fanotify_mark);
1454 UNSUPPORTED_SYSCALL_MAP (name_to_handle_at);
1455 UNSUPPORTED_SYSCALL_MAP (open_by_handle_at);
1456 UNSUPPORTED_SYSCALL_MAP (clock_adjtime);
1457 UNSUPPORTED_SYSCALL_MAP (syncfs);
1459 UNSUPPORTED_SYSCALL_MAP (sendmmsg);
1460 UNSUPPORTED_SYSCALL_MAP (process_vm_readv);
1461 UNSUPPORTED_SYSCALL_MAP (process_vm_writev);
1463 UNSUPPORTED_SYSCALL_MAP (finit_module);
1464 UNSUPPORTED_SYSCALL_MAP (sched_setattr);
1465 UNSUPPORTED_SYSCALL_MAP (sched_getattr);
1466 SYSCALL_MAP (getrandom);
1467 default:
1468 return gdb_sys_no_syscall;
1469 }
1470}
1471
1472/* Retrieve the syscall number at a ptrace syscall-stop, either on syscall entry
1473 or exit. Return -1 upon error. */
1474
1475static LONGEST
1477{
1478 struct regcache *regs = get_thread_regcache (thread);
1479 LONGEST ret;
1480
1481 /* Get the system call number from register x8. */
1482 regs->cooked_read (AARCH64_X0_REGNUM + 8, &ret);
1483
1484 /* On exit from a successful execve, we will be in a new process and all the
1485 registers will be cleared - x0 to x30 will be 0, except for a 1 in x7.
1486 This function will only ever get called when stopped at the entry or exit
1487 of a syscall, so by checking for 0 in x0 (arg0/retval), x1 (arg1), x8
1488 (syscall), x29 (FP) and x30 (LR) we can infer:
1489 1) Either inferior is at exit from successful execve.
1490 2) Or inferior is at entry to a call to io_setup with invalid arguments and
1491 a corrupted FP and LR.
1492 It should be safe enough to assume case 1. */
1493 if (ret == 0)
1494 {
1495 LONGEST x1 = -1, fp = -1, lr = -1;
1496 regs->cooked_read (AARCH64_X0_REGNUM + 1, &x1);
1497 regs->cooked_read (AARCH64_FP_REGNUM, &fp);
1498 regs->cooked_read (AARCH64_LR_REGNUM, &lr);
1499 if (x1 == 0 && fp ==0 && lr == 0)
1500 return aarch64_sys_execve;
1501 }
1502
1503 return ret;
1504}
1505
1506/* Record all registers but PC register for process-record. */
1507
1508static int
1510{
1511 int i;
1512
1513 for (i = AARCH64_X0_REGNUM; i < AARCH64_PC_REGNUM; i++)
1515 return -1;
1516
1518 return -1;
1519
1520 return 0;
1521}
1522
1523/* Handler for aarch64 system call instruction recording. */
1524
1525static int
1527 unsigned long svc_number)
1528{
1529 int ret = 0;
1530 enum gdb_syscall syscall_gdb;
1531
1532 syscall_gdb =
1534
1535 if (syscall_gdb < 0)
1536 {
1538 _("Process record and replay target doesn't "
1539 "support syscall number %s\n"),
1540 plongest (svc_number));
1541 return -1;
1542 }
1543
1544 if (syscall_gdb == gdb_sys_sigreturn
1545 || syscall_gdb == gdb_sys_rt_sigreturn)
1546 {
1548 return -1;
1549 return 0;
1550 }
1551
1552 ret = record_linux_system_call (syscall_gdb, regcache,
1554 if (ret != 0)
1555 return ret;
1556
1557 /* Record the return value of the system call. */
1559 return -1;
1560 /* Record LR. */
1562 return -1;
1563 /* Record CPSR. */
1565 return -1;
1566
1567 return 0;
1568}
1569
1570/* Implement the "gcc_target_options" gdbarch method. */
1571
1572static std::string
1574{
1575 /* GCC doesn't know "-m64". */
1576 return {};
1577}
1578
1579/* Helper to get the allocation tag from a 64-bit ADDRESS.
1580
1581 Return the allocation tag if successful and nullopt otherwise. */
1582
1583static gdb::optional<CORE_ADDR>
1584aarch64_mte_get_atag (CORE_ADDR address)
1585{
1586 gdb::byte_vector tags;
1587
1588 /* Attempt to fetch the allocation tag. */
1589 if (!target_fetch_memtags (address, 1, tags,
1590 static_cast<int> (memtag_type::allocation)))
1591 return {};
1592
1593 /* Only one tag should've been returned. Make sure we got exactly that. */
1594 if (tags.size () != 1)
1595 error (_("Target returned an unexpected number of tags."));
1596
1597 /* Although our tags are 4 bits in size, they are stored in a
1598 byte. */
1599 return tags[0];
1600}
1601
1602/* Implement the tagged_address_p gdbarch method. */
1603
1604static bool
1606{
1607 gdb_assert (address != nullptr);
1608
1609 CORE_ADDR addr = value_as_address (address);
1610
1611 /* Remove the top byte for the memory range check. */
1613
1614 /* Check if the page that contains ADDRESS is mapped with PROT_MTE. */
1615 if (!linux_address_in_memtag_page (addr))
1616 return false;
1617
1618 /* We have a valid tag in the top byte of the 64-bit address. */
1619 return true;
1620}
1621
1622/* Implement the memtag_matches_p gdbarch method. */
1623
1624static bool
1626 struct value *address)
1627{
1628 gdb_assert (address != nullptr);
1629
1630 /* Make sure we are dealing with a tagged address to begin with. */
1632 return true;
1633
1634 CORE_ADDR addr = value_as_address (address);
1635
1636 /* Fetch the allocation tag for ADDRESS. */
1637 gdb::optional<CORE_ADDR> atag
1639
1640 if (!atag.has_value ())
1641 return true;
1642
1643 /* Fetch the logical tag for ADDRESS. */
1644 gdb_byte ltag = aarch64_mte_get_ltag (addr);
1645
1646 /* Are the tags the same? */
1647 return ltag == *atag;
1648}
1649
1650/* Implement the set_memtags gdbarch method. */
1651
1652static bool
1654 size_t length, const gdb::byte_vector &tags,
1655 memtag_type tag_type)
1656{
1657 gdb_assert (!tags.empty ());
1658 gdb_assert (address != nullptr);
1659
1660 CORE_ADDR addr = value_as_address (address);
1661
1662 /* Set the logical tag or the allocation tag. */
1663 if (tag_type == memtag_type::logical)
1664 {
1665 /* When setting logical tags, we don't care about the length, since
1666 we are only setting a single logical tag. */
1667 addr = aarch64_mte_set_ltag (addr, tags[0]);
1668
1669 /* Update the value's content with the tag. */
1670 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1671 gdb_byte *srcbuf = value_contents_raw (address).data ();
1672 store_unsigned_integer (srcbuf, sizeof (addr), byte_order, addr);
1673 }
1674 else
1675 {
1676 /* Remove the top byte. */
1678
1679 /* Make sure we are dealing with a tagged address to begin with. */
1681 return false;
1682
1683 /* With G being the number of tag granules and N the number of tags
1684 passed in, we can have the following cases:
1685
1686 1 - G == N: Store all the N tags to memory.
1687
1688 2 - G < N : Warn about having more tags than granules, but write G
1689 tags.
1690
1691 3 - G > N : This is a "fill tags" operation. We should use the tags
1692 as a pattern to fill the granules repeatedly until we have
1693 written G tags to memory.
1694 */
1695
1696 size_t g = aarch64_mte_get_tag_granules (addr, length,
1698 size_t n = tags.size ();
1699
1700 if (g < n)
1701 warning (_("Got more tags than memory granules. Tags will be "
1702 "truncated."));
1703 else if (g > n)
1704 warning (_("Using tag pattern to fill memory range."));
1705
1706 if (!target_store_memtags (addr, length, tags,
1707 static_cast<int> (memtag_type::allocation)))
1708 return false;
1709 }
1710 return true;
1711}
1712
1713/* Implement the get_memtag gdbarch method. */
1714
1715static struct value *
1717 memtag_type tag_type)
1718{
1719 gdb_assert (address != nullptr);
1720
1721 CORE_ADDR addr = value_as_address (address);
1722 CORE_ADDR tag = 0;
1723
1724 /* Get the logical tag or the allocation tag. */
1725 if (tag_type == memtag_type::logical)
1726 tag = aarch64_mte_get_ltag (addr);
1727 else
1728 {
1729 /* Make sure we are dealing with a tagged address to begin with. */
1731 return nullptr;
1732
1733 /* Remove the top byte. */
1735 gdb::optional<CORE_ADDR> atag = aarch64_mte_get_atag (addr);
1736
1737 if (!atag.has_value ())
1738 return nullptr;
1739
1740 tag = *atag;
1741 }
1742
1743 /* Convert the tag to a value. */
1744 return value_from_ulongest (builtin_type (gdbarch)->builtin_unsigned_int,
1745 tag);
1746}
1747
1748/* Implement the memtag_to_string gdbarch method. */
1749
1750static std::string
1752{
1753 if (tag_value == nullptr)
1754 return "";
1755
1756 CORE_ADDR tag = value_as_address (tag_value);
1757
1758 return string_printf ("0x%s", phex_nz (tag, sizeof (tag)));
1759}
1760
1761/* AArch64 Linux implementation of the report_signal_info gdbarch
1762 hook. Displays information about possible memory tag violations. */
1763
1764static void
1766 struct ui_out *uiout,
1767 enum gdb_signal siggnal)
1768{
1769 aarch64_gdbarch_tdep *tdep = gdbarch_tdep<aarch64_gdbarch_tdep> (gdbarch);
1770
1771 if (!tdep->has_mte () || siggnal != GDB_SIGNAL_SEGV)
1772 return;
1773
1774 CORE_ADDR fault_addr = 0;
1775 long si_code = 0;
1776
1777 try
1778 {
1779 /* Sigcode tells us if the segfault is actually a memory tag
1780 violation. */
1781 si_code = parse_and_eval_long ("$_siginfo.si_code");
1782
1783 fault_addr
1784 = parse_and_eval_long ("$_siginfo._sifields._sigfault.si_addr");
1785 }
1786 catch (const gdb_exception_error &exception)
1787 {
1788 exception_print (gdb_stderr, exception);
1789 return;
1790 }
1791
1792 /* If this is not a memory tag violation, just return. */
1793 if (si_code != SEGV_MTEAERR && si_code != SEGV_MTESERR)
1794 return;
1795
1796 uiout->text ("\n");
1797
1798 uiout->field_string ("sigcode-meaning", _("Memory tag violation"));
1799
1800 /* For synchronous faults, show additional information. */
1801 if (si_code == SEGV_MTESERR)
1802 {
1803 uiout->text (_(" while accessing address "));
1804 uiout->field_core_addr ("fault-addr", gdbarch, fault_addr);
1805 uiout->text ("\n");
1806
1807 gdb::optional<CORE_ADDR> atag
1809 fault_addr));
1810 gdb_byte ltag = aarch64_mte_get_ltag (fault_addr);
1811
1812 if (!atag.has_value ())
1813 uiout->text (_("Allocation tag unavailable"));
1814 else
1815 {
1816 uiout->text (_("Allocation tag "));
1817 uiout->field_string ("allocation-tag", hex_string (*atag));
1818 uiout->text ("\n");
1819 uiout->text (_("Logical tag "));
1820 uiout->field_string ("logical-tag", hex_string (ltag));
1821 }
1822 }
1823 else
1824 {
1825 uiout->text ("\n");
1826 uiout->text (_("Fault address unavailable"));
1827 }
1828}
1829
1830/* AArch64 Linux implementation of the gdbarch_create_memtag_section hook. */
1831
1832static asection *
1834 CORE_ADDR address, size_t size)
1835{
1836 gdb_assert (obfd != nullptr);
1837 gdb_assert (size > 0);
1838
1839 /* Create the section and associated program header.
1840
1841 Make sure the section's flags has SEC_HAS_CONTENTS, otherwise BFD will
1842 refuse to write data to this section. */
1843 asection *mte_section
1844 = bfd_make_section_anyway_with_flags (obfd, "memtag", SEC_HAS_CONTENTS);
1845
1846 if (mte_section == nullptr)
1847 return nullptr;
1848
1849 bfd_set_section_vma (mte_section, address);
1850 /* The size of the memory range covered by the memory tags. We reuse the
1851 section's rawsize field for this purpose. */
1852 mte_section->rawsize = size;
1853
1854 /* Fetch the number of tags we need to save. */
1855 size_t tags_count
1857 /* Tags are stored packed as 2 tags per byte. */
1858 bfd_set_section_size (mte_section, (tags_count + 1) >> 1);
1859 /* Store program header information. */
1860 bfd_record_phdr (obfd, PT_AARCH64_MEMTAG_MTE, 1, 0, 0, 0, 0, 0, 1,
1861 &mte_section);
1862
1863 return mte_section;
1864}
1865
1866/* Maximum number of tags to request. */
1867#define MAX_TAGS_TO_TRANSFER 1024
1868
1869/* AArch64 Linux implementation of the gdbarch_fill_memtag_section hook. */
1870
1871static bool
1873{
1874 /* We only handle MTE tags for now. */
1875
1876 size_t segment_size = osec->rawsize;
1877 CORE_ADDR start_address = bfd_section_vma (osec);
1878 CORE_ADDR end_address = start_address + segment_size;
1879
1880 /* Figure out how many tags we need to store in this memory range. */
1881 size_t granules = aarch64_mte_get_tag_granules (start_address, segment_size,
1883
1884 /* If there are no tag granules to fetch, just return. */
1885 if (granules == 0)
1886 return true;
1887
1888 CORE_ADDR address = start_address;
1889
1890 /* Vector of tags. */
1891 gdb::byte_vector tags;
1892
1893 while (granules > 0)
1894 {
1895 /* Transfer tags in chunks. */
1896 gdb::byte_vector tags_read;
1897 size_t xfer_len
1898 = ((granules >= MAX_TAGS_TO_TRANSFER)
1900 : granules * AARCH64_MTE_GRANULE_SIZE);
1901
1902 if (!target_fetch_memtags (address, xfer_len, tags_read,
1903 static_cast<int> (memtag_type::allocation)))
1904 {
1905 warning (_("Failed to read MTE tags from memory range [%s,%s)."),
1906 phex_nz (start_address, sizeof (start_address)),
1907 phex_nz (end_address, sizeof (end_address)));
1908 return false;
1909 }
1910
1911 /* Transfer over the tags that have been read. */
1912 tags.insert (tags.end (), tags_read.begin (), tags_read.end ());
1913
1914 /* Adjust the remaining granules and starting address. */
1915 granules -= tags_read.size ();
1916 address += tags_read.size () * AARCH64_MTE_GRANULE_SIZE;
1917 }
1918
1919 /* Pack the MTE tag bits. */
1920 aarch64_mte_pack_tags (tags);
1921
1922 if (!bfd_set_section_contents (osec->owner, osec, tags.data (),
1923 0, tags.size ()))
1924 {
1925 warning (_("Failed to write %s bytes of corefile memory "
1926 "tag content (%s)."),
1927 pulongest (tags.size ()),
1928 bfd_errmsg (bfd_get_error ()));
1929 }
1930 return true;
1931}
1932
1933/* AArch64 Linux implementation of the gdbarch_decode_memtag_section
1934 hook. Decode a memory tag section and return the requested tags.
1935
1936 The section is guaranteed to cover the [ADDRESS, ADDRESS + length)
1937 range. */
1938
1939static gdb::byte_vector
1941 bfd_section *section,
1942 int type,
1943 CORE_ADDR address, size_t length)
1944{
1945 gdb_assert (section != nullptr);
1946
1947 /* The requested address must not be less than section->vma. */
1948 gdb_assert (section->vma <= address);
1949
1950 /* Figure out how many tags we need to fetch in this memory range. */
1951 size_t granules = aarch64_mte_get_tag_granules (address, length,
1953 /* Sanity check. */
1954 gdb_assert (granules > 0);
1955
1956 /* Fetch the total number of tags in the range [VMA, address + length). */
1957 size_t granules_from_vma
1958 = aarch64_mte_get_tag_granules (section->vma,
1959 address - section->vma + length,
1961
1962 /* Adjust the tags vector to contain the exact number of packed bytes. */
1963 gdb::byte_vector tags (((granules - 1) >> 1) + 1);
1964
1965 /* Figure out the starting offset into the packed tags data. */
1966 file_ptr offset = ((granules_from_vma - granules) >> 1);
1967
1968 if (!bfd_get_section_contents (section->owner, section, tags.data (),
1969 offset, tags.size ()))
1970 error (_("Couldn't read contents from memtag section."));
1971
1972 /* At this point, the tags are packed 2 per byte. Unpack them before
1973 returning. */
1974 bool skip_first = ((granules_from_vma - granules) % 2) != 0;
1975 aarch64_mte_unpack_tags (tags, skip_first);
1976
1977 /* Resize to the exact number of tags that was requested. */
1978 tags.resize (granules);
1979
1980 return tags;
1981}
1982
1983/* AArch64 implementation of the remove_non_address_bits gdbarch hook. Remove
1984 non address bits from a pointer value. */
1985
1986static CORE_ADDR
1988{
1989 aarch64_gdbarch_tdep *tdep = gdbarch_tdep<aarch64_gdbarch_tdep> (gdbarch);
1990
1991 /* By default, we assume TBI and discard the top 8 bits plus the VA range
1992 select bit (55). */
1993 CORE_ADDR mask = AARCH64_TOP_BITS_MASK;
1994
1995 if (tdep->has_pauth ())
1996 {
1997 /* Fetch the PAC masks. These masks are per-process, so we can just
1998 fetch data from whatever thread we have at the moment.
1999
2000 Also, we have both a code mask and a data mask. For now they are the
2001 same, but this may change in the future. */
2002 struct regcache *regs = get_current_regcache ();
2003 CORE_ADDR cmask, dmask;
2004
2005 if (regs->cooked_read (tdep->pauth_reg_base, &dmask) != REG_VALID)
2006 dmask = mask;
2007
2008 if (regs->cooked_read (tdep->pauth_reg_base + 1, &cmask) != REG_VALID)
2009 cmask = mask;
2010
2011 mask |= aarch64_mask_from_pac_registers (cmask, dmask);
2012 }
2013
2014 return aarch64_remove_top_bits (pointer, mask);
2015}
2016
2017static void
2019{
2020 static const char *const stap_integer_prefixes[] = { "#", "", NULL };
2021 static const char *const stap_register_prefixes[] = { "", NULL };
2022 static const char *const stap_register_indirection_prefixes[] = { "[",
2023 NULL };
2024 static const char *const stap_register_indirection_suffixes[] = { "]",
2025 NULL };
2026 aarch64_gdbarch_tdep *tdep = gdbarch_tdep<aarch64_gdbarch_tdep> (gdbarch);
2027
2028 tdep->lowest_pc = 0x8000;
2029
2030 linux_init_abi (info, gdbarch, 1);
2031
2034
2035 /* Enable TLS support. */
2038
2039 /* Shared library handling. */
2042
2044
2045 /* Enable longjmp. */
2046 tdep->jb_pc = 11;
2047
2052
2053 /* SystemTap related. */
2054 set_gdbarch_stap_integer_prefixes (gdbarch, stap_integer_prefixes);
2055 set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
2057 stap_register_indirection_prefixes);
2059 stap_register_indirection_suffixes);
2063
2064 /* Reversible debugging, process record. */
2066 /* Syscall record. */
2068
2069 /* The top byte of a user space address known as the "tag",
2070 is ignored by the kernel and can be regarded as additional
2071 data associated with the address. */
2074
2075 /* MTE-specific settings and hooks. */
2076 if (tdep->has_mte ())
2077 {
2078 /* Register a hook for checking if an address is tagged or not. */
2080
2081 /* Register a hook for checking if there is a memory tag match. */
2084
2085 /* Register a hook for setting the logical/allocation tags for
2086 a range of addresses. */
2088
2089 /* Register a hook for extracting the logical/allocation tag from an
2090 address. */
2092
2093 /* Set the allocation tag granule size to 16 bytes. */
2095
2096 /* Register a hook for converting a memory tag to a string. */
2098
2101
2102 /* Core file helpers. */
2103
2104 /* Core file helper to create a memory tag section for a particular
2105 PT_LOAD segment. */
2108
2109 /* Core file helper to fill a memory tag section with tag data. */
2112
2113 /* Core file helper to decode a memory tag section. */
2116 }
2117
2118 /* Initialize the aarch64_linux_record_tdep. */
2119 /* These values are the size of the type that will be used in a system
2120 call. They are obtained from Linux Kernel source. */
2122 = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
2143 = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
2145 = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
2147 = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
2192
2193 /* These values are the second argument of system call "sys_ioctl".
2194 They are obtained from Linux Kernel source. */
2260
2261 /* These values are the second argument of system call "sys_fcntl"
2262 and "sys_fcntl64". They are obtained from Linux Kernel source. */
2267
2268 /* The AArch64 syscall calling convention: reg x0-x6 for arguments,
2269 reg x8 for syscall number and return value in reg x0. */
2277
2278 /* `catch syscall' */
2279 set_xml_syscall_file_name (gdbarch, "syscalls/aarch64-linux.xml");
2281
2282 /* Displaced stepping. */
2289
2291}
2292
2293#if GDB_SELF_TEST
2294
2295namespace selftests {
2296
2297/* Verify functions to read and write logical tags. */
2298
2299static void
2300aarch64_linux_ltag_tests (void)
2301{
2302 /* We have 4 bits of tags, but we test writing all the bits of the top
2303 byte of address. */
2304 for (int i = 0; i < 1 << 8; i++)
2305 {
2306 CORE_ADDR addr = ((CORE_ADDR) i << 56) | 0xdeadbeef;
2307 SELF_CHECK (aarch64_mte_get_ltag (addr) == (i & 0xf));
2308
2309 addr = aarch64_mte_set_ltag (0xdeadbeef, i);
2310 SELF_CHECK (addr = ((CORE_ADDR) (i & 0xf) << 56) | 0xdeadbeef);
2311 }
2312}
2313
2314} // namespace selftests
2315#endif /* GDB_SELF_TEST */
2316
2318void
2320{
2321 gdbarch_register_osabi (bfd_arch_aarch64, 0, GDB_OSABI_LINUX,
2323
2324#if GDB_SELF_TEST
2325 selftests::register_test ("aarch64-linux-tagged-address",
2326 selftests::aarch64_linux_ltag_tests);
2327#endif
2328}
#define AARCH64_EXTRA_DATAP_OFFSET
aarch64_syscall
@ aarch64_sys_sync_file_range
@ aarch64_sys_accept
@ aarch64_sys_ioprio_get
@ aarch64_sys_mq_getsetattr
@ aarch64_sys_fchown
@ aarch64_sys_msgrcv
@ aarch64_sys_getsockopt
@ aarch64_sys_setregid
@ aarch64_sys_close
@ aarch64_sys_openat
@ aarch64_sys_fgetxattr
@ aarch64_sys_lseek
@ aarch64_sys_accept4
@ aarch64_sys_mincore
@ aarch64_sys_ppoll
@ aarch64_sys_fadvise64
@ aarch64_sys_sched_setaffinity
@ aarch64_sys_getrlimit
@ aarch64_sys_execve
@ aarch64_sys_io_setup
@ aarch64_sys_migrate_pages
@ aarch64_sys_mprotect
@ aarch64_sys_setgid
@ aarch64_sys_gettid
@ aarch64_sys_signalfd4
@ aarch64_sys_timer_create
@ aarch64_sys_fanotify_mark
@ aarch64_sys_recvfrom
@ aarch64_sys_chdir
@ aarch64_sys_ftruncate
@ aarch64_sys_msync
@ aarch64_sys_io_destroy
@ aarch64_sys_sync_file_range2
@ aarch64_sys_pwrite64
@ aarch64_sys_setitimer
@ aarch64_sys_setdomainname
@ aarch64_sys_remap_file_pages
@ aarch64_sys_sched_getaffinity
@ aarch64_sys_timer_settime
@ aarch64_sys_getppid
@ aarch64_sys_timer_getoverrun
@ aarch64_sys_sched_setscheduler
@ aarch64_sys_adjtimex
@ aarch64_sys_read
@ aarch64_sys_keyctl
@ aarch64_sys_vmsplice
@ aarch64_sys_swapon
@ aarch64_sys_fremovexattr
@ aarch64_sys_settimeofday
@ aarch64_sys_rt_sigpending
@ aarch64_sys_exit
@ aarch64_sys_setxattr
@ aarch64_sys_mount
@ aarch64_sys_inotify_add_watch
@ aarch64_sys_timerfd_gettime
@ aarch64_sys_tkill
@ aarch64_sys_pselect6
@ aarch64_sys_fchmodat
@ aarch64_sys_getresgid
@ aarch64_sys_sendmsg
@ aarch64_sys_shmat
@ aarch64_sys_mq_unlink
@ aarch64_sys_recvmsg
@ aarch64_sys_mlockall
@ aarch64_sys_preadv
@ aarch64_sys_setresuid
@ aarch64_sys_inotify_init1
@ aarch64_sys_tgkill
@ aarch64_sys_setrlimit
@ aarch64_sys_setresgid
@ aarch64_sys_semop
@ aarch64_sys_symlinkat
@ aarch64_sys_lsetxattr
@ aarch64_sys_mq_timedsend
@ aarch64_sys_getpid
@ aarch64_sys_sethostname
@ aarch64_sys_mremap
@ aarch64_sys_shmctl
@ aarch64_sys_sched_getparam
@ aarch64_sys_fallocate
@ aarch64_sys_sched_get_priority_max
@ aarch64_sys_umount2
@ aarch64_sys_mbind
@ aarch64_sys_sendto
@ aarch64_sys_readv
@ aarch64_sys_setsid
@ aarch64_sys_fcntl
@ aarch64_sys_sched_get_priority_min
@ aarch64_sys_fchownat
@ aarch64_sys_process_vm_readv
@ aarch64_sys_acct
@ aarch64_sys_flistxattr
@ aarch64_sys_msgctl
@ aarch64_sys_newfstatat
@ aarch64_sys_uname
@ aarch64_sys_listen
@ aarch64_sys_faccessat
@ aarch64_sys_madvise
@ aarch64_sys_clock_settime
@ aarch64_sys_timer_delete
@ aarch64_sys_epoll_create1
@ aarch64_sys_setsockopt
@ aarch64_sys_sendmmsg
@ aarch64_sys_mq_open
@ aarch64_sys_nfsservctl
@ aarch64_sys_mknodat
@ aarch64_sys_pwritev
@ aarch64_sys_removexattr
@ aarch64_sys_msgsnd
@ aarch64_sys_getrusage
@ aarch64_sys_munlockall
@ aarch64_sys_io_cancel
@ aarch64_sys_add_key
@ aarch64_sys_sync
@ aarch64_sys_mlock
@ aarch64_sys_finit_module
@ aarch64_sys_getuid
@ aarch64_sys_get_mempolicy
@ aarch64_sys_epoll_ctl
@ aarch64_sys_mq_notify
@ aarch64_sys_capset
@ aarch64_sys_getpriority
@ aarch64_sys_socketpair
@ aarch64_sys_mmap
@ aarch64_sys_wait4
@ aarch64_sys_set_mempolicy
@ aarch64_sys_set_robust_list
@ aarch64_sys_fanotify_init
@ aarch64_sys_getgid
@ aarch64_sys_getcpu
@ aarch64_sys_readlinkat
@ aarch64_sys_getpgid
@ aarch64_sys_semget
@ aarch64_sys_msgget
@ aarch64_sys_exit_group
@ aarch64_sys_getsockname
@ aarch64_sys_nanosleep
@ aarch64_sys_timerfd_create
@ aarch64_sys_io_getevents
@ aarch64_sys_getdents64
@ aarch64_sys_rt_sigqueueinfo
@ aarch64_sys_pipe2
@ aarch64_sys_sigaltstack
@ aarch64_sys_shutdown
@ aarch64_sys_rt_sigprocmask
@ aarch64_sys_fdatasync
@ aarch64_sys_setreuid
@ aarch64_sys_fchmod
@ aarch64_sys_epoll_pwait
@ aarch64_sys_renameat
@ aarch64_sys_mkdirat
@ aarch64_sys_sched_getattr
@ aarch64_sys_llistxattr
@ aarch64_sys_tee
@ aarch64_sys_open_by_handle_at
@ aarch64_sys_fstatfs
@ aarch64_sys_getegid
@ aarch64_sys_clock_gettime
@ aarch64_sys_inotify_rm_watch
@ aarch64_sys_fstat
@ aarch64_sys_clock_adjtime
@ aarch64_sys_setgroups
@ aarch64_sys_chroot
@ aarch64_sys_getrandom
@ aarch64_sys_write
@ aarch64_sys_sched_getscheduler
@ aarch64_sys_setpriority
@ aarch64_sys_lookup_dcookie
@ aarch64_sys_dup
@ aarch64_sys_dup3
@ aarch64_sys_capget
@ aarch64_sys_swapoff
@ aarch64_sys_lremovexattr
@ aarch64_sys_fsetxattr
@ aarch64_sys_setuid
@ aarch64_sys_flock
@ aarch64_sys_kill
@ aarch64_sys_linkat
@ aarch64_sys_setfsgid
@ aarch64_sys_brk
@ aarch64_sys_eventfd2
@ aarch64_sys_reboot
@ aarch64_sys_set_tid_address
@ aarch64_sys_truncate
@ aarch64_sys_umask
@ aarch64_sys_mq_timedreceive
@ aarch64_sys_setfsuid
@ aarch64_sys_semctl
@ aarch64_sys_syslog
@ aarch64_sys_pivot_root
@ aarch64_sys_writev
@ aarch64_sys_name_to_handle_at
@ aarch64_sys_rt_sigtimedwait
@ aarch64_sys_gettimeofday
@ aarch64_sys_munlock
@ aarch64_sys_delete_module
@ aarch64_sys_pread64
@ aarch64_sys_clone
@ aarch64_sys_munmap
@ aarch64_sys_readahead
@ aarch64_sys_rt_sigreturn
@ aarch64_sys_getpeername
@ aarch64_sys_times
@ aarch64_sys_getxattr
@ aarch64_sys_ioprio_set
@ aarch64_sys_io_submit
@ aarch64_sys_sched_setparam
@ aarch64_sys_getresuid
@ aarch64_sys_recvmmsg
@ aarch64_sys_vhangup
@ aarch64_sys_request_key
@ aarch64_sys_sched_rr_get_interval
@ aarch64_sys_getgroups
@ aarch64_sys_syncfs
@ aarch64_sys_ptrace
@ aarch64_sys_setpgid
@ aarch64_sys_semtimedop
@ aarch64_sys_clock_nanosleep
@ aarch64_sys_process_vm_writev
@ aarch64_sys_lgetxattr
@ aarch64_sys_shmdt
@ aarch64_sys_clock_getres
@ aarch64_sys_unshare
@ aarch64_sys_fsync
@ aarch64_sys_prctl
@ aarch64_sys_ioctl
@ aarch64_sys_socket
@ aarch64_sys_statfs
@ aarch64_sys_init_module
@ aarch64_sys_timerfd_settime
@ aarch64_sys_bind
@ aarch64_sys_rt_tgsigqueueinfo
@ aarch64_sys_sysinfo
@ aarch64_sys_sendfile
@ aarch64_sys_geteuid
@ aarch64_sys_setns
@ aarch64_sys_unlinkat
@ aarch64_sys_futex
@ aarch64_sys_get_robust_list
@ aarch64_sys_listxattr
@ aarch64_sys_rt_sigaction
@ aarch64_sys_sched_setattr
@ aarch64_sys_prlimit64
@ aarch64_sys_waitid
@ aarch64_sys_splice
@ aarch64_sys_rt_sigsuspend
@ aarch64_sys_connect
@ aarch64_sys_timer_gettime
@ aarch64_sys_fchdir
@ aarch64_sys_perf_event_open
@ aarch64_sys_sched_yield
@ aarch64_sys_shmget
@ aarch64_sys_personality
@ aarch64_sys_getitimer
@ aarch64_sys_kcmp
@ aarch64_sys_getsid
@ aarch64_sys_utimensat
@ aarch64_sys_quotactl
@ aarch64_sys_move_pages
@ aarch64_sys_kexec_load
@ aarch64_sys_getcwd
#define MAX_TAGS_TO_TRANSFER
static linux_record_tdep aarch64_linux_record_tdep
static int aarch64_all_but_pc_registers_record(struct regcache *regcache)
static expr::operation_up aarch64_stap_parse_special_token(struct gdbarch *gdbarch, struct stap_parse_info *p)
#define SVE_HEADER_SIZE
#define SVE_HEADER_RESERVED_LENGTH
#define SVE_HEADER_MAX_VL_LENGTH
#define SVE_HEADER_RESERVED_OFFSET
#define SVE_HEADER_FLAGS_LENGTH
#define AARCH64_SIGCONTEXT_REG_SIZE
#define SVE_HEADER_SIZE_LENGTH
#define AARCH64_SVE_CONTEXT_VL_OFFSET
#define SVE_HEADER_FLAG_SVE
static std::string aarch64_linux_gcc_target_options(struct gdbarch *gdbarch)
static void aarch64_linux_collect_sve_regset(const struct regset *regset, const struct regcache *regcache, int regnum, void *buf, size_t size)
static int aarch64_linux_syscall_record(struct regcache *regcache, unsigned long svc_number)
static uint64_t aarch64_linux_core_read_vq(struct gdbarch *gdbarch, bfd *abfd)
static gdb::optional< CORE_ADDR > aarch64_mte_get_atag(CORE_ADDR address)
#define AARCH64_UCONTEXT_SIGCONTEXT_OFFSET
#define AARCH64_FPSIMD_VREG_SIZE
#define AARCH64_SVE_CONTEXT_P_REGS_OFFSET(vq)
#define SVE_HEADER_FLAGS_OFFSET
static const struct regcache_map_entry aarch64_linux_fpregmap[]
static bool aarch64_linux_set_memtags(struct gdbarch *gdbarch, struct value *address, size_t length, const gdb::byte_vector &tags, memtag_type tag_type)
static struct value * aarch64_linux_get_memtag(struct gdbarch *gdbarch, struct value *address, memtag_type tag_type)
static const struct tramp_frame aarch64_linux_rt_sigframe
static void aarch64_linux_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
static const struct regcache_map_entry aarch64_linux_gregmap[]
#define AARCH64_SIGCONTEXT_RESERVED_SIZE
#define AARCH64_SVE_CONTEXT_FFR_OFFSET(vq)
static bool aarch64_linux_fill_memtag_section(struct gdbarch *gdbarch, asection *osec)
const struct regset aarch64_linux_fpregset
static void aarch64_linux_report_signal_info(struct gdbarch *gdbarch, struct ui_out *uiout, enum gdb_signal siggnal)
#define AARCH64_FPSIMD_FPCR_OFFSET
#define AARCH64_SVE_CONTEXT_REGS_OFFSET
#define SVE_HEADER_MAX_SIZE_OFFSET
static enum gdb_syscall aarch64_canonicalize_syscall(enum aarch64_syscall syscall_number)
static gdb::byte_vector aarch64_linux_decode_memtag_section(struct gdbarch *gdbarch, bfd_section *section, int type, CORE_ADDR address, size_t length)
#define AARCH64_FPSIMD_FPSR_OFFSET
#define AARCH64_SIGCONTEXT_XO_OFFSET
#define SVE_HEADER_VL_LENGTH
static CORE_ADDR aarch64_remove_non_address_bits(struct gdbarch *gdbarch, CORE_ADDR pointer)
#define AARCH64_RT_SIGFRAME_UCONTEXT_OFFSET
static uint32_t read_aarch64_ctx(CORE_ADDR ctx_addr, enum bfd_endian byte_order, uint32_t *size)
static void aarch64_linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
static void aarch64_linux_sigframe_init(const struct tramp_frame *self, frame_info_ptr this_frame, struct trad_frame_cache *this_cache, CORE_ADDR func)
void _initialize_aarch64_linux_tdep()
#define SYSCALL_MAP(SYSCALL)
static bool aarch64_linux_tagged_address_p(struct gdbarch *gdbarch, struct value *address)
#define AARCH64_FPSIMD_MAGIC
#define UNSUPPORTED_SYSCALL_MAP(SYSCALL)
#define AARCH64_SVE_CONTEXT_SIZE(vq)
static LONGEST aarch64_linux_get_syscall_number(struct gdbarch *gdbarch, thread_info *thread)
#define AARCH64_FPSIMD_V0_OFFSET
#define SVE_HEADER_SIZE_OFFSET
#define AARCH64_EXTRA_MAGIC
static int aarch64_stap_is_single_operand(struct gdbarch *gdbarch, const char *s)
static void aarch64_linux_supply_sve_regset(const struct regset *regset, struct regcache *regcache, int regnum, const void *buf, size_t size)
static const struct target_desc * aarch64_linux_core_read_description(struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd)
#define AARCH64_SVE_MAGIC
#define SVE_HEADER_MAX_VL_OFFSET
static asection * aarch64_linux_create_memtag_section(struct gdbarch *gdbarch, bfd *obfd, CORE_ADDR address, size_t size)
static std::string aarch64_linux_memtag_to_string(struct gdbarch *gdbarch, struct value *tag_value)
static void aarch64_linux_restore_vreg(struct trad_frame_cache *cache, int num_regs, int vreg_num, CORE_ADDR offset, enum bfd_endian byte_order, bool has_sve)
static bool aarch64_linux_memtag_matches_p(struct gdbarch *gdbarch, struct value *address)
#define SVE_HEADER_VL_OFFSET
const struct regset aarch64_linux_gregset
#define SVE_HEADER_MAX_SIZE_LENGTH
#define AARCH64_SIGCONTEXT_RESERVED_OFFSET
#define AARCH64_LINUX_SIZEOF_GREGSET
#define AARCH64_LINUX_SIZEOF_MTE_REGSET
#define AARCH64_HWCAP_PACA
#define AARCH64_LINUX_SIZEOF_FPREGSET
#define AARCH64_LINUX_SIZEOF_PAUTH
CORE_ADDR aarch64_mte_get_ltag(CORE_ADDR address)
size_t aarch64_mte_get_tag_granules(CORE_ADDR addr, size_t len, size_t granule_size)
void aarch64_mte_unpack_tags(gdb::byte_vector &tags, bool skip_first)
CORE_ADDR aarch64_mte_set_ltag(CORE_ADDR address, CORE_ADDR tag)
void aarch64_mte_pack_tags(gdb::byte_vector &tags)
#define SEGV_MTESERR
#define HWCAP2_MTE
#define AARCH64_MTE_GRANULE_SIZE
#define SEGV_MTEAERR
displaced_step_copy_insn_closure_up aarch64_displaced_step_copy_insn(struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
int regnum
bool aarch64_displaced_step_hw_singlestep(struct gdbarch *gdbarch)
const target_desc * aarch64_read_description(const aarch64_features &features)
int aarch64_process_record(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR insn_addr)
void aarch64_displaced_step_fixup(struct gdbarch *gdbarch, struct displaced_step_copy_insn_closure *dsc_, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
#define B_REGISTER_SIZE
#define AARCH64_DISPLACED_MODIFIED_INSNS
#define D_REGISTER_SIZE
#define Q_REGISTER_SIZE
#define H_REGISTER_SIZE
#define S_REGISTER_SIZE
CORE_ADDR aarch64_remove_top_bits(CORE_ADDR pointer, CORE_ADDR mask)
Definition aarch64.c:66
CORE_ADDR aarch64_mask_from_pac_registers(const CORE_ADDR cmask, const CORE_ADDR dmask)
Definition aarch64.c:85
#define AARCH64_Q0_REGNUM
Definition aarch64.h:126
#define AARCH64_H0_REGNUM
Definition aarch64.h:129
#define AARCH64_SVE_P_REGS_NUM
Definition aarch64.h:140
#define sve_vq_from_vl(vl)
Definition aarch64.h:156
#define sve_vl_from_vq(vq)
Definition aarch64.h:159
#define AARCH64_TOP_BITS_MASK
Definition aarch64.h:123
#define AARCH64_SVE_V0_REGNUM
Definition aarch64.h:131
@ AARCH64_SVE_FFR_REGNUM
Definition aarch64.h:105
@ AARCH64_FP_REGNUM
Definition aarch64.h:91
@ AARCH64_PC_REGNUM
Definition aarch64.h:94
@ AARCH64_CPSR_REGNUM
Definition aarch64.h:95
@ AARCH64_SP_REGNUM
Definition aarch64.h:93
@ AARCH64_SVE_VG_REGNUM
Definition aarch64.h:106
@ AARCH64_SVE_Z0_REGNUM
Definition aarch64.h:98
@ AARCH64_FPSR_REGNUM
Definition aarch64.h:100
@ AARCH64_SVE_P0_REGNUM
Definition aarch64.h:102
@ AARCH64_FPCR_REGNUM
Definition aarch64.h:101
@ AARCH64_LR_REGNUM
Definition aarch64.h:92
@ AARCH64_X0_REGNUM
Definition aarch64.h:90
@ AARCH64_V0_REGNUM
Definition aarch64.h:96
#define AARCH64_B0_REGNUM
Definition aarch64.h:130
#define V_REGISTER_SIZE
Definition aarch64.h:116
#define AARCH64_TLS_REGISTER_SIZE
Definition aarch64.h:115
#define sve_vg_from_vl(vl)
Definition aarch64.h:153
#define AARCH64_S0_REGNUM
Definition aarch64.h:128
#define AARCH64_SVE_Z_REGS_NUM
Definition aarch64.h:139
#define AARCH64_MAX_SVE_VQ
Definition aarch64.h:166
#define AARCH64_D0_REGNUM
Definition aarch64.h:127
#define AARCH64_PAUTH_DMASK_REGNUM(pauth_reg_base)
Definition aarch64.h:133
gdb::optional< gdb::byte_vector > target_read_auxv_raw(target_ops *ops)
Definition auxv.c:375
enum register_status cooked_read(int regnum, gdb_byte *buf)
Definition regcache.c:692
gdbarch * arch() const
Definition regcache.c:230
void raw_supply(int regnum, const void *buf) override
Definition regcache.c:1053
void raw_supply_zeroed(int regnum)
Definition regcache.c:1101
void collect_regset(const struct regset *regset, int regbase, int regnum, void *buf, size_t size) const
Definition regcache.c:1274
void supply_regset(const struct regset *regset, int regbase, int regnum, const void *buf, size_t size)
Definition regcache.c:1252
void field_core_addr(const char *fldname, struct gdbarch *gdbarch, CORE_ADDR address)
Definition ui-out.c:478
void field_string(const char *fldname, const char *string, const ui_file_style &style=ui_file_style())
Definition ui-out.c:511
void text(const char *string)
Definition ui-out.c:566
#define ULONGEST_MAX
Definition defs.h:473
void store_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, T val)
Definition findvar.c:163
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition defs.h:561
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:526
LONGEST parse_and_eval_long(const char *exp)
Definition eval.c:62
void exception_print(struct ui_file *file, const struct gdb_exception &e)
Definition exceptions.c:105
ssize_t read(int fd, void *buf, size_t count)
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
Definition frame.c:1351
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition frame.c:713
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition frame.c:2907
@ SIGTRAMP_FRAME
Definition frame.h:190
#define ptrace(request, pid, addr, data)
Definition gdb_ptrace.h:141
void set_gdbarch_process_record(struct gdbarch *gdbarch, gdbarch_process_record_ftype *process_record)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1370
void set_gdbarch_stap_parse_special_token(struct gdbarch *gdbarch, gdbarch_stap_parse_special_token_ftype *stap_parse_special_token)
void set_gdbarch_stap_integer_prefixes(struct gdbarch *gdbarch, const char *const *stap_integer_prefixes)
Definition gdbarch.c:4460
void set_gdbarch_max_insn_length(struct gdbarch *gdbarch, ULONGEST max_insn_length)
Definition gdbarch.c:4003
void set_gdbarch_core_read_description(struct gdbarch *gdbarch, gdbarch_core_read_description_ftype *core_read_description)
void set_gdbarch_create_memtag_section(struct gdbarch *gdbarch, gdbarch_create_memtag_section_ftype *create_memtag_section)
void set_gdbarch_memtag_granule_size(struct gdbarch *gdbarch, CORE_ADDR memtag_granule_size)
Definition gdbarch.c:3216
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype *skip_trampoline_code)
void set_gdbarch_stap_is_single_operand(struct gdbarch *gdbarch, gdbarch_stap_is_single_operand_ftype *stap_is_single_operand)
void set_gdbarch_tagged_address_p(struct gdbarch *gdbarch, gdbarch_tagged_address_p_ftype *tagged_address_p)
void set_gdbarch_get_syscall_number(struct gdbarch *gdbarch, gdbarch_get_syscall_number_ftype *get_syscall_number)
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition gdbarch.c:1899
bfd * obfd
void set_gdbarch_get_memtag(struct gdbarch *gdbarch, gdbarch_get_memtag_ftype *get_memtag)
int gdbarch_int_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1423
void set_gdbarch_memtag_matches_p(struct gdbarch *gdbarch, gdbarch_memtag_matches_p_ftype *memtag_matches_p)
void set_gdbarch_displaced_step_copy_insn(struct gdbarch *gdbarch, gdbarch_displaced_step_copy_insn_ftype *displaced_step_copy_insn)
void set_gdbarch_stap_register_indirection_prefixes(struct gdbarch *gdbarch, const char *const *stap_register_indirection_prefixes)
Definition gdbarch.c:4528
void set_gdbarch_gcc_target_options(struct gdbarch *gdbarch, gdbarch_gcc_target_options_ftype *gcc_target_options)
void set_gdbarch_displaced_step_fixup(struct gdbarch *gdbarch, gdbarch_displaced_step_fixup_ftype *displaced_step_fixup)
CORE_ADDR gdbarch_remove_non_address_bits(struct gdbarch *gdbarch, CORE_ADDR pointer)
Definition gdbarch.c:3104
void set_gdbarch_memtag_to_string(struct gdbarch *gdbarch, gdbarch_memtag_to_string_ftype *memtag_to_string)
void set_gdbarch_remove_non_address_bits(struct gdbarch *gdbarch, gdbarch_remove_non_address_bits_ftype *remove_non_address_bits)
void set_gdbarch_report_signal_info(struct gdbarch *gdbarch, gdbarch_report_signal_info_ftype *report_signal_info)
void set_gdbarch_fetch_tls_load_module_address(struct gdbarch *gdbarch, gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address)
void set_gdbarch_displaced_step_hw_singlestep(struct gdbarch *gdbarch, gdbarch_displaced_step_hw_singlestep_ftype *displaced_step_hw_singlestep)
int gdbarch_long_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1440
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1691
void set_gdbarch_fill_memtag_section(struct gdbarch *gdbarch, gdbarch_fill_memtag_section_ftype *fill_memtag_section)
void set_gdbarch_stap_register_prefixes(struct gdbarch *gdbarch, const char *const *stap_register_prefixes)
Definition gdbarch.c:4494
void set_gdbarch_stap_register_indirection_suffixes(struct gdbarch *gdbarch, const char *const *stap_register_indirection_suffixes)
Definition gdbarch.c:4545
void set_gdbarch_set_memtags(struct gdbarch *gdbarch, gdbarch_set_memtags_ftype *set_memtags)
void set_gdbarch_skip_solib_resolver(struct gdbarch *gdbarch, gdbarch_skip_solib_resolver_ftype *skip_solib_resolver)
void set_gdbarch_decode_memtag_section(struct gdbarch *gdbarch, gdbarch_decode_memtag_section_ftype *decode_memtag_section)
void set_gdbarch_iterate_over_regset_sections(struct gdbarch *gdbarch, gdbarch_iterate_over_regset_sections_ftype *iterate_over_regset_sections)
memtag_type
Definition gdbarch.h:128
void() iterate_over_regset_sections_cb(const char *sect_name, int supply_size, int collect_size, const struct regset *regset, const char *human_name, void *cb_data)
Definition gdbarch.h:102
struct type * lookup_pointer_type(struct type *type)
Definition gdbtypes.c:402
CORE_ADDR glibc_skip_solib_resolver(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition glibc-tdep.c:38
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition gnu-nat.c:1862
size_t size
Definition go32-nat.c:241
int record_linux_system_call(enum gdb_syscall syscall, struct regcache *regcache, struct linux_record_tdep *tdep)
gdb_syscall
@ gdb_sys_sigreturn
@ gdb_sys_no_syscall
@ gdb_sys_rt_sigreturn
@ gdb_sys_mmap2
link_map_offsets * linux_lp64_fetch_link_map_offsets()
CORE_ADDR linux_get_hwcap2()
void linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch, int num_disp_step_buffers)
bool linux_address_in_memtag_page(CORE_ADDR address)
CORE_ADDR linux_get_hwcap()
CORE_ADDR find_solib_trampoline_target(frame_info_ptr frame, CORE_ADDR pc)
Definition minsyms.c:1534
Definition ada-exp.h:80
std::unique_ptr< operation > operation_up
Definition expression.h:81
void gdbarch_register_osabi(enum bfd_architecture arch, unsigned long machine, enum gdb_osabi osabi, void(*init_osabi)(struct gdbarch_info, struct gdbarch *))
Definition osabi.c:146
@ GDB_OSABI_LINUX
Definition osabi.h:32
int record_full_arch_list_add_reg(struct regcache *regcache, int regnum)
void regcache_collect_regset(const struct regset *regset, const struct regcache *regcache, int regnum, void *buf, size_t size)
Definition regcache.c:1264
struct regcache * get_current_regcache(void)
Definition regcache.c:426
struct regcache * get_thread_regcache(process_stratum_target *target, ptid_t ptid)
Definition regcache.c:397
void regcache_supply_regset(const struct regset *regset, struct regcache *regcache, int regnum, const void *buf, size_t size)
Definition regcache.c:1242
static int regcache_map_entry_size(const struct regcache_map_entry *map)
Definition regcache.h:127
#define REGSET_VARIABLE_SIZE
Definition regset.h:52
void(* func)(remote_target *remote, char *)
void set_solib_svr4_fetch_link_map_offsets(struct gdbarch *gdbarch, struct link_map_offsets *(*flmo)(void))
CORE_ADDR svr4_fetch_objfile_link_map(struct objfile *objfile)
int(* aarch64_syscall_record)(struct regcache *regcache, unsigned long svc_number)
bool has_sve() const
bool has_pauth() const
struct type * builtin_long
Definition gdbtypes.h:2249
ULONGEST ioctl_TIOCGLCKTRMIOS
ULONGEST ioctl_TIOCMIWAIT
ULONGEST ioctl_TCGETA
ULONGEST ioctl_TIOCGICOUNT
ULONGEST ioctl_TIOCMBIC
ULONGEST ioctl_TIOCMBIS
ULONGEST ioctl_TCSETSW2
ULONGEST ioctl_TIOCSERGSTRUCT
ULONGEST ioctl_TIOCGPTN
ULONGEST ioctl_TIOCSERGETMULTI
ULONGEST ioctl_TIOCGSID
ULONGEST ioctl_FIOQSIZE
ULONGEST ioctl_TIOCSERCONFIG
ULONGEST ioctl_FIONCLEX
ULONGEST ioctl_TIOCSSOFTCAR
ULONGEST ioctl_TIOCSWINSZ
ULONGEST ioctl_TCSETSF
ULONGEST ioctl_TIOCLINUX
ULONGEST ioctl_TIOCTTYGSTRUCT
ULONGEST ioctl_TIOCSBRK
ULONGEST ioctl_TIOCGPGRP
ULONGEST ioctl_TIOCSERSETMULTI
ULONGEST ioctl_TCSETS
ULONGEST ioctl_TIOCSSERIAL
int size_serial_icounter_struct
ULONGEST ioctl_TIOCSPTLCK
ULONGEST ioctl_TIOCGETD
ULONGEST ioctl_FIONREAD
ULONGEST ioctl_TIOCCBRK
ULONGEST ioctl_TCGETS
ULONGEST ioctl_TIOCGSOFTCAR
ULONGEST ioctl_TIOCNOTTY
ULONGEST ioctl_TIOCSPGRP
ULONGEST ioctl_TIOCGSERIAL
ULONGEST ioctl_FIOASYNC
ULONGEST ioctl_TIOCSERGETLSR
ULONGEST ioctl_TIOCOUTQ
ULONGEST ioctl_TIOCMGET
ULONGEST ioctl_TIOCGWINSZ
ULONGEST ioctl_TIOCSERGWILD
ULONGEST ioctl_TIOCCONS
ULONGEST ioctl_TCSETSF2
ULONGEST ioctl_TIOCSCTTY
ULONGEST ioctl_TIOCSETD
ULONGEST ioctl_TIOCSLCKTRMIOS
ULONGEST ioctl_TIOCSHAYESESP
ULONGEST ioctl_TIOCGHAYESESP
ULONGEST ioctl_TIOCEXCL
ULONGEST ioctl_TIOCNXCL
ULONGEST ioctl_TCSETSW
ULONGEST ioctl_TIOCMSET
ULONGEST ioctl_TIOCSERSWILD
Definition regcache.h:110
const char * arg
Definition stap-probe.h:45
const char * saved_arg
Definition stap-probe.h:53
struct type * arg_type
Definition stap-probe.h:59
std::vector< tdesc_feature_up > features
Definition value.c:181
LONGEST offset
Definition value.c:281
CORE_ADDR address
Definition value.c:246
bool target_store_memtags(CORE_ADDR address, size_t len, const gdb::byte_vector &tags, int type)
Definition target.c:829
bool target_fetch_memtags(CORE_ADDR address, size_t len, gdb::byte_vector &tags, int type)
Definition target.c:822
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1771
void trad_frame_set_reg_value_bytes(struct trad_frame_cache *this_trad_cache, int regnum, gdb::array_view< const gdb_byte > bytes)
Definition trad-frame.c:175
void trad_frame_set_reg_addr(struct trad_frame_cache *this_trad_cache, int regnum, CORE_ADDR addr)
Definition trad-frame.c:110
void trad_frame_set_id(struct trad_frame_cache *this_trad_cache, struct frame_id this_id)
Definition trad-frame.c:220
void tramp_frame_prepend_unwinder(struct gdbarch *gdbarch, const struct tramp_frame *tramp_frame)
#define TRAMP_SENTINEL_INSN
Definition tramp-frame.h:44
int user_reg_map_name_to_regnum(struct gdbarch *gdbarch, const char *name, int len)
Definition user-regs.c:132
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1865
#define gdb_stderr
Definition utils.h:193
CORE_ADDR value_as_address(struct value *val)
Definition value.c:2804
struct value * value_from_ulongest(struct type *type, ULONGEST num)
Definition value.c:3637
gdb::array_view< gdb_byte > value_contents_raw(struct value *value)
Definition value.c:1167
void set_xml_syscall_file_name(struct gdbarch *gdbarch, const char *name)
Definition xml-syscall.c:50