20#include <sys/utsname.h>
22#include "gdbsupport/common-defs.h"
23#include "elf/external.h"
24#include "elf/common.h"
26#include "arch/aarch64.h"
27#include "gdbsupport/common-regcache.h"
28#include "gdbsupport/byte-vector.h"
30#include "arch/aarch64-scalable-linux.h"
45 if (
sizeof (header) == header.
size)
64 if (
sizeof (header) == header.
size)
80 if (
sizeof (header) == header.
size)
93 iovec.iov_len =
sizeof (header);
94 iovec.iov_base = &header;
111 iovec.iov_len =
sizeof (header);
112 iovec.iov_base = (
void *) &header;
129 iovec.iov_len =
sizeof (header);
130 iovec.iov_base = &header;
147 iovec.iov_len =
sizeof (header);
148 iovec.iov_base = (
void *) &header;
165 iovec.iov_len =
sizeof (header);
166 iovec.iov_base = &header;
183 iovec.iov_len =
sizeof (header);
184 iovec.iov_base = (
void *) &header;
200 return (vl == 16 || vl == 32 || vl == 64 || vl == 128 || vl == 256);
225 iovec.iov_len =
sizeof (header);
226 iovec.iov_base = &header;
241 uint64_t vq = sve_vq_from_vl (header.
vl);
245 warning (_(
"Invalid SVE state from kernel; SVE disabled."));
260 iovec.iov_len =
sizeof (header);
261 iovec.iov_base = &header;
273 header.
vl = sve_vl_from_vq (vq);
296 if (reg_buf->get_register_status (AARCH64_SVE_VG_REGNUM) != REG_VALID)
306 reg_vg = sve_vg_from_vq (vq);
309 reg_buf->raw_collect (AARCH64_SVE_VG_REGNUM, ®_vg);
323 uint64_t vq = sve_vq_from_vl (header.
vl);
327 warning (_(
"Invalid ZA state from kernel; ZA disabled."));
352 if (header.
vl == sve_vl_from_vq (vq))
358 header.
vl = sve_vl_from_vq (vq);
363 iovec.iov_len =
sizeof (header);
364 iovec.iov_base = &header;
385 uint64_t reg_svg = 0;
391 if (reg_buf->get_register_status (svg_regnum) != REG_VALID)
401 reg_svg = sve_vg_from_vq (svq);
404 reg_buf->raw_collect (svg_regnum, ®_svg);
417 perror_with_name (_(
"Unable to fetch SVE/SSVE vector length"));
427 iovec.iov_base = sve_state.data ();
428 iovec.iov_len = sve_state.size ();
433 perror_with_name (_(
"Unable to fetch SVE/SSVE registers"));
445 iovec.iov_base = (
void *) sve_state.data ();
446 iovec.iov_len = sve_state.size ();
451 perror_with_name (_(
"Unable to store SVE/SSVE registers"));
461 error (_(
"Failed to read NT_ARM_ZA header."));
464 error (_(
"Found invalid vector length for NT_ARM_ZA."));
467 iovec.iov_len = header.
size;
468 gdb::byte_vector za_state (header.
size);
469 iovec.iov_base = za_state.data ();
472 perror_with_name (_(
"Failed to fetch NT_ARM_ZA register set."));
484 iovec.iov_base = (
void *) za_state.data ();
485 iovec.iov_len = za_state.size ();
488 perror_with_name (_(
"Failed to write to the NT_ARM_ZA register set."));
500 error (_(
"Failed to read NT_ARM_ZA header."));
504 std::vector<gdb_byte> za_new_state (
ZA_PT_SIZE (sve_vq_from_vl (header.
vl)));
511 const gdb_byte *base = (gdb_byte *) &header;
516 iovec.iov_len = za_new_state.size ();
517 iovec.iov_base = za_new_state.data ();
520 perror_with_name (_(
"Failed to initialize the NT_ARM_ZA register set."));
526 gdb::byte_vector zt_new_state (AARCH64_SME2_ZT0_SIZE, 0);
541 gdb::byte_vector zt_state (AARCH64_SME2_ZT0_SIZE);
544 iovec.iov_len = AARCH64_SME2_ZT0_SIZE;
545 iovec.iov_base = zt_state.data ();
548 perror_with_name (_(
"Failed to fetch NT_ARM_ZT register set."));
558 gdb_assert (zt_state.size () == AARCH64_SME2_ZT0_SIZE
559 || zt_state.size () == 0);
566 iovec.iov_len = zt_state.size ();
567 iovec.iov_base = (
void *) zt_state.data ();
571 perror_with_name (_(
"Failed to write to the NT_ARM_ZT register set."));
579 gdb_byte zt_state[AARCH64_SME2_ZT0_SIZE];
582 iovec.iov_len = AARCH64_SME2_ZT0_SIZE;
583 iovec.iov_base = (
void *) zt_state;
598 gdb_assert (src !=
nullptr && dst !=
nullptr);
599 gdb_assert (size > 1);
601#if (__BYTE_ORDER == __BIG_ENDIAN)
602 for (
int i = 0; i < size - 1; i++)
603 dst[i] = src[size - i];
605 memcpy (dst, src, size);
616 char *base = (
char *) sve_state.data ();
620 uint64_t vq = sve_vq_from_vl (header->
vl);
621 uint64_t vg = sve_vg_from_vl (header->
vl);
626 error (_(
"Invalid SVE header from kernel."));
630 reg_buf->raw_supply (AARCH64_SVE_VG_REGNUM, &vg);
636 for (
int i = 0; i < AARCH64_SVE_Z_REGS_NUM; i++)
637 reg_buf->raw_supply (AARCH64_SVE_Z0_REGNUM + i,
640 for (
int i = 0; i < AARCH64_SVE_P_REGS_NUM; i++)
641 reg_buf->raw_supply (AARCH64_SVE_P0_REGNUM + i,
644 reg_buf->raw_supply (AARCH64_SVE_FFR_REGNUM,
646 reg_buf->raw_supply (AARCH64_FPSR_REGNUM,
648 reg_buf->raw_supply (AARCH64_FPCR_REGNUM,
669 struct user_fpsimd_state *fpsimd
679 for (
int i = 0; i < AARCH64_SVE_Z_REGS_NUM; i++)
684 reg_buf->raw_supply (AARCH64_SVE_Z0_REGNUM + i, reg);
687 reg_buf->raw_supply (AARCH64_FPSR_REGNUM, &fpsimd->fpsr);
688 reg_buf->raw_supply (AARCH64_FPCR_REGNUM, &fpsimd->fpcr);
693 for (
int i = 0; i < AARCH64_SVE_P_REGS_NUM; i++)
694 reg_buf->raw_supply (AARCH64_SVE_P0_REGNUM + i, reg);
696 reg_buf->raw_supply (AARCH64_SVE_FFR_REGNUM, reg);
707 struct reg_buffer_common *reg_buf)
712 perror_with_name (_(
"Unable to set VG register"));
718 uint64_t vq = sve_vq_from_vl (header->
vl);
721 memcpy (new_state.data (), sve_state.data (), sve_state.size ());
723 char *base = (
char *) new_state.data ();
728 error (_(
"Invalid SVE header from kernel."));
742 memset (reg, 0,
sizeof (reg));
746 bool has_sve_state =
false;
747 for (
int i = 0; i < AARCH64_SVE_Z_REGS_NUM; i++)
749 if (!reg_buf->raw_compare (AARCH64_SVE_Z0_REGNUM + i, reg,
752 has_sve_state =
true;
758 for (
int i = 0; i < AARCH64_SVE_P_REGS_NUM; i++)
760 if (!reg_buf->raw_compare (AARCH64_SVE_P0_REGNUM + i, reg, 0))
762 has_sve_state =
true;
769 = !reg_buf->raw_compare (AARCH64_SVE_FFR_REGNUM, reg, 0);
771 struct user_fpsimd_state *fpsimd
795 for (
int i = 0; i < AARCH64_SVE_Z_REGS_NUM; i++)
798 == reg_buf->get_register_status (AARCH64_SVE_Z0_REGNUM + i))
800 reg_buf->raw_collect (AARCH64_SVE_Z0_REGNUM + i, reg);
807 if (REG_VALID == reg_buf->get_register_status (AARCH64_FPSR_REGNUM))
808 reg_buf->raw_collect (AARCH64_FPSR_REGNUM, &fpsimd->fpsr);
809 if (REG_VALID == reg_buf->get_register_status (AARCH64_FPCR_REGNUM))
810 reg_buf->raw_collect (AARCH64_FPCR_REGNUM, &fpsimd->fpcr);
836 for (
int i = AARCH64_SVE_Z_REGS_NUM - 1; i >= 0 ; i--)
839 sizeof (__int128_t));
853 for (
int i = 0; i < AARCH64_SVE_Z_REGS_NUM; i++)
854 if (REG_VALID == reg_buf->get_register_status (AARCH64_SVE_Z0_REGNUM
856 reg_buf->raw_collect (AARCH64_SVE_Z0_REGNUM + i,
859 for (
int i = 0; i < AARCH64_SVE_P_REGS_NUM; i++)
860 if (REG_VALID == reg_buf->get_register_status (AARCH64_SVE_P0_REGNUM
862 reg_buf->raw_collect (AARCH64_SVE_P0_REGNUM + i,
865 if (REG_VALID == reg_buf->get_register_status (AARCH64_SVE_FFR_REGNUM))
866 reg_buf->raw_collect (AARCH64_SVE_FFR_REGNUM,
868 if (REG_VALID == reg_buf->get_register_status (AARCH64_FPSR_REGNUM))
869 reg_buf->raw_collect (AARCH64_FPSR_REGNUM,
871 if (REG_VALID == reg_buf->get_register_status (AARCH64_FPCR_REGNUM))
872 reg_buf->raw_collect (AARCH64_FPCR_REGNUM,
888 int za_regnum,
int svg_regnum,
895 gdb_assert (!za_state.empty ());
897 char *base = (
char *) za_state.data ();
903 uint64_t svcr_value = 0;
910 error (_(
"Found invalid streaming vector length in NT_ARM_ZA"
915 svcr_value |= SVCR_ZA_BIT;
919 size_t za_bytes = header->
vl * header->
vl;
920 gdb_byte za_zeroed[za_bytes];
921 memset (za_zeroed, 0, za_bytes);
922 reg_buf->raw_supply (za_regnum, za_zeroed);
929 uint64_t svg_value = sve_vg_from_vl (header->
vl);
932 reg_buf->raw_supply (svg_regnum, &svg_value);
933 reg_buf->raw_supply (svcr_regnum, &svcr_value);
943 struct reg_buffer_common *reg_buf,
944 int za_regnum,
int svg_regnum,
972 error (_(
"Failed to read NT_ARM_ZA header."));
975 uint64_t old_svg = sve_vg_from_vl (header.
vl);
979 reg_buf->raw_collect (svg_regnum, &new_svg);
982 bool svg_changed = new_svg != old_svg;
989 error (_(
"Unable to set svg register"));
993 size_t za_bytes = sve_vl_from_vg (old_svg) * sve_vl_from_vg (old_svg);
994 gdb_byte za_zeroed[za_bytes];
995 memset (za_zeroed, 0, za_bytes);
1002 reg_buf->raw_supply (za_regnum, za_zeroed);
1008 && reg_buf->raw_compare (za_regnum, za_zeroed, 0))
1020 && !reg_buf->raw_compare (za_regnum, za_zeroed, 0))
1030 char *base = (
char *) za_state.data ();
1032 uint64_t svq = sve_vq_from_vl (za_header->
vl);
1037 error (_(
"Invalid vector length or payload size when reading ZA."));
1041 if (REG_VALID == reg_buf->get_register_status (za_regnum))
1049 uint64_t svcr_value = 0;
1052 reg_buf->raw_supply (svcr_regnum, &svcr_value);
1073 gdb_assert (!zt_state.empty ());
1076 reg_buf->raw_supply (zt_regnum, zt_state.data ());
1081 gdb::byte_vector zt_zeroed (AARCH64_SME2_ZT0_SIZE, 0);
1082 reg_buf->raw_supply (zt_regnum, zt_zeroed.data ());
1093 struct reg_buffer_common *reg_buf,
1100 gdb::byte_vector zt_bytes (AARCH64_SME2_ZT0_SIZE, 0);
1101 bool zt_is_all_zeroes
1102 = reg_buf->raw_compare (zt_regnum, zt_bytes.data (), 0);
1107 if (valid_za || !zt_is_all_zeroes)
1117 reg_buf->raw_collect (zt_regnum, zt_bytes.data ());
gdb::byte_vector aarch64_fetch_sve_regset(int tid)
bool supports_zt_registers(int tid)
void aarch64_store_za_regset(int tid, const gdb::byte_vector &za_state)
void aarch64_sve_regs_copy_from_reg_buf(int tid, struct reg_buffer_common *reg_buf)
bool write_sve_header(int tid, const struct user_sve_header &header)
static void aarch64_maybe_swab128(gdb_byte *dst, const gdb_byte *src, size_t size)
void aarch64_za_regs_copy_from_reg_buf(int tid, struct reg_buffer_common *reg_buf, int za_regnum, int svg_regnum, int svcr_regnum)
bool aarch64_za_set_svq(int tid, uint64_t vq)
bool aarch64_has_za_state(int tid)
uint64_t aarch64_za_get_svq(int tid)
static bool aarch64_sve_vl_valid(const bool sve_state, size_t vl)
bool read_za_header(int tid, struct user_za_header &header)
static bool aarch64_sme_vl_valid(size_t vl)
void aarch64_zt_regs_copy_from_reg_buf(int tid, struct reg_buffer_common *reg_buf, int zt_regnum)
void aarch64_za_regs_copy_to_reg_buf(int tid, struct reg_buffer_common *reg_buf, int za_regnum, int svg_regnum, int svcr_regnum)
bool aarch64_has_sve_state(int tid)
bool read_ssve_header(int tid, struct user_sve_header &header)
void aarch64_sve_regs_copy_to_reg_buf(int tid, struct reg_buffer_common *reg_buf)
void aarch64_store_zt_regset(int tid, const gdb::byte_vector &zt_state)
uint64_t aarch64_sve_get_vq(int tid)
gdb::byte_vector aarch64_fetch_zt_regset(int tid)
bool aarch64_has_ssve_state(int tid)
gdb::byte_vector aarch64_fetch_za_regset(int tid)
bool write_ssve_header(int tid, const struct user_sve_header &header)
bool read_sve_header(int tid, struct user_sve_header &header)
bool aarch64_sve_set_vq(int tid, uint64_t vq)
bool write_za_header(int tid, const struct user_za_header &header)
void aarch64_zt_regs_copy_to_reg_buf(int tid, struct reg_buffer_common *reg_buf, int zt_regnum)
void aarch64_store_sve_regset(int tid, const gdb::byte_vector &sve_state)
void aarch64_initialize_za_regset(int tid)
#define HAS_SVE_STATE(header)
#define SVE_PT_SVE_FPSR_OFFSET(vq)
#define SVE_PT_SVE_FPCR_OFFSET(vq)
#define SVE_PT_SVE_FFR_OFFSET(vq)
#define SVE_PT_SVE_PREG_OFFSET(vq, n)
#define SVE_PT_SIZE(vq, flags)
#define SVE_PT_SVE_ZREG_SIZE(vq)
#define SVE_PT_FPSIMD_OFFSET
#define SVE_PT_SVE_ZREG_OFFSET(vq, n)
#define ptrace(request, pid, addr, data)