Add ptrace register access for AArch64 SVE registers

[omjavaid]

Summary

This patch adds NativeRegisterContext_arm64 ptrace routines to access AArch64 SVE registers. This patch also adds a test-case to test AArch64 SVE registers dynamic configuration and read/write.

This patch is part from previously submitted AArch64 SVE register access support.

[omjavaid]

This new updated patch overrides GetRegisterInfoAtIndex in NativeRegisterContextLinux_arm64 to reduce the impacts of register numbering conversion on the generic LLGS code.

[omjavaid]

This update remove skipping over register infos requirement by overlapping sve register numbers with debug register numbers which are not required by Linux register context.

[omjavaid]

This update remove dependence over generic interfaces by calling ConfigureRegisterContext on every call to ReadRegister/WriteRegister.

[omjavaid]

This update incorporates suggestion from last iteration and also rebases after merger of register sets and register infos in RegisterInfosPOSIX_arm64.
Also I have posted a separate patch D83541 to make lldb/source/Plugins/Process/Linux/LinuxPTraceDefines_arm64sve.h platform independent in order to use them with elf-core.

@labath what do you think ?

[omjavaid]

This update makes changes to avoid dependence on lldb-arm64-register-enums.h. Also provides rebased version after update of parent patches.

[omjavaid]

Updated and re-based after changes in core file patch

[omjavaid]

This revision updates SVE ptrace support to reflect changes we made in SVE core file support specially around handling of FPSR and FPCR.

[labath]

I haven't looked at all the sve details, but they seem very similar to the core file stuff, so I think they should be fine. I have some other comments though...

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp

349

What's the relationship of this function and the InvalidateAllRegisters function we added (for arm64 benefit) a couple of reviews back? Can we just have one of them?

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.h

22

At this point, that header is sufficiently different from the asm/ptrace.h implementation (names of all structs and fields are different) that I don't think it makes sense to use it as an optional replacement. It makes it very likely things will not build in one of the modes.

This should either use the system version (and then only build when the system has the appropriate headers), or we should use the in-house version unconditionally (which may require renaming/namespacing the rest of the file so that it does not conflict with the real asm/ptrace.h).

lldb/test/API/commands/register/register/aarch64_sve_registers/rw_access_static_config/TestSVERegisters.py

22 ↗

(On Diff #278718)

It would be better to have this actually detect the availability of the feature. A skip-always test is not very convincing.

IIRC, some of the tests for fancy x86 registers have the inferior detect the availability of the feature (via the cpuid instruction or something), and then exit with a predefined exit code. Then the test can check for that and skip itself if the feature is not available. Would something like that work here?

75 ↗

(On Diff #278718)

you don't need to set this twice

lldb/test/API/commands/register/register/aarch64_sve_registers/rw_access_static_config/main.c

2–4 ↗

(On Diff #278718)

In our newer register tests we use the pattern where the debugger sets the register values, which are then read back through the inferior (and vice versa). I thing this is a good thing as it avoids the possibility of making symmetrical bugs in the read/write code, which will then appear to modify the register successfully, but they won't actually change the value observed by the inferior process.

[omjavaid]

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp

349

Both InvalidateAllRegisters and ConfigureRegisterContext are inter related.

The idea is to maintain a cache of SVE register configurations created after thread stop on first call to ReadRegister/WriteRegister, using ConfigureRegisterContext. This configuration cache is maintained unless we do register write or we issue a step or resume.

InvalidateAllRegisters is called before resume and it will invalidate all cached register data including SVE configuration thus forcing us to do ConfigureRegisterContext on stop.

There is also a case where we need to reconfigure register context when we write vector granule register and need to update register sizes and offsets and sync them up between LLDB client and server. That case is handled by the child revisions of this patch.

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.h

22

Ack.

lldb/test/API/commands/register/register/aarch64_sve_registers/rw_access_static_config/main.c

2–4 ↗

(On Diff #278718)

In this test we are also doing the same please have a look at TestSVERegisters.py:140-142.

The code in main.c is used to make sure we enable SVE mode. AArch64 SVE mode is enabled by Linux kernel on first execution of SVE code.

[omjavaid]

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.h

22

asm/ptrace.h also describes legacy structs for fpsimd access, hardware breakpoint structs and other related ptrace access. Newer versions of ptrace only append SVE specific structs and macros. In house LLDB's SVE macros file only include SVE specific register names. I dont see any conflict since I have also added a guard for multiple definitions in LinuxPTraceDefines_arm64sve.h as it protects against builds of AArch64/Linux where ThreadElfCore also includes sigcontext and ptrace.h for accessing elf-core related struct definitions.

[omjavaid]

This update fixes issues highlighted in last review iteration.

@labath any further action on this?

[labath]

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp

349

Right, it's that inter-relatedness that worries me. Back when we were talking about InvalidateAllRegisters we (I) decided that it was simpler to call it before a thread resumes. I'm wondering if that wasn't a mistake.

Like, if we called InvalidateAllRegisters when a thread stops, then you could use this opportunity to initialize the SVE configuration, right? And that would avoid the need to call ConfigureRegisterContext on every register read operation? Obviously there'd still need to be some reconfiguration/invalidation of the SVE context after some register writes, but that would be similar to us invalidating the GPR cache when the GPR registers get written.

Basically, it seems to me that would make things more homogeneous.

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.h

22

I'm not saying we shouldn't include asm/ptrace.h at all. It obviously contains a lot of useful stuff, and we wouldn't want to duplicate all of that.

What I am saying is that for the stuff that we already have duplicated, we just be using that unconditionally. Doing otherwise just needlessly forks the build matrix and creates opportunities for things to not work in one mode or the other. We're already committed to ensuring things work with the in-house definitions so why bothering to ensure that things work both with them _and_ with the system ones.

lldb/test/API/commands/register/register/aarch64_sve_registers/rw_access_static_config/main.c

2–4 ↗

(On Diff #278718)

I have a feeling we're misunderstanding each other. I am talking about the tests in test/Shell/Register (e.g. x86-64-xmm16-read.test, x86-64-xmm16-write.test). This test definitely doesn't to that. The code in 140-142 is just reading back what was written by lines 135-137, not values set by the inferior.

[omjavaid]

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp

349

Agreed. I can give that a shot that probably was the original idea behind InvalidateAllRegisters.

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.h

22

Right now SVE in-house macros and the ones in asm/ptrace.h are identical. If we include asm/ptrace.h and it already has SVE macros we cannot avoid that inclusion so in case we want to force use of in-house macros we ll have to rename the in-house macros and headers with LLVM_ or LLDB_ prefix to make sure we avoid duplication. If you have strong opinion in favor of renaming i can go ahead and do that.

lldb/test/API/commands/register/register/aarch64_sve_registers/rw_access_static_config/main.c

2–4 ↗

(On Diff #278718)

The problem in case of SVE is that size of vector is unknown untill we run therefore we cannot hard write value that will be written and read back.
Also this API based test actually verifies that vector granule register value and Z/P register sizes make sense. It then prepares a value to be written to Z, P or FFr registers based on currently configured vector length and the read that same value back. I could not find a way to do that using shell based tests.

[omjavaid]

In this update I have moved ConfigureRegisterContext insider InvalidateAllRegisters in light of D84501 where we move InvalidateAllRegisters on every stop rather than doing so before step/resume

[labath]

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.h

22

I do, actually. Given that this code is also used for the core files, which can be used from any host, and the fact that we have already started making changes to it because of that (_uNN vs uintNN_t, the msvc compatibility patch, etc), I think we just just treating this as a part of our codebase and not some asm/ptrace addon.

I wouldn't tack an additional LLDB_ onto the names though. What I'd do is replace all of these macros with regular C(++) symbols. Parameter-less macros can be constants and function-like macros can just be functions. They can keep the original all-caps spelling to make it clear where they are coming from, but in order to distinguish them from the system symbols we can make a tiny modification -- instead of naming everyting SVE_FOO, we name the thing just FOO, but put it inside a lldb_private::SVE namespace -- that way the symbols can be referred to as SVE::FOO.

lldb/test/API/commands/register/register/aarch64_sve_registers/rw_access_static_config/main.c

2–4 ↗

(On Diff #278718)

Right. While it would definitely be nice if this test was next to the other ones, rewriting this as a lit test is not what I was going for. I think these are sufficiently special to handle them this way.

What I was referring to is the general principle of setting the registers in the inferior (via asm or something) and then reading them from the test. That principle applies no matter which style is the test written in.

[omjavaid]

This patch fixes review items from last review cycles. Now we do not use LinuxPTraceDefines_arm64sve.h for NativeProcessLinux_arm64 as these defs are already back ported into libc ptrace.h available on most distros. LLDB arm64 build bot and release builders should already have the header included.

We have updated LinuxPTraceDefines_arm64sve.h in D85641 where macros are converted into c++ consts and inlines.

Also test case now include ASM writing of by all SVE registers and they are read back and verified by the test case. I have also retained the writing test that was already there previously.

[omjavaid]

@labath Any further action needed on this change? I have updated test main.c for doing asm write to SVE regs and then reading them back during testing. Also i have removed NativeProcessLinux_arm64 dependence on LinuxPTraceDefines_arm64sve.h. We are using sys root's ptrace.h as SVE marcros are back ported in most versions of ptrace.h.

[labath]

In D79699#2215216, @omjavaid wrote:

@labath Any further action needed on this change? I have updated test main.c for doing asm write to SVE regs and then reading them back during testing. Also i have removed NativeProcessLinux_arm64 dependence on LinuxPTraceDefines_arm64sve.h. We are using sys root's ptrace.h as SVE marcros are back ported in most versions of ptrace.h.

Almost. I have two more questions/requests inline.

lldb/test/API/commands/register/register/aarch64_sve_registers/rw_access_static_config/TestSVERegisters.py

100–106 ↗

(On Diff #284328)

Are you sure this will work if the system does not support SVE? I would expect the test application to die from SIGILL (or something) long before we reach this part.

Even if it does work, it will mean that the test will be skipped (instead of failing) if the lldb-server stops reporting the sve registers (or even if it just slightly changes the register set name). That's why I was originally suggesting to check for SVE support from within the inferior process.

Is there a simple way to do that? I'm assuming there must be, otherwise the application could not detect whether it can use sve...

134 ↗

(On Diff #284328)

So, the program sets all p registers to the same value (0xffff..) right? Would it be possible to introduce some variance there (like you did for the z registers), to ensure that the registers are actually read from the right place?

[omjavaid]

This update adds check for SVE support using /proc/cpuinfo in SVE testcases. Also tests case to read predicate registers with 5 different values instead of 0xff.

@labath this seems reasonable now?

[labath]

Looks good, just the cpuinfo detection function could use a bit of improvement.

Thanks for your patience.

lldb/test/API/commands/register/register/aarch64_sve_registers/rw_access_static_config/TestSVERegisters.py

22 ↗

(On Diff #285956)

This will put the file into the CWD, which is in the source tree. This should be self.getBuildArtifact(cpuinfo), and then you don't need the tear down hook.

Also, "platform get-file" (or SBPlatform::Get) should also work on local setups.

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux.h

public:
   // variant should be compiled into the final executable.
   static std::unique_ptr<NativeRegisterContextLinux>
   CreateHostNativeRegisterContextLinux(const ArchSpec &target_arch,
                                        NativeThreadProtocol &native_thread);
 
   // Invalidates cached values in register context data structures
   virtual void InvalidateAllRegisters(){}
 
+  // Configures register context based on target capabilities
+  virtual void ConfigureRegisterContext() {}
+
 protected:
   lldb::ByteOrder GetByteOrder() const;
 
   virtual Status ReadRegisterRaw(uint32_t reg_index, RegisterValue &reg_value);
 
   virtual Status WriteRegisterRaw(uint32_t reg_index,
                                   const RegisterValue &reg_value);
 

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.h

 //===-- NativeRegisterContextLinux_arm64.h ---------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(__arm64__) || defined(__aarch64__)
 
 #ifndef lldb_NativeRegisterContextLinux_arm64_h
 #define lldb_NativeRegisterContextLinux_arm64_h
 
 #include "Plugins/Process/Linux/NativeRegisterContextLinux.h"
 #include "Plugins/Process/Utility/lldb-arm64-register-enums.h"
 
+#include <asm/ptrace.h>
+
+#ifndef SVE_PT_REGS_SVE
+#define INCLUDE_LINUX_PTRACE_DEFINITIONS_FOR_SVE_ARM64
+#include "Plugins/Process/Linux/LinuxPTraceDefines_arm64sve.h"
+#endif
+
 namespace lldb_private {
 namespace process_linux {
 
 class NativeProcessLinux;
 
+enum class SVE_STATE {
+  SVE_STATE_UNKNOWN,
+  SVE_STATE_DISABLED,
+  SVE_STATE_FPSIMD,
+  SVE_STATE_FULL
+};
+
 class NativeRegisterContextLinux_arm64 : public NativeRegisterContextLinux {
 public:
   NativeRegisterContextLinux_arm64(const ArchSpec &target_arch,
                                    NativeThreadProtocol &native_thread);
 
   uint32_t GetRegisterSetCount() const override;
 
   uint32_t GetUserRegisterCount() const override;
 
   const RegisterSet *GetRegisterSet(uint32_t set_index) const override;
 
   Status ReadRegister(const RegisterInfo *reg_info,
                       RegisterValue &reg_value) override;
 
   Status WriteRegister(const RegisterInfo *reg_info,
                        const RegisterValue &reg_value) override;
 
   Status ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
 
   Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
   void InvalidateAllRegisters() override;
 
+  void ConfigureRegisterContext() override;
+
   // Hardware breakpoints/watchpoint management functions
 
   uint32_t NumSupportedHardwareBreakpoints() override;
 
   uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
 
   bool ClearHardwareBreakpoint(uint32_t hw_idx) override;
 
protected:
   Status ReadGPR() override;
 
   Status WriteGPR() override;
 
   Status ReadFPR() override;
 
   Status WriteFPR() override;
 
+  Status ReadAllSVE();
+
+  Status WriteAllSVE();
+
+  Status ReadSVEHeader();
+
+  Status WriteSVEHeader();
+
   void *GetGPRBuffer() override { return &m_gpr_arm64; }
 
   void *GetFPRBuffer() override { return &m_fpr; }
 
   size_t GetFPRSize() override { return sizeof(m_fpr); }
 
+  void *GetSVEHeader() { return &m_sve_header; }
+
+  void *GetSVEBuffer();
+
+  size_t GetSVEHeaderSize() { return sizeof(m_sve_header); }
+
+  size_t GetSVEBufferSize() { return m_sve_ptrace_payload.size(); }
+
 private:
   struct RegInfo {
     uint32_t num_registers;
     uint32_t num_gpr_registers;
     uint32_t num_fpr_registers;
+    uint32_t num_sve_registers;
 
     uint32_t last_gpr;
     uint32_t first_fpr;
     uint32_t last_fpr;
 
     uint32_t first_fpr_v;
     uint32_t last_fpr_v;
 
+    uint32_t first_sve;
+    uint32_t last_sve;
+
     uint32_t gpr_flags;
   };
 
   // based on RegisterContextDarwin_arm64.h
   struct VReg {
     uint8_t bytes[16];
   };
 
   // based on RegisterContextDarwin_arm64.h
   struct FPU {
     VReg v[32];
     uint32_t fpsr;
     uint32_t fpcr;
   };
 
   struct GPR {
     uint64_t x[31];
     uint64_t sp;
     uint64_t pc;
     uint64_t pstate;
   };
 
   bool m_gpr_is_valid;
   bool m_fpu_is_valid;
+  bool m_sve_buffer_is_valid;
+
+  bool m_sve_header_is_valid;
+  bool m_sve_update_reg_infos;
 
   GPR m_gpr_arm64; // 64-bit general purpose registers.
+
   RegInfo m_reg_info;
   FPU m_fpr; // floating-point registers including extended register sets.
 
+  mutable SVE_STATE m_sve_state;
+  struct user_sve_header m_sve_header;
+  std::vector<uint8_t> m_sve_ptrace_payload;
+
   // Debug register info for hardware breakpoints and watchpoints management.
   struct DREG {
     lldb::addr_t address;  // Breakpoint/watchpoint address value.
     lldb::addr_t hit_addr; // Address at which last watchpoint trigger exception
                            // occurred.
     lldb::addr_t real_addr; // Address value that should cause target to stop.
     uint32_t control;       // Breakpoint/watchpoint control value.
     uint32_t refcount;      // Serves as enable/disable and reference counter.
   };
 
   struct DREG m_hbr_regs[16]; // Arm native linux hardware breakpoints
   struct DREG m_hwp_regs[16]; // Arm native linux hardware watchpoints
 
   uint32_t m_max_hwp_supported;
   uint32_t m_max_hbp_supported;
   bool m_refresh_hwdebug_info;
 
   bool IsGPR(unsigned reg) const;
 
   bool IsFPR(unsigned reg) const;
 
+  bool IsSVE(unsigned reg) const;
+
+  bool IsSVEZReg(unsigned reg) const;
+
+  bool IsSVEPReg(unsigned reg) const;
+
+  bool IsSVERegVG(unsigned reg) const;
+
+  uint64_t GetSVERegVG() { return m_sve_header.vl / 8; }
+
+  void SetSVERegVG(uint64_t vg) { m_sve_header.vl = vg * 8; }
+
   Status ReadHardwareDebugInfo();
 
   Status WriteHardwareDebugRegs(int hwbType);
 
   uint32_t CalculateFprOffset(const RegisterInfo *reg_info) const;
+
+  uint32_t CalculateSVEOffset(uint32_t reg_num) const;
 };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef lldb_NativeRegisterContextLinux_arm64_h
 
 #endif // defined (__arm64__) || defined (__aarch64__)

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp

 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h"
 
 // System includes - They have to be included after framework includes because
 // they define some macros which collide with variable names in other modules
 #include <sys/socket.h>
 // NT_PRSTATUS and NT_FPREGSET definition
 #include <elf.h>
-// user_hwdebug_state definition
-#include <asm/ptrace.h>
+
+#ifndef NT_ARM_SVE
+#define NT_ARM_SVE 0x405 /* ARM Scalable Vector Extension */
+#endif
 
 #define REG_CONTEXT_SIZE (GetGPRSize() + GetFPRSize())
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_linux;
 
 // ARM64 general purpose registers.
static const uint32_t g_fpu_regnums_arm64[] = {
     fpu_d28_arm64,      fpu_d29_arm64,  fpu_d30_arm64, fpu_d31_arm64,
     fpu_fpsr_arm64,     fpu_fpcr_arm64,
     LLDB_INVALID_REGNUM // register sets need to end with this flag
 };
 static_assert(((sizeof g_fpu_regnums_arm64 / sizeof g_fpu_regnums_arm64[0]) -
                1) == k_num_fpr_registers_arm64,
               "g_fpu_regnums_arm64 has wrong number of register infos");
 
+// ARM64 SVE registers.
+static const uint32_t g_sve_regnums_arm64[] = {
+    sve_vg_arm64,
+
+    sve_z0_arm64,       sve_z1_arm64,  sve_z2_arm64,  sve_z3_arm64,
+    sve_z4_arm64,       sve_z5_arm64,  sve_z6_arm64,  sve_z7_arm64,
+    sve_z8_arm64,       sve_z9_arm64,  sve_z10_arm64, sve_z11_arm64,
+    sve_z12_arm64,      sve_z13_arm64, sve_z14_arm64, sve_z15_arm64,
+    sve_z16_arm64,      sve_z17_arm64, sve_z18_arm64, sve_z19_arm64,
+    sve_z20_arm64,      sve_z21_arm64, sve_z22_arm64, sve_z23_arm64,
+    sve_z24_arm64,      sve_z25_arm64, sve_z26_arm64, sve_z27_arm64,
+    sve_z28_arm64,      sve_z29_arm64, sve_z30_arm64, sve_z31_arm64,
+
+    sve_p0_arm64,       sve_p1_arm64,  sve_p2_arm64,  sve_p3_arm64,
+    sve_p4_arm64,       sve_p5_arm64,  sve_p6_arm64,  sve_p7_arm64,
+    sve_p8_arm64,       sve_p9_arm64,  sve_p10_arm64, sve_p11_arm64,
+    sve_p12_arm64,      sve_p13_arm64, sve_p14_arm64, sve_p15_arm64,
+
+    sve_ffr_arm64,
+    LLDB_INVALID_REGNUM // register sets need to end with this flag
+};
+static_assert(((sizeof g_sve_regnums_arm64 / sizeof g_sve_regnums_arm64[0]) -
+               1) == k_num_sve_registers_arm64,
+              "g_sve_regnums_arm64 has wrong number of register infos");
+
 namespace {
 // Number of register sets provided by this context.
-enum { k_num_register_sets = 2 };
+enum { k_num_register_sets = 3 };
 }
 
 // Register sets for ARM64.
 static const RegisterSet g_reg_sets_arm64[k_num_register_sets] = {
     {"General Purpose Registers", "gpr", k_num_gpr_registers_arm64,
      g_gpr_regnums_arm64},
     {"Floating Point Registers", "fpu", k_num_fpr_registers_arm64,
-     g_fpu_regnums_arm64}};
+     g_fpu_regnums_arm64},
+    {"SVE Registers", "sve", k_num_sve_registers_arm64, g_sve_regnums_arm64}};
 
 std::unique_ptr<NativeRegisterContextLinux>
 NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
     const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
   switch (target_arch.GetMachine()) {
   case llvm::Triple::arm:
     return std::make_unique<NativeRegisterContextLinux_arm>(target_arch,
                                                              native_thread);
NativeRegisterContextLinux_arm64::NativeRegisterContextLinux_arm64(
     const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
     : NativeRegisterContextLinux(native_thread,
                                  new RegisterInfoPOSIX_arm64(target_arch)) {
   switch (target_arch.GetMachine()) {
   case llvm::Triple::aarch64:
     m_reg_info.num_registers = k_num_registers_arm64;
     m_reg_info.num_gpr_registers = k_num_gpr_registers_arm64;
     m_reg_info.num_fpr_registers = k_num_fpr_registers_arm64;
+    m_reg_info.num_sve_registers = k_num_sve_registers_arm64;
+
     m_reg_info.last_gpr = k_last_gpr_arm64;
     m_reg_info.first_fpr = k_first_fpr_arm64;
     m_reg_info.last_fpr = k_last_fpr_arm64;
     m_reg_info.first_fpr_v = fpu_v0_arm64;
     m_reg_info.last_fpr_v = fpu_v31_arm64;
     m_reg_info.gpr_flags = gpr_cpsr_arm64;
+    m_reg_info.first_sve = sve_vg_arm64;
+    m_reg_info.last_sve = sve_ffr_arm64;
     break;
   default:
     llvm_unreachable("Unhandled target architecture.");
     break;
   }
 
   ::memset(&m_fpr, 0, sizeof(m_fpr));
   ::memset(&m_gpr_arm64, 0, sizeof(m_gpr_arm64));
   ::memset(&m_hwp_regs, 0, sizeof(m_hwp_regs));
   ::memset(&m_hbr_regs, 0, sizeof(m_hbr_regs));
+  ::memset(&m_sve_header, 0, sizeof(m_sve_header));
 
   // 16 is just a maximum value, query hardware for actual watchpoint count
   m_max_hwp_supported = 16;
   m_max_hbp_supported = 16;
   m_refresh_hwdebug_info = true;
 
   m_gpr_is_valid = false;
   m_fpu_is_valid = false;
+  m_sve_buffer_is_valid = false;
+
+  m_sve_header_is_valid = false;
+  m_sve_update_reg_infos = true;
+
+  // SVE is not enabled until we query user_sve_header
+  m_sve_state = SVE_STATE::SVE_STATE_UNKNOWN;
 }
 
 uint32_t NativeRegisterContextLinux_arm64::GetRegisterSetCount() const {
+  if (m_sve_state == SVE_STATE::SVE_STATE_FPSIMD ||
+      m_sve_state == SVE_STATE::SVE_STATE_FULL)
+
     return k_num_register_sets;
+  else
+    return k_num_register_sets - 1;
 }
 
 const RegisterSet *
 NativeRegisterContextLinux_arm64::GetRegisterSet(uint32_t set_index) const {
-  if (set_index < k_num_register_sets)
+  if (set_index < GetRegisterSetCount())
     return &g_reg_sets_arm64[set_index];
 
   return nullptr;
 }
 
 uint32_t NativeRegisterContextLinux_arm64::GetUserRegisterCount() const {
-  uint32_t count = 0;
-  for (uint32_t set_index = 0; set_index < k_num_register_sets; ++set_index)
-    count += g_reg_sets_arm64[set_index].num_registers;
-  return count;
+  if (m_sve_state == SVE_STATE::SVE_STATE_FPSIMD ||
+      m_sve_state == SVE_STATE::SVE_STATE_FULL)
+    return k_num_gpr_registers_arm64 + k_num_fpr_registers_arm64 +
+           k_num_sve_registers_arm64;
+
+  return k_num_gpr_registers_arm64 + k_num_fpr_registers_arm64;
 }
 
 Status
 NativeRegisterContextLinux_arm64::ReadRegister(const RegisterInfo *reg_info,
                                                RegisterValue &reg_value) {
   Status error;
 
   if (!reg_info) {
     error.SetErrorString("reg_info NULL");
     return error;
   }
 
   const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
 
   if (reg == LLDB_INVALID_REGNUM)
     return Status("no lldb regnum for %s", reg_info && reg_info->name
                                                ? reg_info->name
                                                : "<unknown register>");
 
   uint8_t *src;
   uint32_t offset;
+  uint64_t sve_vg;
+  std::vector<uint8_t> sve_reg_non_live;
 
   if (IsGPR(reg)) {
     if (!m_gpr_is_valid) {
       error = ReadGPR();
       if (error.Fail())
         return error;
     }
 
     offset = reg_info->byte_offset;
     assert(offset < GetGPRSize());
     src = (uint8_t *)GetGPRBuffer() + offset;
 
   } else if (IsFPR(reg)) {
+    if (m_sve_state == SVE_STATE::SVE_STATE_DISABLED) {
+      // SVE is disabled take legacy route for FPU register access
       if (!m_fpu_is_valid) {
 
         error = ReadFPR();
         if (error.Fail())
           return error;
       }
       offset = CalculateFprOffset(reg_info);
       assert(offset < GetFPRSize());
       src = (uint8_t *)GetFPRBuffer() + offset;
+    } else {
+      // SVE enabled, we will read and cache SVE ptrace data
+      if (!m_sve_buffer_is_valid) {
+        error = ReadAllSVE();
+        if (error.Fail())
+          return error;
+      }
+      // Extract SVE Z register value register number for this reg_info
+      uint32_t sve_reg_num = LLDB_INVALID_REGNUM;
+      if (reg_info->value_regs &&
+          reg_info->value_regs[0] != LLDB_INVALID_REGNUM)
+        sve_reg_num = reg_info->value_regs[0];
+      else if (reg == fpu_fpcr_arm64 || reg == fpu_fpsr_arm64)
+        sve_reg_num = reg;
+      if (sve_reg_num != LLDB_INVALID_REGNUM) {
+        offset = CalculateSVEOffset(sve_reg_num);
+        assert(offset < GetSVEBufferSize());
+        src = (uint8_t *)GetSVEBuffer() + offset;
+      }
+    }
+  } else if (IsSVERegVG(reg)) {
+
+    sve_vg = GetSVERegVG();
+    src = (uint8_t *)&sve_vg;
+
+  } else if (IsSVE(reg)) {
+    if (m_sve_state == SVE_STATE::SVE_STATE_DISABLED) {
+      return Status("SVE disabled or not supported");
+    } else {
+      // SVE enabled, we will read and cache SVE ptrace data
+      if (!m_sve_buffer_is_valid) {
+        error = ReadAllSVE();
+        if (error.Fail())
+          return error;
+      }
+      if (m_sve_state == SVE_STATE::SVE_STATE_FPSIMD) {
+        sve_reg_non_live.resize(reg_info->byte_size, 0);
+        // In FPSIMD state SVE payload mirrors legacy fpsimd struct and so just
+        // copy 16 bytes of v register to the start of z register. All other
+        // SVE register will be set to zero.
+        if (IsSVEZReg(reg)) {
+          offset = CalculateSVEOffset(reg);
+          assert(offset < GetSVEBufferSize());
+          ::memcpy(sve_reg_non_live.data(), (uint8_t *)GetSVEBuffer() + offset,
+                   16);
+        }
+        src = sve_reg_non_live.data();
+      } else if (m_sve_state == SVE_STATE::SVE_STATE_FULL) {
+        offset = CalculateSVEOffset(reg);
+        assert(offset < GetSVEBufferSize());
+        src = (uint8_t *)GetSVEBuffer() + offset;
+      }
+    }
   } else
     return Status("failed - register wasn't recognized to be a GPR or an FPR, "
                   "write strategy unknown");
 
   reg_value.SetFromMemoryData(reg_info, src, reg_info->byte_size,
                               eByteOrderLittle, error);
 
   return error;
Status NativeRegisterContextLinux_arm64::WriteRegister(
   const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
 
   if (reg == LLDB_INVALID_REGNUM)
     return Status("no lldb regnum for %s", reg_info && reg_info->name
                                                ? reg_info->name
                                                : "<unknown register>");
 
   uint8_t *dst;
   uint32_t offset;
+  std::vector<uint8_t> sve_reg_non_live;
 
   if (IsGPR(reg)) {
     if (!m_gpr_is_valid) {
       error = ReadGPR();
       if (error.Fail())
         return error;
     }
 
     offset = reg_info->byte_offset;
     assert(offset < GetGPRSize());
     dst = (uint8_t *)GetGPRBuffer() + offset;
 
     ::memcpy(dst, reg_value.GetBytes(), reg_info->byte_size);
 
     return WriteGPR();
   } else if (IsFPR(reg)) {
+    if (m_sve_state == SVE_STATE::SVE_STATE_DISABLED) {
+      // SVE is disabled take legacy route for FPU register access
       if (!m_fpu_is_valid) {
         error = ReadFPR();
         if (error.Fail())
           return error;
       }
       offset = CalculateFprOffset(reg_info);
       assert(offset < GetFPRSize());
       dst = (uint8_t *)GetFPRBuffer() + offset;
 
       ::memcpy(dst, reg_value.GetBytes(), reg_info->byte_size);
 
       return WriteFPR();
+    } else {
+      // SVE enabled, we will read and cache SVE ptrace data
+      if (!m_sve_buffer_is_valid) {
+        error = ReadAllSVE();
+        if (error.Fail())
+          return error;
+      }
+      // Extract SVE Z register value register number for this reg_info
+      uint32_t sve_reg_num = LLDB_INVALID_REGNUM;
+      if (reg_info->value_regs &&
+          reg_info->value_regs[0] != LLDB_INVALID_REGNUM)
+        sve_reg_num = reg_info->value_regs[0];
+      else if (reg == fpu_fpcr_arm64 || reg == fpu_fpsr_arm64)
+        sve_reg_num = reg;
+      if (sve_reg_num != LLDB_INVALID_REGNUM) {
+        offset = CalculateSVEOffset(sve_reg_num);
+        assert(offset < GetSVEBufferSize());
+        dst = (uint8_t *)GetSVEBuffer() + offset;
+        ::memcpy(dst, reg_value.GetBytes(), reg_info->byte_size);
+        return WriteAllSVE();
+      }
+    }
+  } else if (IsSVERegVG(reg)) {
+    return Status("SVE state change operation not supported");
+  } else if (IsSVE(reg)) {
+    if (m_sve_state == SVE_STATE::SVE_STATE_DISABLED) {
+      return Status("SVE disabled or not supported");
+    } else {
+      // Target has SVE enabled, we will read and cache SVE ptrace data
+      if (!m_sve_buffer_is_valid) {
+        error = ReadAllSVE();
+        if (error.Fail())
+          return error;
       }
 
+      // If target supports SVE but currently in FPSIMD mode.
+      if (m_sve_state == SVE_STATE::SVE_STATE_FPSIMD) {
+        // Here we will check if writing this SVE register enables
+        // SVE_STATE_FULL
+        bool set_sve_state_full = false;
+        const uint8_t *reg_bytes = (const uint8_t *)reg_value.GetBytes();
+        if (IsSVEZReg(reg)) {
+          for (uint32_t i = 16; i < reg_info->byte_size; i++) {
+            if (reg_bytes[i]) {
+              set_sve_state_full = true;
+              break;
+            }
+          }
+        } else if (IsSVEPReg(reg) || reg == sve_ffr_arm64) {
+          for (uint32_t i = 0; i < reg_info->byte_size; i++) {
+            if (reg_bytes[i]) {
+              set_sve_state_full = true;
+              break;
+            }
+          }
+        }
+        if (set_sve_state_full) {
+          return Status("SVE state change operation not supported");
+        } else if (!set_sve_state_full && IsSVEZReg(reg)) {
+          // We are writing a Z register which is zero beyond 16 bytes so copy
+          // first 16 bytes only as SVE payload mirrors legacy fpsimd structure
+          offset = CalculateSVEOffset(reg);
+          assert(offset < GetSVEBufferSize());
+          dst = (uint8_t *)GetSVEBuffer() + offset;
+          ::memcpy(dst, reg_value.GetBytes(), 16);
+          return WriteAllSVE();
+        }
+      } else if (m_sve_state == SVE_STATE::SVE_STATE_FULL) {
+        offset = CalculateSVEOffset(reg);
+        assert(offset < GetSVEBufferSize());
+        dst = (uint8_t *)GetSVEBuffer() + offset;
+        ::memcpy(dst, reg_value.GetBytes(), reg_info->byte_size);
+        return WriteAllSVE();
+      }
+    }
+  }
   return error;
 }
 
 Status NativeRegisterContextLinux_arm64::ReadAllRegisterValues(
     lldb::DataBufferSP &data_sp) {
   Status error;
 
   data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));

 bool NativeRegisterContextLinux_arm64::IsGPR(unsigned reg) const {
   return reg <= m_reg_info.last_gpr; // GPR's come first.
 }
 
 bool NativeRegisterContextLinux_arm64::IsFPR(unsigned reg) const {
   return (m_reg_info.first_fpr <= reg && reg <= m_reg_info.last_fpr);
 }
 
+bool NativeRegisterContextLinux_arm64::IsSVE(unsigned reg) const {
+  return (m_reg_info.first_sve <= reg && reg <= m_reg_info.last_sve);
+}
+
+bool NativeRegisterContextLinux_arm64::IsSVEZReg(unsigned reg) const {
+  return (sve_z0_arm64 <= reg && reg <= sve_z31_arm64);
+}
+
+bool NativeRegisterContextLinux_arm64::IsSVEPReg(unsigned reg) const {
+  return (sve_p0_arm64 <= reg && reg <= sve_p15_arm64);
+}
+
+bool NativeRegisterContextLinux_arm64::IsSVERegVG(unsigned reg) const {
+  return (m_reg_info.first_sve == reg);
+}
+
 uint32_t NativeRegisterContextLinux_arm64::NumSupportedHardwareBreakpoints() {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_BREAKPOINTS));
 
   LLDB_LOGF(log, "NativeRegisterContextLinux_arm64::%s()", __FUNCTION__);
 
   Status error;
 
   // Read hardware breakpoint and watchpoint information.
NativeRegisterContextLinux_arm64::GetWatchpointHitAddress(uint32_t wp_index) {
 
   if (wp_index >= m_max_hwp_supported)
     return LLDB_INVALID_ADDRESS;
 
   if (WatchpointIsEnabled(wp_index))
     return m_hwp_regs[wp_index].hit_addr;
   else
     return LLDB_INVALID_ADDRESS;
   }
 
   Status NativeRegisterContextLinux_arm64::ReadHardwareDebugInfo() {
     if (!m_refresh_hwdebug_info) {
       return Status();
     }
 
     ::pid_t tid = m_thread.GetID();
 
     int regset = NT_ARM_HW_WATCH;
     struct iovec ioVec;
     struct user_hwdebug_state dreg_state;
     Status error;
 
     ioVec.iov_base = &dreg_state;
     ioVec.iov_len = sizeof(dreg_state);
     error = NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, tid, &regset,
                                               &ioVec, ioVec.iov_len);
 
     if (error.Fail())
       return error;
 
     m_max_hwp_supported = dreg_state.dbg_info & 0xff;
 
     regset = NT_ARM_HW_BREAK;
     error = NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, tid, &regset,
                                               &ioVec, ioVec.iov_len);
 
     if (error.Fail())
       return error;
 
     m_max_hbp_supported = dreg_state.dbg_info & 0xff;
     m_refresh_hwdebug_info = false;
 
     return error;
   }
 
   Status NativeRegisterContextLinux_arm64::WriteHardwareDebugRegs(int hwbType) {
     struct iovec ioVec;
     struct user_hwdebug_state dreg_state;
     Status error;
 
     memset(&dreg_state, 0, sizeof(dreg_state));
     ioVec.iov_base = &dreg_state;
 
     if (hwbType == eDREGTypeWATCH) {
       hwbType = NT_ARM_HW_WATCH;
       ioVec.iov_len = sizeof(dreg_state.dbg_info) + sizeof(dreg_state.pad) +
                       (sizeof(dreg_state.dbg_regs[0]) * m_max_hwp_supported);
 
       for (uint32_t i = 0; i < m_max_hwp_supported; i++) {
         dreg_state.dbg_regs[i].addr = m_hwp_regs[i].address;
         dreg_state.dbg_regs[i].ctrl = m_hwp_regs[i].control;
       }
     } else {
       hwbType = NT_ARM_HW_BREAK;
       ioVec.iov_len = sizeof(dreg_state.dbg_info) + sizeof(dreg_state.pad) +
                       (sizeof(dreg_state.dbg_regs[0]) * m_max_hbp_supported);
 
       for (uint32_t i = 0; i < m_max_hbp_supported; i++) {
         dreg_state.dbg_regs[i].addr = m_hbr_regs[i].address;
         dreg_state.dbg_regs[i].ctrl = m_hbr_regs[i].control;
       }
     }
 
     return NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, m_thread.GetID(),
                                              &hwbType, &ioVec, ioVec.iov_len);
   }
 
   Status NativeRegisterContextLinux_arm64::ReadGPR() {
     Status error;
 
     struct iovec ioVec;
 
     ioVec.iov_base = GetGPRBuffer();
     ioVec.iov_len = GetGPRSize();
 
     error = ReadRegisterSet(&ioVec, GetGPRSize(), NT_PRSTATUS);
 
     if (error.Success())
       m_gpr_is_valid = true;
 
     return error;
   }
 
   Status NativeRegisterContextLinux_arm64::WriteGPR() {
     struct iovec ioVec;
 
     m_gpr_is_valid = false;
 
     ioVec.iov_base = GetGPRBuffer();
     ioVec.iov_len = GetGPRSize();
 
     return WriteRegisterSet(&ioVec, GetGPRSize(), NT_PRSTATUS);
   }
 
   Status NativeRegisterContextLinux_arm64::ReadFPR() {
     Status error;
 
     struct iovec ioVec;
 
     ioVec.iov_base = GetFPRBuffer();
     ioVec.iov_len = GetFPRSize();
 
     error = ReadRegisterSet(&ioVec, GetFPRSize(), NT_FPREGSET);
 
     if (error.Success())
       m_fpu_is_valid = true;
 
     return error;
   }
 
   Status NativeRegisterContextLinux_arm64::WriteFPR() {
     struct iovec ioVec;
 
     m_fpu_is_valid = false;
 
     ioVec.iov_base = GetFPRBuffer();
     ioVec.iov_len = GetFPRSize();
 
     return WriteRegisterSet(&ioVec, GetFPRSize(), NT_FPREGSET);
   }
 
+  Status NativeRegisterContextLinux_arm64::ReadSVEHeader() {
+    Status error;
+
+    struct iovec ioVec;
+
+    ioVec.iov_base = GetSVEHeader();
+    ioVec.iov_len = GetSVEHeaderSize();
+
+    error = ReadRegisterSet(&ioVec, GetSVEHeaderSize(), NT_ARM_SVE);
+
+    m_sve_header_is_valid = true;
+
+    return error;
+  }
+
+  Status NativeRegisterContextLinux_arm64::WriteSVEHeader() {
+    Status error;
+
+    struct iovec ioVec;
+
+    ioVec.iov_base = GetSVEHeader();
+    ioVec.iov_len = GetSVEHeaderSize();
+
+    m_sve_buffer_is_valid = false;
+    m_sve_header_is_valid = false;
+
+    return WriteRegisterSet(&ioVec, GetSVEHeaderSize(), NT_ARM_SVE);
+  }
+
+  Status NativeRegisterContextLinux_arm64::ReadAllSVE() {
+    Status error;
+
+    struct iovec ioVec;
+
+    ioVec.iov_base = GetSVEBuffer();
+    ioVec.iov_len = GetSVEBufferSize();
+
+    error = ReadRegisterSet(&ioVec, GetSVEBufferSize(), NT_ARM_SVE);
+
+    if (error.Success())
+      m_sve_buffer_is_valid = true;
+
+    return error;
+  }
+
+  Status NativeRegisterContextLinux_arm64::WriteAllSVE() {
+    Status error;
+
+    struct iovec ioVec;
+
+    ioVec.iov_base = GetSVEBuffer();
+    ioVec.iov_len = GetSVEBufferSize();
+
+    m_sve_buffer_is_valid = false;
+    m_sve_header_is_valid = false;
+
+    return WriteRegisterSet(&ioVec, GetSVEBufferSize(), NT_ARM_SVE);
+  }
+
   void NativeRegisterContextLinux_arm64::InvalidateAllRegisters() {
     m_gpr_is_valid = false;
     m_fpu_is_valid = false;
+    m_sve_buffer_is_valid = false;
+    m_sve_header_is_valid = false;
+  }
+
+  void NativeRegisterContextLinux_arm64::ConfigureRegisterContext() {
+    if (!m_sve_header_is_valid) {
+      Status error = ReadSVEHeader();
+
+      if (error.Success()) {
+        if ((m_sve_header.flags & SVE_PT_REGS_MASK) == SVE_PT_REGS_FPSIMD)
+          m_sve_state = SVE_STATE::SVE_STATE_FPSIMD;
+        else if ((m_sve_header.flags & SVE_PT_REGS_MASK) == SVE_PT_REGS_SVE)
+          m_sve_state = SVE_STATE::SVE_STATE_FULL;
+
+        if (sve_vl_valid(m_sve_header.vl)) {
+          size_t vq = sve_vq_from_vl(m_sve_header.vl);
+          SetRegisterInfoMode(vq);
+          m_reg_info.num_registers = k_num_registers_arm64_sve;
+          m_sve_ptrace_payload.resize(SVE_PT_SIZE(vq, SVE_PT_REGS_SVE));
+        } else {
+          m_sve_state = SVE_STATE::SVE_STATE_DISABLED;
+          SetRegisterInfoMode(eRegisterInfoModeAArch64);
+        }
+      } else {
+        m_sve_state = SVE_STATE::SVE_STATE_DISABLED;
+        SetRegisterInfoMode(eRegisterInfoModeAArch64);
+      }
+    }
   }
 
   uint32_t NativeRegisterContextLinux_arm64::CalculateFprOffset(
       const RegisterInfo *reg_info) const {
     return reg_info->byte_offset -
            GetRegisterInfoAtIndex(m_reg_info.first_fpr)->byte_offset;
   }
 
+  uint32_t
+  NativeRegisterContextLinux_arm64::CalculateSVEOffset(uint32_t reg_num) const {
+    if (m_sve_state == SVE_STATE::SVE_STATE_FPSIMD) {
+      if (IsSVEZReg(reg_num))
+        return (reg_num - sve_z0_arm64) * 16;
+      else if (reg_num == fpu_fpsr_arm64)
+        return 32 * 16;
+      else if (reg_num == fpu_fpcr_arm64)
+        return (32 * 16) + 4;
+    } else if (m_sve_state == SVE_STATE::SVE_STATE_FULL) {
+      size_t vq = sve_vq_from_vl(m_sve_header.vl);
+      if (IsSVEZReg(reg_num))
+        return SVE_PT_SVE_ZREG_OFFSET(vq, reg_num - sve_z0_arm64);
+      else if (IsSVEPReg(reg_num))
+        return SVE_PT_SVE_PREG_OFFSET(vq, reg_num - sve_p0_arm64);
+      else if (reg_num == sve_ffr_arm64)
+        return SVE_PT_SVE_FFR_OFFSET(vq);
+      else if (reg_num == fpu_fpsr_arm64)
+        return SVE_PT_SVE_FPSR_OFFSET(vq);
+      else if (reg_num == fpu_fpcr_arm64)
+        return SVE_PT_SVE_FPCR_OFFSET(vq);
+    }
+    return 0;
+  }
+
+  void *NativeRegisterContextLinux_arm64::GetSVEBuffer() {
+    if (m_sve_state == SVE_STATE::SVE_STATE_FPSIMD)
+      return m_sve_ptrace_payload.data() + SVE_PT_FPSIMD_OFFSET;
+    return m_sve_ptrace_payload.data();
+  }
+
 #endif // defined (__arm64__) || defined (__aarch64__)

lldb/source/Plugins/Process/Linux/NativeThreadLinux.h

public:
   std::string GetName() override;
 
   lldb::StateType GetState() override;
 
   bool GetStopReason(ThreadStopInfo &stop_info,
                      std::string &description) override;
 
   NativeRegisterContextLinux &GetRegisterContext() override {
+    if (m_reg_context_up && IsStopped(nullptr))
+      m_reg_context_up->ConfigureRegisterContext();
+
     return *m_reg_context_up;
   }
 
   Status SetWatchpoint(lldb::addr_t addr, size_t size, uint32_t watch_flags,
                        bool hardware) override;
 
   Status RemoveWatchpoint(lldb::addr_t addr) override;
 

lldb/test/API/commands/register/register/aarch64_sve_registers/Makefile

+C_SOURCES := main.c
+
+CFLAGS_EXTRAS := -march=armv8-a+sve
+
+include Makefile.rules

lldb/test/API/commands/register/register/aarch64_sve_registers/TestSVERegisters.py

+"""
+Test the AArch64 SVE registers.
+"""
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class RegisterCommandsTestCase(TestBase):
+
+    def check_sve_register_size(self, set, name, expected):
+        reg_value = set.GetChildMemberWithName(name)
+        self.assertTrue(reg_value.IsValid(),
+                        'Verify we have a register named "%s"' % (name))
+        self.assertEqual(reg_value.GetByteSize(), expected,
+                         'Verify "%s" == %i' % (name, expected))
+
+    mydir = TestBase.compute_mydir(__file__)
+    @skipIf
+    def test_sve_registers_configuration(self):
+        """Test AArch64 SVE registers size configuration."""
+        self.build()
+        self.line = line_number('main.c', '// Set a break point here.')
+
+        exe = self.getBuildArtifact("a.out")
+        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+
+        lldbutil.run_break_set_by_file_and_line(self, "main.c", self.line, num_expected_locations=1)
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
+                        substrs = ["stop reason = breakpoint 1."])
+
+        target = self.dbg.GetSelectedTarget()
+        process = target.GetProcess()
+        thread = process.GetThreadAtIndex(0)
+        currentFrame = thread.GetFrameAtIndex(0)
+
+        has_sve = False
+        for registerSet in currentFrame.GetRegisters():
+            if 'sve registers' in registerSet.GetName().lower():
+                has_sve = True
+
+        if not has_sve:
+            self.skipTest('SVE registers must be supported.')        
+        
+        registerSets = process.GetThreadAtIndex(0).GetFrameAtIndex(0).GetRegisters()
+
+        sve_registers = registerSets.GetValueAtIndex(2)
+
+        vg_reg = sve_registers.GetChildMemberWithName("vg")
+
+        vg_reg_value = sve_registers.GetChildMemberWithName("vg").GetValueAsUnsigned()
+
+        z_reg_size = vg_reg_value * 8
+
+        p_reg_size = z_reg_size / 8
+
+        for i in range(32):
+            self.check_sve_register_size(sve_registers, 'z%i' % (i), z_reg_size)
+        
+        for i in range(16):
+            self.check_sve_register_size(sve_registers, 'p%i' % (i), p_reg_size)
+
+        self.check_sve_register_size(sve_registers, 'ffr', p_reg_size)
+
+    mydir = TestBase.compute_mydir(__file__)
+    @no_debug_info_test
+    @skipIf
+    def test_sve_registers_read_write(self):
+        """Test AArch64 SVE registers read and write."""
+        self.build()
+        self.line = line_number('main.c', '// Set a break point here.')
+
+        exe = self.getBuildArtifact("a.out")
+        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+
+        lldbutil.run_break_set_by_file_and_line(self, "main.c", self.line, num_expected_locations=1)
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
+                        substrs = ["stop reason = breakpoint 1."])
+
+        target = self.dbg.GetSelectedTarget()
+        process = target.GetProcess()
+        thread = process.GetThreadAtIndex(0)
+        currentFrame = thread.GetFrameAtIndex(0)
+
+        has_sve = False
+        for registerSet in currentFrame.GetRegisters():
+            if 'sve registers' in registerSet.GetName().lower():
+                has_sve = True
+
+        if not has_sve:
+            self.skipTest('SVE registers must be supported.')
+           
+        registerSets = process.GetThreadAtIndex(0).GetFrameAtIndex(0).GetRegisters()
+
+        sve_registers = registerSets.GetValueAtIndex(2)
+
+        vg_reg = sve_registers.GetChildMemberWithName("vg")
+
+        vg_reg_value = sve_registers.GetChildMemberWithName("vg").GetValueAsUnsigned()
+
+        z_reg_size = vg_reg_value * 8
+
+        p_reg_size = int(z_reg_size / 8)
+
+        z_regs_value = '{' + ' '.join(('0x9d' for _ in range(z_reg_size))) + '}'
+
+        p_regs_value = '{' + ' '.join(('0xee' for _ in range(p_reg_size))) + '}'
+
+        for i in range(32):
+           self.runCmd('register write ' + 'z%i' % (i) + " '" + z_regs_value + "'")
+        
+        for i in range(32):
+            self.expect("register read "  + 'z%i' % (i), substrs = [z_regs_value])
+
+        for i in range(16):
+           self.runCmd('register write ' + 'p%i' % (i) + " '" + p_regs_value + "'")
+        
+        for i in range(16):
+            self.expect("register read "  + 'p%i' % (i), substrs = [p_regs_value])
+        
+        self.runCmd('register write ' + 'ffr ' + "'"  + p_regs_value + "'")
+
+        self.expect("register read "  + 'ffr', substrs = [p_regs_value])
+

lldb/test/API/commands/register/register/aarch64_sve_registers/main.c

+int main() {
+  asm volatile("ptrue p0.s\n\t");
+  asm volatile("fcpy  z0.s, p0/m, #5.00000000\n\t");
+  return 0; // Set a break point here.
+}
 No newline at end of file