AArch64 SVE register infos and core file support

[omjavaid]

Summary

This patch adds support for AArch64 SVE register infos description and register access via ptrace.

AArch64 SVE is a an optional extension of Arm v8.3-a architecture which introduces 32 vector registers Z, 16 predicate P registers and FFR predicate register. These registers have fixed names but can dynamically be configured to different size based on underlying OS configuration.

This patch adds register info struct that describes SVE register infos. Also provides native register context routines to access SVE registers. It introduces a mechanism to configure SVE register size and offsets at startup before exchanging register information across gdb-remote process.

It makes use of linux kernel definitions copied into lldb/source/Plugins/Process/Linux/LinuxPTraceDefines_arm64sve.h for backward compatibility with sysroots which might yet not support SVE definitions.

There are two test cases added to the testsuite one of them checks register size configuration based on vg (vector granule register). Also a test is added which verifies registers can be read and written.

There is no physical hardware currently available to test SVE and we make use of QEMU for the purpose of testing this feature.

[labath]

There is no physical hardware currently available to test SVE and we make use of QEMU for the purpose of testing this feature.

Are these registers presented in core files in any way? Would it be possible to at least test the RegisterInfoPOSIX_arm64.h changes that way?

[omjavaid]

Posting full diff.

[omjavaid]

In D77047#1954696, @labath wrote:

There is no physical hardware currently available to test SVE and we make use of QEMU for the purpose of testing this feature.

Are these registers presented in core files in any way? Would it be possible to at least test the RegisterInfoPOSIX_arm64.h changes that way?

Yes. Core file section is added for SVE registers but i have not tried to get that working with LLDB. I will get back to you on this.

[omjavaid]

In D77047#1956774, @omjavaid wrote:

In D77047#1954696, @labath wrote:

There is no physical hardware currently available to test SVE and we make use of QEMU for the purpose of testing this feature.

Are these registers presented in core files in any way? Would it be possible to at least test the RegisterInfoPOSIX_arm64.h changes that way?

Yes. Core file section is added for SVE registers but i have not tried to get that working with LLDB. I will get back to you on this.

@labath Core file FP register access is not supported on AArch64. I am working on a follow up patch to fix it. This patch only has linux changes so can we get this through?

[labath]

In D77047#1966539, @omjavaid wrote:

@labath Core file FP register access is not supported on AArch64. I am working on a follow up patch to fix it. This patch only has linux changes so can we get this through?

This patch is a bit big and basically untested (an unconditionally skipped test hardly counts), so I am looking for ways to split it up and add some test coverage. I'm also worried about copying what appear to be chunks of linux header files...

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

42–43

Why can't this work be done in the register context constructor? I believe we are always creating a Thread (and its reg context) while it is stopped...

lldb/source/Plugins/Process/Utility/NativeRegisterContextRegisterInfo.h

38–40

I can't find any callers of this function. Who is calling it?

[omjavaid]

In D77047#1971454, @labath wrote:

In D77047#1966539, @omjavaid wrote:

@labath Core file FP register access is not supported on AArch64. I am working on a follow up patch to fix it. This patch only has linux changes so can we get this through?

This patch is a bit big and basically untested (an unconditionally skipped test hardly counts), so I am looking for ways to split it up and add some test coverage. I'm also worried about copying what appear to be chunks of linux header files...

I also considered licensing issues around copying this chunk but found GDB also copied this chunk of linux defines into its sources. I think its part of linux headers with license to freely use these headers in client programs. Do you know any licensing expert who can give us feedback on this patch? The only reason we have to include these headers here is that on older sysroots AArch64 compiler we wont be able to compile this code as they dont have these headers included so far but newer version do include these headers by default.

As for the test coverage I am working on a follow up to this patch that will include corefile support I hope we ll be able to test major portion of this patch with that support.

[labath]

In D77047#1980248, @omjavaid wrote:

In D77047#1971454, @labath wrote:

In D77047#1966539, @omjavaid wrote:

@labath Core file FP register access is not supported on AArch64. I am working on a follow up patch to fix it. This patch only has linux changes so can we get this through?

This patch is a bit big and basically untested (an unconditionally skipped test hardly counts), so I am looking for ways to split it up and add some test coverage. I'm also worried about copying what appear to be chunks of linux header files...

I also considered licensing issues around copying this chunk but found GDB also copied this chunk of linux defines into its sources. I think its part of linux headers with license to freely use these headers in client programs. Do you know any licensing expert who can give us feedback on this patch? The only reason we have to include these headers here is that on older sysroots AArch64 compiler we wont be able to compile this code as they dont have these headers included so far but newer version do include these headers by default.

The situation might be different for gdb since they're both GPL-ish. For licensing questions you could try mailing llvm foundation.

[omjavaid]

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

1191

SetRegisterInfoMode(vq); is getting called over here.

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

42–43

ConfigureRegisterContext makes sure that sve register offsets and sizes are correctly updated and synced from ptrace on every stop. If SVE registers reconfigure themselves we ll have to update that information into our dynamic register infos array. Although for the context of this patch it assumes it will never change its register size during execution. But I will follow up patch that implements that behaviour.

[omjavaid]

This update includes core file register access for SVE registers. Register descriptions can now be tested with core dump.

@labath Should I post QEMU SVE setup instructions somewhere if you want to have a go at running included test cases.?

[omjavaid]

Also about licensing issues of included macros I am in contact with original authors from ARM and I hope they will be able to help sign off this patch for LLVM submission.

[labath]

In D77047#1996198, @omjavaid wrote:

This update includes core file register access for SVE registers. Register descriptions can now be tested with core dump.

Cool. Could you please split off the stuff necessary for making core files work into a separate patch, and have the "native" patch be on top of that. I want to get an idea of how much of new code is included in the second patch.

@labath Should I post QEMU SVE setup instructions somewhere if you want to have a go at running included test cases.?

I think that would be very valuable. Not really much for this patch (I probably wont get around to running it), but for any future contributors (inlcuding myself) whose patches break some arm stuff (be it SVE-related or not).

In D77047#1996202, @omjavaid wrote:

Also about licensing issues of included macros I am in contact with original authors from ARM and I hope they will be able to help sign off this patch for LLVM submission.

Awesome.

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

1191

Ok, I see. That makes sense. The part that seems pretty unfortunate here is that you've needed to add a fairly strange function to the generic (RegisterInfoInterface) interface even though the caller and callee are in arm64-specific code. Let's see if we can avoid that.

What if, instead of remangling the register infos in RegisterInfoPOSIX_arm64 every time that SetRegisterInfoMode is called, the "mode" was a argument to the class constructor, and changing of the mode was implemented by creating a new "info" object? I.e., this code would instead of calling SetRegisterInfoMode(vq);, do something like m_register_info_interface_up = std::make_unique<RegisterInfoPOSIX_arm64>(vq);

Would that work?

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

42–43

Ok, that makes sense now. The thing on my mind in that case is that this functionality overlaps a lot with InvalidateAllRegisters we've added a couple of patches back. I think it would be nice to have just one function which "reinitializes" a register context. InvalidateAllRegisters wouldn't work right now, because it's called before a resume, but if we changed it to be called after a stop, it would be able to do both things.

Would it be possible to change it so that this InvalidateAllRegisters is called after a stop, e.g. in NativeThreadLinux::SetStopped. I am sorry for the churn, I know it was my idea to call it before a resume -- it seemed like a reasonable thing to do at the time, but not any more.. :(

[omjavaid]

This patch now contains AArch64 SVE register infos description and support for core dump SVE register access. Linux ptrace support will be submitted in a follow up patch while linux ptrace headers are being submitted by Arm under license agreement separately.

[labath]

(sorry about all the editing -- I'm trying to figure out the order of these patches)

[omjavaid]

New update contains minor update needed to accommodate SVE PTrace macros header from ARM.

[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.

[labath]

I'm worried about the confusing relationship between RegisterInfos_arm64_sve.h and RegisterInfos_arm64.h and the overlap in the register numbers it enforces. when we discussed this last time, my understanding was that the sve registers could be inserted _before_ the debug registers (similar to what happened with D24255). Now I see that may not be possible because some of these registers are used in the darwin arm64 register context. However, that makes the whole idea much less appealing.

Would it be possible to organize these headers like this:

• create a new header which holds common register definitions: this would be register numbers for the gpr and fpr registers (and their respective _contains arrays).
• have RegisterInfos_arm64_sve.h include this header and provide additional register definitions, and define its RegisterInfo array to match
• have RegisterInfos_arm64.h to the same

What I am hoping to achieve this way is to remove the DECLARE_REGISTER_INFOS_ARM64_SVE_STRUCT condition macro (dragons (ODR violations) lie there), and the duplicate enum values associated with it.

[omjavaid]

In this updated I have removed overlapping parts of RegisterInfos_arm64.h and RegisterInfos_arm64_sve.h which in turn removes any possibility of duplicate definitions.

Both register infos define separate static register info arrays namely g_register_infos_arm64_le and g_register_infos_arm64_sve_le. Definition of FPR registers is also different and their invalidate/contains reg lists are also different. For the context of all native register context which do not yet support SVE g_register_infos_arm64_le will be used as they only include RegisterInfos_arm64.h.

@labath do you think there is still chance of any ODR violations?

[labath]

There's always a chance for ODR violations, particularly with header files defining static objects. This looks better though what I really wanted was to keep the non-sve register info array (g_register_infos_arm64_le) completely out of the path of the sve header. Like, by using three headers, one defining g_register_infos_arm64_le (and stuff specific to that like the exception registers), one defining the sve array, and the third one which would contain the things common to both. Nonetheless, I think we can now move on to aspects of this patch. Please see my inline comments.

lldb/source/Plugins/Process/Utility/NativeRegisterContextRegisterInfo.h

38–40

It still seems to me that this function is not used (in this patch at least).

lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_arm64.cpp

259

http://llvm.org/docs/CodingStandards.html#don-t-use-else-after-a-return

lldb/source/Plugins/Process/Utility/RegisterInfoInterface.h

64–68

I don't believe these functions should be present on the generic interface. The only caller and the only implementation of them is already arm64-specific, so it should be possible to arrange it such that they don't need to go through the base class interface. For instance the RegisterContextCorePOSIX_arm64 constructor could accept an RegisterInfoPOSIX_arm64 instance to indicate what it needs to work with, and then downcast m_register_info_up (via a helper function?) when it needs to call these. Solutions without downcasting are possible too, though may require a bit more refactoring.

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

72–89

no else after return

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.h

51–53

Do these need to be public? If so, why?

74

Why is this mutable?

[omjavaid]

In D77047#2125220, @labath wrote:

There's always a chance for ODR violations, particularly with header files defining static objects. This looks better though what I really wanted was to keep the non-sve register info array (g_register_infos_arm64_le) completely out of the path of the sve header. Like, by using three headers, one defining g_register_infos_arm64_le (and stuff specific to that like the exception registers), one defining the sve array, and the third one which would contain the things common to both. Nonetheless, I think we can now move on to aspects of this patch. Please see my inline comments.

I am working to fix this with D80105 by defining dynamic register infos array based on register sets which will be requirement for Pointer Authentication and MTE. But I wanted to first get done with SVE and come back to register infos refactoring later.

lldb/source/Plugins/Process/Utility/NativeRegisterContextRegisterInfo.h

38–40

Ack. This function is used by chiild revisions which adds ptrace support. I ll move it there.

lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_arm64.cpp

259

Ack.

lldb/source/Plugins/Process/Utility/RegisterInfoInterface.h

64–68

Agreed. I ll make an arrangement for this in updated rev.

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

72–89

Ack.

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.h

51–53

These should be private. I ll update this in updated rev.

74

It was pulled in from NativeRegisterContextLinux_arm64 and got set mutable by mistake I ll correct in updated rev.

[omjavaid]

@labath I have updated diff after resolving issues highlighted. Also I have removed dependence on generic interfaces.

[labath]

Thanks. This looks is starting to look good now. I didn't get a chance to review all of the changes, but here's a few more things that I noticed.

lldb/source/Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h

72–76

Now that this is arm-specific, I am wondering if there isn't a better name for this than "register info 'mode'". Maybe it could be just "enable/disable SVE" ? Specifically, if the validity of the "mode" is checked by the caller, then we can avoid this RegisterInfoModeIsValid business...

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

20

It would be also nice if this constructor accepted a RegisterInfoPOSIX_arm64 instead of plain RegisterInfoInterface. That would make it much harder to misuse this class. For that we'd need to slightly refactor the construction code in ThreadElfCore. For example, we could swap the order of the "os" and "machine" switches and then join the two "machine" switches that construct RegisterInfoInterfaces and RegisterContexts.

Maybe you could do that as a separate patch?

72–89

Well.. that's one way of handing that.. :) It's not necessarily bad, but I was imagining you would just delete all the "else"s...

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.h

17–22

This is including platform-specific headers, but elf cores should be readable from any host. I guess you should just re-define the relevant constants somewhere. (I'm not sure what they are.)

lldb/source/Utility/ARM64_DWARF_Registers.h

54–147

All of these numbers are from the official spec, right? Maybe you could just commit this straight away so it does not clutter this review.

[omjavaid]

This update incorporates suggestion from last iteration and also rebases after merger to registersets 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 ?

[labath]

I didn't notice this before, but I see now that there's more register number overlap in lldb-arm64-register-enums.h. Having one overlapping enum is bad enough, but two seems really too much? Can we avoid the second enum somehow, at least? Perhaps by switching RegisterContextCorePOSIX_arm64 to use the other enum definitions for its work?

lldb/source/Plugins/Process/Utility/RegisterInfoPOSIX_arm64.cpp

125–126

This comment looks outdated.

149

IIUC, m_sve_enabled is only true if m_vector_reg_vq is not zero. Could we delete this variable and just make a function to make that comparison?

157–160

It doesn't look like m_dynamic_register_infos is needed -- you could just make m_register_info_p point directly into the map.

lldb/source/Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h

72

The offset argument is not set anywhere.

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.h

17

I guess this does not make sense now that the header is standalone

[omjavaid]

This update addresses issues raised in last iteration. Also have removed dependence on lldb-arm64-register-enums.h.

[labath]

Some more comments (and questions) from me. Sorry about the back-and-forth. It's taking me a while to wrap my head around this, and as I start to understand things, new questions arise...

lldb/source/Plugins/Process/Utility/RegisterInfoPOSIX_arm64.cpp

151–159

I'd probably try relying on the fact that operator[] constructs an empty vector, and that the empty vector is not a valid register info value. Something like:

std::vector<RegisterInfo> &new_reg_info = m_per_vq_reg_infos[sve_vq];
if (new_reg_info.empty()) {
  new_reg_info = llvm::makeArrayRef(g_register_infos_arm64_sve_le, m_register_info_count);
  ...
}
m_register_info_p = new_reg_info.data();

That would make this less of a mouthful and also avoid looking up the same key in the map three or four times.

lldb/source/Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h

17–22

If this is going to be a class enum (which I think is a good idea), then there's no need to repeat the type name in the actual enumerators. It also seems like this could/should follow the lldb naming conventions (SveState::Disabled, etc).

lldb/source/Plugins/Process/Utility/lldb-arm64-register-enums.h

316

I guess these changes should be reverted now?

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

134–158

I'm confused by this function. If I understant the SVE_PT macros and the logic in RegisterInfoPOSIX_arm64::ConfigureVectorRegisterInfos correctly, then they both seem to encode the same information. And it seems to me that this function should just be reg_infos[reg_num].offset - some_constant, which is the same thing that we're doing for the arm FP registers when SVE is disabled, and also for most other architectures too.

Why is that not the case? Am I missing something? If they are not encoding the same thing, could they be made to encode the same thing?

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.h

17

Please group the header next to other Plugins/Process/Utility header

lldb/test/API/functionalities/postmortem/elf-core/TestLinuxCore.py

314–315

What's up with these?

[omjavaid]

In D77047#2125220, @labath wrote:

There's always a chance for ODR violations, particularly with header files defining static objects. This looks better though what I really wanted was to keep the non-sve register info array (g_register_infos_arm64_le) completely out of the path of the sve header. Like, by using three headers, one defining g_register_infos_arm64_le (and stuff specific to that like the exception registers), one defining the sve array, and the third one which would contain the things common to both. Nonetheless, I think we can now move on to aspects of this patch. Please see my inline comments.

I am working to fix this with D80105 by defining dynamic register infos array based on register sets which will be requirement for Pointer Authentication and MTE. But I wanted to first get done with SVE and come back to register infos refactoring later.

lldb/source/Plugins/Process/Utility/RegisterInfoPOSIX_arm64.cpp

151–159

ACK

lldb/source/Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h

17–22

ACK

lldb/source/Plugins/Process/Utility/lldb-arm64-register-enums.h

316

ACK

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

134–158

This function calculates offset of a particular register in core note data. SVE data in core dump is similar to what PTrace emits and offsets into this data is not linear. SVE macros are used to access those offsets based on register numbers and currently selected vector length.
Also for the purpose of ease we have linear offsets in SVE register infos and it helps us simplify register data once it makes way to GDBRemoteRegisterContext on the client side.

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.h

17

ACK

lldb/test/API/functionalities/postmortem/elf-core/TestLinuxCore.py

314–315

Sorry Typo

[labath]

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

134–158

Could you give an example of the non-linearity of the core dump data? (Some registers, and their respective core file and gdb-remote offsets)

[omjavaid]

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

134–158

In case of core file we create a buffer m_sveregset which stores SVE core note information
m_sveregset =

getRegset(notes, m_register_info_up->GetTargetArchitecture().GetTriple(),
          AARCH64_SVE_Desc);

At this point we do not know what was the vector length and at what offsets in the data our registers are located. We read top bytes of size use_sve_header and read vector length. Based on this information we configure vector length in Register infos. While the SVE payload starts with user_sve_header then there are some allignment bytes followed by vector length based Z registers followed by P and FFR, then there are some more allginment bytes followd by FPCR and FPSR. Macros provided by Linux help us jump to the desired offset by providing register number and vq into the core note or Ptrace payload.

In case of client side storage we store GPRs at linear offset followed by Vector Granule register. Then there are SVE registers Z, P, FFR, FPSR and FPCR. Offsets of V, D and S registers in FPR regset overlap with corresponding first bytes of Z registers and will be same as corresponding Z register. While both FP/SVE FPSR share same register offset, size and register number.

Here is an excerpt from https://github.com/torvalds/linux/blob/master/Documentation/arm64/sve.rst

SVE_PT_REGS_FPSIMD
SVE registers are not live (GETREGSET) or are to be made non-live (SETREGSET).
The payload is of type struct user_fpsimd_state, with the same meaning as for NT_PRFPREG, starting at offset SVE_PT_FPSIMD_OFFSET from the start of user_sve_header.
Extra data might be appended in the future: the size of the payload should be obtained using SVE_PT_FPSIMD_SIZE(vq, flags).
vq should be obtained using sve_vq_from_vl(vl).

or

SVE_PT_REGS_SVE
SVE registers are live (GETREGSET) or are to be made live (SETREGSET).
The payload contains the SVE register data, starting at offset SVE_PT_SVE_OFFSET from the start of user_sve_header, and with size SVE_PT_SVE_SIZE(vq, flags);

[labath]

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

134–158

Given this

SVE payload starts with ... followed by vector length based Z registers followed by P and FFR,

and this

In case of client side storage we store GPRs ... Then there are SVE registers Z, P, FFR, FPSR and FPCR

I would expect that for each of the Z, P and FFR registers, the expression offset_in_core(reg) - offset_in_gdb_remote(reg) is always the same constant (and is basically equal to SVE_PT_SVE_ZREG_OFFSET(vq, 0) - reg_info[Z0].byte_offset). So we could just add/subtract that constant to the gdb-remote byte_offset field instead of painstakingly decomposing the register number only for the linux macros to reconstruct it back again. Is that not so?

[omjavaid]

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

134–158

The standard never talks about Z, P and FFR being contagious that is what I learnt by reading macros. There standard states this:

If the registers are present, the remainder of the record has a vl-dependent size and layout. Macros SVE_SIG_* are defined [1] to facilitate access to the members.
Each scalable register (Zn, Pn, FFR) is stored in an endianness-invariant layout, with bits [(8 * i + 7) : (8 * i)] stored at byte offset i from the start of the register's representation in memory.
If the SVE context is too big to fit in sigcontext.reserved[], then extra space is allocated on the stack, an extra_context record is written in reserved[] referencing this space. sve_context is then written in the extra space. Refer to [1] for further details about this mechanism.

I understand what you are talking about but given the macros were specifically provided and above line about register record was vague and I thought best is to follow the macros for offset calculation although other way around is simpler but may be slightly unreliable.

I suggest to keep this as it is unless there is strong reason apart from slight performance penalty. This resembles with GDB implementation which was done by ARM and I am only following that as reference. May be we can revise this in future when the feature becomes more mainstream.

[labath]

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

134–158

I'm not worried about the performance penalty (most of these abstractions can be optimized away anyway). I'm more worried about the maintainability penalty incurred by a non-standard and fairly complicated solution.

The way I see it, it doesn't really matter how exactly the specification describes these things. Having the macros is nice, but it's not their names that become a part of the ABI -- their implementation does. So they (linux, arm, whoever) cannot change the layout of the these registers without breaking all existing applications (and core files) any more than they can change the layout of the general purpose registers (which we also access by offset, without any fancy macros). In fact, even if they did change the layout, given that we have a copy of these headers, we wouldn't automatically inherit those changes anyway, but would have to take some manual action. And since we'd probably want to maintain some sort of backwards compatibility, we couldn't just replace the new macro definitions, but would have to do some sort of versioning (just today I got reminded that lldb contains versioned layouts of various internal structs used by the ObjC runtime).

So, for that reason I am more concerned about consistency with other lldb register contexts than I am with consistency with gdb.

Also, I bet gdb doesn't have an equivalent of our RegisterInfo struct. Without that, using these macros would be obviously better, but given that we have that, and we already use it to access other registers, ditching that for macros does not seem like a win to me.

Another way to look at this would be to compare this to e.g. ELF reading code in llvm. We cannot just include <linux/elf.h> as we want this to be cross-platform. However, we also don't just copy the header blindly into our code base. We don't depart from it needlessly, but we do make sure that it plays well with the rest of llvm -- #defines are changed to enums, we add templates to select between 64/32 bit versions, change some platform-specific names so that different platforms may co-exist, etc.

[omjavaid]

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

134–158

I understand your point here and by referring to Linux, Arm or GDB implementation I only wanted to make sure that we are implementing the architecture and platform specific parts correctly. The choice of using Linux/SVE specific macros in elf-core context was not a blind decision. I am not advocating for following a particular implementations and I would not have pulled in these Linux specific macros into elf-core implementation if the SVE core note layout was independent of Linux platform specifics like sig_context and user_sve_header. Offset to the start of register data in NT_ARM_SVE is also calculated after doing alignment correction based on VQ and size of sig_context. Given that SVE is currently supported by Linux only, NT_ARM_SVE is Linux only core note and core dump generated makes use of these macro definitions I had no choice but to include them for extraction of data from NT_ARM_SVE section. If I had not followed these macros I still would have written something similar my self for register data extraction from NT_ARM_SVE elf core note.

I am going to post another update where I ll try to minimize use of these macros in offset calculation.

[omjavaid]

This update address issues highlighted in last iteration and also minimizes the use of SVE_PT macros by using RegisterInfo.byte_size and byte_offset where possible.

@labath What do you think ?

[omjavaid]

Minor fix removing GetRegNumP0 which is no longer needed.

[labath]

At this point, I think I (finally) have a good understanding of both how this patch works and interacts with the rest of the world. I have one more batch of comments, but hopefully none are too controversial, and I really do hope this is the last iteration.

lldb/source/Plugins/Process/Utility/RegisterInfoPOSIX_arm64.cpp

158

I think all uses of new_reg_info_p could just be replaced by reg_info_ref

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

115–118

What's up with this copying? We already have the data in the m_sveregset DataExtractor. What's the reason for copying it into the m_sve_note_payload vector? Also, m_sve_header seems like it could just be a reinterpret_casted pointer into that buffer instead of a copy. (Maybe not even a pointer, just a utility function which performs the cast when called).

Actually, when I think about casts and data extractors, I am reminded of endianness. This will access those fields using host endianness, which is most likely not what we want to do. So, probably the best/simplest solution would be to indeed declare a user_sve_header struct, but don't populate it via memcpy, but rather via the appropriate DataExtractor extraction methods. Since the only field of the user_sve_header used outside this function is the vl field, perhaps the struct could be a local variable and only the vector length would be persisted. That would be consistent with how the flags field is decoded and stored into the m_sve_state field.

(If the struct fields are always little-endian (if that's true, I thought arm has BE variants) then you could also stick to the reinterpret_cast idea, but change the types of the struct fields to llvm::support::ulittleXX_t to read them as LE independently of the host.)

132

This IsFPR check is now redundant.

134–158

Thanks for your patience. I think this looks better. The more I understand how these work, the more I realize that will need fairly special handling..

136–138

This is already checked by ReadRegister and the false -> uint32_t conversion is dodgy. An assertion would completely suffice here.

144–145

These two registers are special-cased both here and in the CalculateSVEOffset. Given that both functions also do a switch over the sve "states", it makes following the code quite challenging. What if we moved the handling of these registers completely up-front, and removed their handling from CalculateSVEOffset completely?
I'm thinking of something like:

if (reg == GetRegNumFPCR() && m_sve_state != SVEState::Disabled) {
  src = GetSVEBuffer() + GetFPCROffset(); // Or maybe just inline GetFPCROffset here
} else if (reg == GetRegNumFPSR() && m_sve_state != SVEState::Disabled) {
  src = ...;
} if (IsFPR(reg)) {
  // as usual, only you can assume that FP[CS]R are already handled if SVE is enabled
}

153–154

This also looks endian-incorrect. Maybe value = GetSVERegVG(); return true; ?

156

A switch over possible m_sve_state values would likely be cleaner.

166

I guess it would be better to do the cast inside GetSVEBuffer. (and please make that a c++ reinterpret_cast).

172

it seems that src should be a const pointer.

[omjavaid]

lldb/source/Plugins/Process/Utility/RegisterInfoPOSIX_arm64.cpp

158

Ack.

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

115–118

Agreed m_sve_note_payload is redundant. Most of the implementation was mirrored from ptrace implementation and I was lazy enough and did not remove the redundancies which are not needed in case of core dump.

About endianess of SVE data I dont think it will create any problem as the data is transferred in endian invariant format. According to the standard here:

• Whenever SVE scalable register values (Zn, Pn, FFR) are exchanged in memory between userspace and the kernel, the register value is encoded in memory in an endianness-invariant layout, with bits [(8 * i + 7) : (8 * i)] encoded at byte offset i from the start of the memory representation. This affects for example the signal frame (struct sve_context) and ptrace interface (struct user_sve_header) and associated data.

132

Ack,

136–138

Ack.

144–145

Ok will try to update in next revision.

153–154

Endian invariant as explained above.

156

Ack.

166

Ack.

172

Ack.

[omjavaid]

In this update I have addressed issues highlighted in last review iteration.

@labath Does this now look LGTM?

[labath]

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

115–118

Ok, so if I parse that correctly, this is basically saying that the register values are always little-endian. Fair enough. However, lldb will be reading these things using the host endianness, so the values will be incorrect on a big-endian host.

Also, the are you sure that this includes the metadata in the user_sve_header field? The documentation does mention the struct explicitly, but then it also very explicitly speaks about register values. The data in the struct is not a register value, and I can find no evidence of byte-swapping in the linux kernel (https://github.com/torvalds/linux/blob/master/arch/arm64/kernel/ptrace.c#L769).

[omjavaid]

This update plugs the holes susceptible to bugs by endianity variations. I have used DataExtractor GetU16 to read flags and vl from user_sve_header. Also removed the memset and replaced it with SetFromMemoryData function.

Moreover a new test is added which tests SVE FPSIMD mode core file.

[omjavaid]

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

115–118

@labath Thanks for being great help in this review. I think you were right about the user_sve_header being susceptible to endianity problems. I have plugged the issues now.

[labath]

I think this is as good as we can get right now. Thanks for sticking through. Two quick comments inline.

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

164–165

Are there any FPR registers which we should not be able to retrieve from the SVE state? I'm wondering if this should be turned into an assert.

180–184

It looks like this is only used in the IsSVEZ(reg) block below. You could move the declarations there and avoid initializations with bogus values.

[omjavaid]

This update makes minor adjustments before merge in light of final comments.

lldb/include/lldb/Target/RegisterContext.h

WriteRegisterValueToMemory(const lldb_private::RegisterInfo *reg_info,
                              lldb::addr_t dst_addr, uint32_t dst_len,
                              const RegisterValue &reg_value);
 
   // Subclasses should not override these
   virtual lldb::tid_t GetThreadID() const;
 
   virtual Thread &GetThread() { return m_thread; }
 
-  const RegisterInfo *GetRegisterInfoByName(llvm::StringRef reg_name,
+  virtual const RegisterInfo *GetRegisterInfoByName(llvm::StringRef reg_name,
                                                     uint32_t start_idx = 0);
 
   const RegisterInfo *GetRegisterInfo(lldb::RegisterKind reg_kind,
                                       uint32_t reg_num);
 
   uint64_t GetPC(uint64_t fail_value = LLDB_INVALID_ADDRESS);
 
   bool SetPC(uint64_t pc);
 

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

+//===-- LinuxPtraceDefs_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
+//
+//===----------------------------------------------------------------------===//
+
+// This file provides Linux specific defines to enable compilation with SVE
+// ptrace support. These defines may later be removed once they get defined
+// in Procfs.h and Ptrace.h.
+
+// References in Linux kernel source:
+// 1) Documentation/arm64/sve.txt
+// 2) arch/arm64/include/uapi/asm/ptrace.h
+// 3) arch/arm64/include/uapi/asm/sve_context.h
+#ifdef INCLUDE_LINUX_PTRACE_DEFINITIONS_FOR_SVE_ARM64
+
+#ifndef lldb_LinuxPtraceDefs_arm64_h
+#define lldb_LinuxPtraceDefs_arm64_h
+
+#include <asm/types.h>
+
+#if !defined(__arm64__) && !defined(__aarch64__)
+struct _aarch64_ctx {
+  __u32 magic;
+  __u32 size;
+};
+#endif
+
+#define SVE_MAGIC 0x53564501
+
+struct sve_context {
+  struct _aarch64_ctx head;
+  __u16 vl;
+  __u16 __reserved[3];
+};
+
+/*
+ * The SVE architecture leaves space for future expansion of the
+ * vector length beyond its initial architectural limit of 2048 bits
+ * (16 quadwords).
+ *
+ * See linux/Documentation/arm64/sve.txt for a description of the VL/VQ
+ * terminology.
+ */
+#define SVE_VQ_BYTES 16 /* number of bytes per quadword */
+
+#define SVE_VQ_MIN 1
+#define SVE_VQ_MAX 512
+
+#define SVE_VL_MIN (SVE_VQ_MIN * SVE_VQ_BYTES)
+#define SVE_VL_MAX (SVE_VQ_MAX * SVE_VQ_BYTES)
+
+#define SVE_NUM_ZREGS 32
+#define SVE_NUM_PREGS 16
+
+#define sve_vl_valid(vl)                                                       \
+  ((vl) % SVE_VQ_BYTES == 0 && (vl) >= SVE_VL_MIN && (vl) <= SVE_VL_MAX)
+#define sve_vq_from_vl(vl) ((vl) / SVE_VQ_BYTES)
+#define sve_vl_from_vq(vq) ((vq)*SVE_VQ_BYTES)
+
+/*
+ * If the SVE registers are currently live for the thread at signal delivery,
+ * sve_context.head.size >=
+ *  SVE_SIG_CONTEXT_SIZE(sve_vq_from_vl(sve_context.vl))
+ * and the register data may be accessed using the SVE_SIG_*() macros.
+ *
+ * If sve_context.head.size <
+ *  SVE_SIG_CONTEXT_SIZE(sve_vq_from_vl(sve_context.vl)),
+ * the SVE registers were not live for the thread and no register data
+ * is included: in this case, the SVE_SIG_*() macros should not be
+ * used except for this check.
+ *
+ * The same convention applies when returning from a signal: a caller
+ * will need to remove or resize the sve_context block if it wants to
+ * make the SVE registers live when they were previously non-live or
+ * vice-versa.  This may require the the caller to allocate fresh
+ * memory and/or move other context blocks in the signal frame.
+ *
+ * Changing the vector length during signal return is not permitted:
+ * sve_context.vl must equal the thread's current vector length when
+ * doing a sigreturn.
+ *
+ *
+ * Note: for all these macros, the "vq" argument denotes the SVE
+ * vector length in quadwords (i.e., units of 128 bits).
+ *
+ * The correct way to obtain vq is to use sve_vq_from_vl(vl).  The
+ * result is valid if and only if sve_vl_valid(vl) is true.  This is
+ * guaranteed for a struct sve_context written by the kernel.
+ *
+ *
+ * Additional macros describe the contents and layout of the payload.
+ * For each, SVE_SIG_x_OFFSET(args) is the start offset relative to
+ * the start of struct sve_context, and SVE_SIG_x_SIZE(args) is the
+ * size in bytes:
+ *
+ *  x type        description
+ *  - ----        -----------
+ *  REGS          the entire SVE context
+ *
+ *  ZREGS __uint128_t[SVE_NUM_ZREGS][vq]  all Z-registers
+ *  ZREG  __uint128_t[vq]     individual Z-register Zn
+ *
+ *  PREGS uint16_t[SVE_NUM_PREGS][vq] all P-registers
+ *  PREG  uint16_t[vq]      individual P-register Pn
+ *
+ *  FFR uint16_t[vq]      first-fault status register
+ *
+ * Additional data might be appended in the future.
+ */
+
+#define SVE_SIG_ZREG_SIZE(vq) ((__u32)(vq)*SVE_VQ_BYTES)
+#define SVE_SIG_PREG_SIZE(vq) ((__u32)(vq) * (SVE_VQ_BYTES / 8))
+#define SVE_SIG_FFR_SIZE(vq) SVE_SIG_PREG_SIZE(vq)
+
+#define SVE_SIG_REGS_OFFSET                                                    \
+  ((sizeof(struct sve_context) + (SVE_VQ_BYTES - 1)) / SVE_VQ_BYTES *          \
+   SVE_VQ_BYTES)
+
+#define SVE_SIG_ZREGS_OFFSET SVE_SIG_REGS_OFFSET
+#define SVE_SIG_ZREG_OFFSET(vq, n)                                             \
+  (SVE_SIG_ZREGS_OFFSET + SVE_SIG_ZREG_SIZE(vq) * (n))
+#define SVE_SIG_ZREGS_SIZE(vq)                                                 \
+  (SVE_SIG_ZREG_OFFSET(vq, SVE_NUM_ZREGS) - SVE_SIG_ZREGS_OFFSET)
+
+#define SVE_SIG_PREGS_OFFSET(vq) (SVE_SIG_ZREGS_OFFSET + SVE_SIG_ZREGS_SIZE(vq))
+#define SVE_SIG_PREG_OFFSET(vq, n)                                             \
+  (SVE_SIG_PREGS_OFFSET(vq) + SVE_SIG_PREG_SIZE(vq) * (n))
+#define SVE_SIG_PREGS_SIZE(vq)                                                 \
+  (SVE_SIG_PREG_OFFSET(vq, SVE_NUM_PREGS) - SVE_SIG_PREGS_OFFSET(vq))
+
+#define SVE_SIG_FFR_OFFSET(vq)                                                 \
+  (SVE_SIG_PREGS_OFFSET(vq) + SVE_SIG_PREGS_SIZE(vq))
+
+#define SVE_SIG_REGS_SIZE(vq)                                                  \
+  (SVE_SIG_FFR_OFFSET(vq) + SVE_SIG_FFR_SIZE(vq) - SVE_SIG_REGS_OFFSET)
+
+#define SVE_SIG_CONTEXT_SIZE(vq) (SVE_SIG_REGS_OFFSET + SVE_SIG_REGS_SIZE(vq))
+
+/* SVE/FP/SIMD state (NT_ARM_SVE) */
+
+struct user_sve_header {
+  __u32 size;     /* total meaningful regset content in bytes */
+  __u32 max_size; /* maxmium possible size for this thread */
+  __u16 vl;       /* current vector length */
+  __u16 max_vl;   /* maximum possible vector length */
+  __u16 flags;
+  __u16 __reserved;
+};
+
+/* Definitions for user_sve_header.flags: */
+#define SVE_PT_REGS_MASK (1 << 0)
+
+#define SVE_PT_REGS_FPSIMD 0
+#define SVE_PT_REGS_SVE SVE_PT_REGS_MASK
+
+/*
+ * Common SVE_PT_* flags:
+ * These must be kept in sync with prctl interface in <linux/ptrace.h>
+ */
+#define SVE_PT_VL_INHERIT (PR_SVE_VL_INHERIT >> 16)
+#define SVE_PT_VL_ONEXEC (PR_SVE_SET_VL_ONEXEC >> 16)
+
+/*
+ * The remainder of the SVE state follows struct user_sve_header.  The
+ * total size of the SVE state (including header) depends on the
+ * metadata in the header:  SVE_PT_SIZE(vq, flags) gives the total size
+ * of the state in bytes, including the header.
+ *
+ * Refer to <asm/sigcontext.h> for details of how to pass the correct
+ * "vq" argument to these macros.
+ */
+
+/* Offset from the start of struct user_sve_header to the register data */
+#define SVE_PT_REGS_OFFSET                                                     \
+  ((sizeof(struct sve_context) + (SVE_VQ_BYTES - 1)) / SVE_VQ_BYTES *          \
+   SVE_VQ_BYTES)
+
+/*
+ * The register data content and layout depends on the value of the
+ * flags field.
+ */
+
+/*
+ * (flags & SVE_PT_REGS_MASK) == SVE_PT_REGS_FPSIMD case:
+ *
+ * The payload starts at offset SVE_PT_FPSIMD_OFFSET, and is of type
+ * struct user_fpsimd_state.  Additional data might be appended in the
+ * future: use SVE_PT_FPSIMD_SIZE(vq, flags) to compute the total size.
+ * SVE_PT_FPSIMD_SIZE(vq, flags) will never be less than
+ * sizeof(struct user_fpsimd_state).
+ */
+
+#define SVE_PT_FPSIMD_OFFSET SVE_PT_REGS_OFFSET
+
+#define SVE_PT_FPSIMD_SIZE(vq, flags) (sizeof(struct user_fpsimd_state))
+
+/*
+ * (flags & SVE_PT_REGS_MASK) == SVE_PT_REGS_SVE case:
+ *
+ * The payload starts at offset SVE_PT_SVE_OFFSET, and is of size
+ * SVE_PT_SVE_SIZE(vq, flags).
+ *
+ * Additional macros describe the contents and layout of the payload.
+ * For each, SVE_PT_SVE_x_OFFSET(args) is the start offset relative to
+ * the start of struct user_sve_header, and SVE_PT_SVE_x_SIZE(args) is
+ * the size in bytes:
+ *
+ *  x type        description
+ *  - ----        -----------
+ *  ZREGS   \
+ *  ZREG    |
+ *  PREGS   | refer to <asm/sigcontext.h>
+ *  PREG    |
+ *  FFR   /
+ *
+ *  FPSR  uint32_t      FPSR
+ *  FPCR  uint32_t      FPCR
+ *
+ * Additional data might be appended in the future.
+ */
+
+#define SVE_PT_SVE_ZREG_SIZE(vq) SVE_SIG_ZREG_SIZE(vq)
+#define SVE_PT_SVE_PREG_SIZE(vq) SVE_SIG_PREG_SIZE(vq)
+#define SVE_PT_SVE_FFR_SIZE(vq) SVE_SIG_FFR_SIZE(vq)
+#define SVE_PT_SVE_FPSR_SIZE sizeof(__u32)
+#define SVE_PT_SVE_FPCR_SIZE sizeof(__u32)
+
+#define __SVE_SIG_TO_PT(offset)                                                \
+  ((offset)-SVE_SIG_REGS_OFFSET + SVE_PT_REGS_OFFSET)
+
+#define SVE_PT_SVE_OFFSET SVE_PT_REGS_OFFSET
+
+#define SVE_PT_SVE_ZREGS_OFFSET __SVE_SIG_TO_PT(SVE_SIG_ZREGS_OFFSET)
+#define SVE_PT_SVE_ZREG_OFFSET(vq, n)                                          \
+  __SVE_SIG_TO_PT(SVE_SIG_ZREG_OFFSET(vq, n))
+#define SVE_PT_SVE_ZREGS_SIZE(vq)                                              \
+  (SVE_PT_SVE_ZREG_OFFSET(vq, SVE_NUM_ZREGS) - SVE_PT_SVE_ZREGS_OFFSET)
+
+#define SVE_PT_SVE_PREGS_OFFSET(vq) __SVE_SIG_TO_PT(SVE_SIG_PREGS_OFFSET(vq))
+#define SVE_PT_SVE_PREG_OFFSET(vq, n)                                          \
+  __SVE_SIG_TO_PT(SVE_SIG_PREG_OFFSET(vq, n))
+#define SVE_PT_SVE_PREGS_SIZE(vq)                                              \
+  (SVE_PT_SVE_PREG_OFFSET(vq, SVE_NUM_PREGS) - SVE_PT_SVE_PREGS_OFFSET(vq))
+
+#define SVE_PT_SVE_FFR_OFFSET(vq) __SVE_SIG_TO_PT(SVE_SIG_FFR_OFFSET(vq))
+
+#define SVE_PT_SVE_FPSR_OFFSET(vq)                                             \
+  ((SVE_PT_SVE_FFR_OFFSET(vq) + SVE_PT_SVE_FFR_SIZE(vq) +                      \
+    (SVE_VQ_BYTES - 1)) /                                                      \
+   SVE_VQ_BYTES * SVE_VQ_BYTES)
+#define SVE_PT_SVE_FPCR_OFFSET(vq)                                             \
+  (SVE_PT_SVE_FPSR_OFFSET(vq) + SVE_PT_SVE_FPSR_SIZE)
+
+/*
+ * Any future extension appended after FPCR must be aligned to the next
+ * 128-bit boundary.
+ */
+
+#define SVE_PT_SVE_SIZE(vq, flags)                                             \
+  ((SVE_PT_SVE_FPCR_OFFSET(vq) + SVE_PT_SVE_FPCR_SIZE - SVE_PT_SVE_OFFSET +    \
+    (SVE_VQ_BYTES - 1)) /                                                      \
+   SVE_VQ_BYTES * SVE_VQ_BYTES)
+
+#define SVE_PT_SIZE(vq, flags)                                                 \
+  (((flags)&SVE_PT_REGS_MASK) == SVE_PT_REGS_SVE                               \
+       ? SVE_PT_SVE_OFFSET + SVE_PT_SVE_SIZE(vq, flags)                        \
+       : SVE_PT_FPSIMD_OFFSET + SVE_PT_FPSIMD_SIZE(vq, flags))
+
+#endif
+#endif

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;
 
+  uint32_t GetNativeRegisterIndex(uint32_t reg_index) 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;
+}
+
+uint32_t NativeRegisterContextLinux_arm64::GetNativeRegisterIndex(
+    uint32_t reg_index) const {
+  if (reg_index < m_reg_info.num_gpr_registers)
+    return g_reg_sets_arm64[0].registers[reg_index];
+
+  reg_index -= m_reg_info.num_gpr_registers;
+  if (reg_index < m_reg_info.num_fpr_registers)
+    return g_reg_sets_arm64[1].registers[reg_index];
+
+  if (m_sve_state == SVE_STATE::SVE_STATE_FPSIMD ||
+      m_sve_state == SVE_STATE::SVE_STATE_FULL) {
+    reg_index -= m_reg_info.num_fpr_registers;
+    if (reg_index < m_reg_info.num_sve_registers)
+      return g_reg_sets_arm64[2].registers[reg_index];
+  }
+
+  return LLDB_INVALID_REGNUM;
 }
 
 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(
 
   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.
case 0x03:
     return 2;
   case 0x0f:
     return 4;
   case 0xff:
     return 8;
   default:
     return 0;
   }
   }
-bool NativeRegisterContextLinux_arm64::WatchpointIsEnabled(uint32_t wp_index) {
+  bool
+  NativeRegisterContextLinux_arm64::WatchpointIsEnabled(uint32_t wp_index) {
     Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
     LLDB_LOG(log, "wp_index: {0}", wp_index);
 
     if ((m_hwp_regs[wp_index].control & 0x1) == 0x1)
       return true;
     else
       return false;
   }
 
   Status NativeRegisterContextLinux_arm64::GetWatchpointHitIndex(
       uint32_t &wp_index, lldb::addr_t trap_addr) {
     Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
     LLDB_LOG(log, "wp_index: {0}, trap_addr: {1:x}", wp_index, trap_addr);
 
     uint32_t watch_size;
     lldb::addr_t watch_addr;
 
     for (wp_index = 0; wp_index < m_max_hwp_supported; ++wp_index) {
       watch_size = GetWatchpointSize(wp_index);
       watch_addr = m_hwp_regs[wp_index].address;
 
       if (WatchpointIsEnabled(wp_index) && trap_addr >= watch_addr &&
           trap_addr < watch_addr + watch_size) {
         m_hwp_regs[wp_index].hit_addr = trap_addr;
         return Status();
       }
     }
 
     wp_index = LLDB_INVALID_INDEX32;
     return Status();
   }
 
   lldb::addr_t
   NativeRegisterContextLinux_arm64::GetWatchpointAddress(uint32_t wp_index) {
     Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
     LLDB_LOG(log, "wp_index: {0}", wp_index);
 
     if (wp_index >= m_max_hwp_supported)
       return LLDB_INVALID_ADDRESS;
 
     if (WatchpointIsEnabled(wp_index))
       return m_hwp_regs[wp_index].real_addr;
     else
       return LLDB_INVALID_ADDRESS;
   }
 
   lldb::addr_t
   NativeRegisterContextLinux_arm64::GetWatchpointHitAddress(uint32_t wp_index) {
     Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
     LLDB_LOG(log, "wp_index: {0}", 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_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/source/Plugins/Process/Utility/NativeRegisterContextRegisterInfo.h

public:
   uint32_t GetUserRegisterCount() const override;
 
   uint32_t GetNativeRegisterIndex(uint32_t reg_index) const override;
 
   const RegisterInfo *GetRegisterInfoAtIndex(uint32_t reg_index) const override;
 
   const RegisterInfoInterface &GetRegisterInfoInterface() const;
 
+  uint32_t SetRegisterInfoMode(uint32_t mode) {
+    return m_register_info_interface_up->SetRegisterInfoMode(mode);
+  }
+
 private:
   std::unique_ptr<RegisterInfoInterface> m_register_info_interface_up;
 };
 }
 #endif

lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_arm64.h

public:
 
   const lldb_private::RegisterSet *GetRegisterSet(size_t set) override;
 
   const char *GetRegisterName(unsigned reg);
 
   uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
                                                uint32_t num) override;
 
+  const lldb_private::RegisterInfo *
+  GetRegisterInfoByName(llvm::StringRef reg_name,
+                        uint32_t start_idx = 0) override;
+
 protected:
   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];
   };
 
uint64_t m_gpr_arm64[lldb_private::k_num_gpr_registers_arm64]; // 64-bit
                                                                  // purpose
                                                                  // registers.
   RegInfo m_reg_info;
   struct RegisterContextPOSIX_arm64::FPU
       m_fpr; // floating-point registers including extended register sets.
   std::unique_ptr<lldb_private::RegisterInfoInterface>
       m_register_info_up; // Register Info Interface (FreeBSD or Linux)
 
+  bool m_sve_enabled;
   // Determines if an extended register set is supported on the processor
   // running the inferior process.
   virtual bool IsRegisterSetAvailable(size_t set_index);
 
   virtual const lldb_private::RegisterInfo *GetRegisterInfo();
 
   bool IsGPR(unsigned reg);
 
   bool IsFPR(unsigned reg);
 
+  bool IsSVE(unsigned reg) const;
+
+  bool IsSVEZReg(unsigned reg) const;
+
+  bool IsSVEPReg(unsigned reg) const;
+
+  bool IsSVERegVG(unsigned reg) const;
+
   lldb::ByteOrder GetByteOrder();
 
   virtual bool ReadGPR() = 0;
   virtual bool ReadFPR() = 0;
   virtual bool WriteGPR() = 0;
   virtual bool WriteFPR() = 0;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTPOSIX_ARM64_H

lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_arm64.cpp

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 };
+} // namespace
 
 // Register sets for ARM64.
 static const lldb_private::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}};
 
 bool RegisterContextPOSIX_arm64::IsGPR(unsigned reg) {
   return reg <= m_reg_info.last_gpr; // GPR's come first.
 }
 
 bool RegisterContextPOSIX_arm64::IsFPR(unsigned reg) {
   return (m_reg_info.first_fpr <= reg && reg <= m_reg_info.last_fpr);
 }
 
+bool RegisterContextPOSIX_arm64::IsSVE(unsigned reg) const {
+  return (m_reg_info.first_sve <= reg && reg <= m_reg_info.last_sve);
+}
+
+bool RegisterContextPOSIX_arm64::IsSVEZReg(unsigned reg) const {
+  return (sve_z0_arm64 <= reg && reg <= sve_z31_arm64);
+}
+
+bool RegisterContextPOSIX_arm64::IsSVEPReg(unsigned reg) const {
+  return (sve_p0_arm64 <= reg && reg <= sve_p15_arm64);
+}
+
+bool RegisterContextPOSIX_arm64::IsSVERegVG(unsigned reg) const {
+  return (m_reg_info.first_sve == reg);
+}
+
+const lldb_private::RegisterInfo *
+RegisterContextPOSIX_arm64::GetRegisterInfoByName(llvm::StringRef reg_name,
+                                                  uint32_t start_idx) {
+  if (reg_name.empty())
+    return nullptr;
+
+  uint32_t num_register_sets = GetRegisterSetCount();
+  for (uint32_t set_idx = 0; set_idx < num_register_sets; ++set_idx) {
+    const RegisterSet *const reg_set = GetRegisterSet(set_idx);
+    const size_t num_registers = reg_set->num_registers;
+
+    for (size_t reg_idx = 0; reg_idx < num_registers; ++reg_idx) {
+      const uint32_t reg = reg_set->registers[reg_idx];
+      const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
+
+      if (reg_name.equals_lower(reg_info->name) ||
+          reg_name.equals_lower(reg_info->alt_name))
+        return reg_info;
+    }
+  }
+
+  return nullptr;
+}
+
 RegisterContextPOSIX_arm64::RegisterContextPOSIX_arm64(
     lldb_private::Thread &thread, uint32_t concrete_frame_idx,
     lldb_private::RegisterInfoInterface *register_info)
     : lldb_private::RegisterContext(thread, concrete_frame_idx) {
   m_register_info_up.reset(register_info);
 
   switch (register_info->m_target_arch.GetMachine()) {
   case llvm::Triple::aarch64:
   case llvm::Triple::aarch64_32:
     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:
     assert(false && "Unhandled target architecture.");
     break;
   }
 
+  m_sve_enabled = false;
   ::memset(&m_fpr, 0, sizeof m_fpr);
 }
 
 RegisterContextPOSIX_arm64::~RegisterContextPOSIX_arm64() {}
 
 void RegisterContextPOSIX_arm64::Invalidate() {}
 
 void RegisterContextPOSIX_arm64::InvalidateAllRegisters() {}
 
 unsigned RegisterContextPOSIX_arm64::GetRegisterOffset(unsigned reg) {
   assert(reg < m_reg_info.num_registers && "Invalid register number.");
   return GetRegisterInfo()[reg].byte_offset;
 }
 
 unsigned RegisterContextPOSIX_arm64::GetRegisterSize(unsigned reg) {
   assert(reg < m_reg_info.num_registers && "Invalid register number.");
   return GetRegisterInfo()[reg].byte_size;
 }
 
 size_t RegisterContextPOSIX_arm64::GetRegisterCount() {
   size_t num_registers =
       m_reg_info.num_gpr_registers + m_reg_info.num_fpr_registers;
+  if (m_sve_enabled)
+    return num_registers + m_reg_info.num_sve_registers;
   return num_registers;
 }
 
 size_t RegisterContextPOSIX_arm64::GetGPRSize() {
   return m_register_info_up->GetGPRSize();
 }
 
 const lldb_private::RegisterInfo *
for (size_t set = 0; set < k_num_register_sets; ++set) {
     if (IsRegisterSetAvailable(set))
       ++sets;
   }
 
   return sets;
 }
 
 const lldb_private::RegisterSet *
 RegisterContextPOSIX_arm64::GetRegisterSet(size_t set) {
   if (IsRegisterSetAvailable(set)) {
     switch (m_register_info_up->m_target_arch.GetMachine()) {
     case llvm::Triple::aarch64:
     case llvm::Triple::aarch64_32:
       return &g_reg_sets_arm64[set];
     default:
       assert(false && "Unhandled target architecture.");
       return nullptr;
lldb::ByteOrder RegisterContextPOSIX_arm64::GetByteOrder() {
   lldb_private::Process *process = CalculateProcess().get();
 
   if (process)
     byte_order = process->GetByteOrder();
   return byte_order;
 }
 
 bool RegisterContextPOSIX_arm64::IsRegisterSetAvailable(size_t set_index) {
+  if (m_sve_enabled)
     return set_index < k_num_register_sets;
+  else
+    return set_index < (k_num_register_sets - 1);
 }
 
 // Used when parsing DWARF and EH frame information and any other object file
 // sections that contain register numbers in them.
 uint32_t RegisterContextPOSIX_arm64::ConvertRegisterKindToRegisterNumber(
     lldb::RegisterKind kind, uint32_t num) {
   const uint32_t num_regs = GetRegisterCount();
 

lldb/source/Plugins/Process/Utility/RegisterInfoInterface.h

GetDynamicRegisterInfo(const char *reg_name) const {
     return nullptr;
   }
 
   virtual const std::vector<lldb_private::RegisterInfo> *
   GetDynamicRegisterInfoP() const {
     return nullptr;
   }
 
+  virtual uint32_t SetRegisterInfoMode(uint32_t mode, uint32_t offset = 0) {
+    return 0;
+  }
+
+  virtual uint32_t GetRegisterInfoMode() const { return 0; }
+
 public:
   // FIXME make private.
   lldb_private::ArchSpec m_target_arch;
 };
 }
 
 #endif

lldb/source/Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h

 //===-- RegisterInfoPOSIX_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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERINFOPOSIX_ARM64_H
 #define LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERINFOPOSIX_ARM64_H
 
 #include "RegisterInfoInterface.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/lldb-private.h"
+#include <map>
+
+// AArch64 Register set FP/SIMD feature configuration
+enum {
+  eRegisterInfoModeAArch64,
+  eRegisterInfoModeAArch64SVE,
+  eRegisterInfoModeAArch64SVEMax = 256
+};
 
 class RegisterInfoPOSIX_arm64 : public lldb_private::RegisterInfoInterface {
 public:
   // based on RegisterContextDarwin_arm64.h
   struct GPR {
     uint64_t x[29]; // x0-x28
     uint64_t fp;    // x29
     uint64_t lr;    // x30
public:
   RegisterInfoPOSIX_arm64(const lldb_private::ArchSpec &target_arch);
 
   size_t GetGPRSize() const override;
 
   const lldb_private::RegisterInfo *GetRegisterInfo() const override;
 
   uint32_t GetRegisterCount() const override;
 
+  uint32_t SetRegisterInfoMode(uint32_t mode, uint32_t offset = 0) override;
+
+  uint32_t GetRegisterInfoMode() const override;
+
+  bool RegisterInfoModeIsValid(uint32_t mode) {
+    if (mode >= eRegisterInfoModeAArch64 &&
+        mode <= eRegisterInfoModeAArch64SVEMax)
+      return true;
+    return false;
+  }
+
 private:
+  typedef std::vector<lldb_private::RegisterInfo> dynamic_register_infos;
+  typedef std::map<uint32_t, dynamic_register_infos> per_mode_register_infos;
+
+  dynamic_register_infos m_dynamic_register_infos = {};
+  per_mode_register_infos m_per_vl_reg_infos;
+
+  uint32_t m_reg_info_mode = eRegisterInfoModeAArch64;
+
   const lldb_private::RegisterInfo *m_register_info_p;
   uint32_t m_register_info_count;
 };
 
 #endif

lldb/source/Plugins/Process/Utility/RegisterInfoPOSIX_arm64.cpp

 #define GPR_OFFSET_NAME(reg)                                                   \
   (LLVM_EXTENSION offsetof(RegisterInfoPOSIX_arm64::GPR, reg))
 
 #define FPU_OFFSET(idx) ((idx)*16 + sizeof(RegisterInfoPOSIX_arm64::GPR))
 #define FPU_OFFSET_NAME(reg)                                                   \
   (LLVM_EXTENSION offsetof(RegisterInfoPOSIX_arm64::FPU, reg) +                \
    sizeof(RegisterInfoPOSIX_arm64::GPR))
 
+// This information is based on AArch64 with SVE architecture reference manual.
+// AArch64 with SVE has 32 Z and 16 P vector registers. There is also an FFR
+// (First Fault) register and a VG (Vector Granule) pseudo register.
+
+// SVE 16-byte quad word is the basic unit of expansion in vector length.
+#define SVE_QUAD_WORD_BYTES 16
+
+// Vector length is the multiplier which decides the no of quad words,
+// (multiples of 128-bits or 16-bytes) present in a Z register. Vector length
+// is decided during execution and can change at runtime. SVE AArch64 register
+// infos have modes one for each valid value of vector length. A change in
+// vector length requires register context to update sizes of SVE Z, P and FFR.
+// Also register context needs to update byte offsets of all registers affected
+// by the change in vector length.
+#define SVE_REGS_DEFAULT_OFFSET_LINUX sizeof(RegisterInfoPOSIX_arm64::GPR)
+
+#define SVE_OFFSET_VG SVE_REGS_DEFAULT_OFFSET_LINUX
+
 #define EXC_OFFSET_NAME(reg)                                                   \
   (LLVM_EXTENSION offsetof(RegisterInfoPOSIX_arm64::EXC, reg) +                \
    sizeof(RegisterInfoPOSIX_arm64::GPR) +                                      \
    sizeof(RegisterInfoPOSIX_arm64::FPU))
+
 #define DBG_OFFSET_NAME(reg)                                                   \
   (LLVM_EXTENSION offsetof(RegisterInfoPOSIX_arm64::DBG, reg) +                \
    sizeof(RegisterInfoPOSIX_arm64::GPR) +                                      \
    sizeof(RegisterInfoPOSIX_arm64::FPU) +                                      \
    sizeof(RegisterInfoPOSIX_arm64::EXC))
 
 #define DEFINE_DBG(reg, i)                                                     \
   #reg, NULL,                                                                  \
       sizeof(((RegisterInfoPOSIX_arm64::DBG *) NULL)->reg[i]),                 \
               DBG_OFFSET_NAME(reg[i]), lldb::eEncodingUint, lldb::eFormatHex,  \
                               {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,       \
                                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,       \
                                dbg_##reg##i },                                 \
                                NULL, NULL, NULL, 0
 #define REG_CONTEXT_SIZE                                                       \
   (sizeof(RegisterInfoPOSIX_arm64::GPR) +                                      \
    sizeof(RegisterInfoPOSIX_arm64::FPU) +                                      \
    sizeof(RegisterInfoPOSIX_arm64::EXC))
 
 // Include RegisterInfos_arm64 to declare our g_register_infos_arm64 structure.
 #define DECLARE_REGISTER_INFOS_ARM64_STRUCT
+#define DECLARE_REGISTER_INFOS_ARM64_SVE_STRUCT
 #include "RegisterInfos_arm64.h"
+#include "RegisterInfos_arm64_sve.h"
 #undef DECLARE_REGISTER_INFOS_ARM64_STRUCT
+#undef DECLARE_REGISTER_INFOS_ARM64_SVE_STRUCT
 
 static const lldb_private::RegisterInfo *
 GetRegisterInfoPtr(const lldb_private::ArchSpec &target_arch) {
   switch (target_arch.GetMachine()) {
   case llvm::Triple::aarch64:
   case llvm::Triple::aarch64_32:
     return g_register_infos_arm64_le;
   default:

 const lldb_private::RegisterInfo *
 RegisterInfoPOSIX_arm64::GetRegisterInfo() const {
   return m_register_info_p;
 }
 
 uint32_t RegisterInfoPOSIX_arm64::GetRegisterCount() const {
   return m_register_info_count;
 }
+
+uint32_t RegisterInfoPOSIX_arm64::SetRegisterInfoMode(uint32_t mode,
+                                                      uint32_t offset) {
+  // Register info mode denotes SVE vector length in context of AArch64.
+  // Register info mode once set to zero permanently selects default static
+  // AArch64 register info and cannot be changed to SVE. Also if an invalid
+  // or previously set vector length is passed to this function then it will
+  // exit immediately with previously set vector length.
+  if (!RegisterInfoModeIsValid(mode) || m_reg_info_mode == mode)
+    return m_reg_info_mode;
+
+  if (mode == eRegisterInfoModeAArch64 &&
+      m_reg_info_mode > eRegisterInfoModeAArch64)
+    mode = eRegisterInfoModeAArch64SVE;
+
+  m_reg_info_mode = mode;
+
+  if (mode == eRegisterInfoModeAArch64) {
+    m_register_info_count =
+        static_cast<uint32_t>(sizeof(g_register_infos_arm64_le) /
+                              sizeof(g_register_infos_arm64_le[0]));
+    m_register_info_p = g_register_infos_arm64_le;
+
+    return m_reg_info_mode;
+  }
+
+  m_dynamic_register_infos.clear();
+
+  m_register_info_count =
+      static_cast<uint32_t>(sizeof(g_register_infos_arm64_sve_le) /
+                            sizeof(g_register_infos_arm64_sve_le[0]));
+
+  if (m_per_vl_reg_infos.count(mode)) {
+    m_dynamic_register_infos = m_per_vl_reg_infos.at(mode);
+    m_register_info_p = &m_dynamic_register_infos[0];
+    return m_reg_info_mode;
+  }
+
+  m_dynamic_register_infos = std::vector<lldb_private::RegisterInfo>(
+      g_register_infos_arm64_sve_le,
+      g_register_infos_arm64_sve_le + m_register_info_count);
+  m_register_info_p = &m_dynamic_register_infos[0];
+
+  if (!offset)
+    offset = SVE_REGS_DEFAULT_OFFSET_LINUX;
+
+  m_dynamic_register_infos[sve_vg].byte_offset = offset;
+  offset += m_dynamic_register_infos[sve_vg].byte_size;
+
+  // Update Z registers size and offset
+  uint32_t s_reg_base = fpu_s0;
+  uint32_t d_reg_base = fpu_d0;
+  uint32_t v_reg_base = fpu_v0;
+  uint32_t z_reg_base = sve_z0;
+
+  for (uint32_t index = 0; index < 32; index++) {
+    m_dynamic_register_infos[s_reg_base + index].byte_offset = offset;
+    m_dynamic_register_infos[d_reg_base + index].byte_offset = offset;
+    m_dynamic_register_infos[v_reg_base + index].byte_offset = offset;
+    m_dynamic_register_infos[z_reg_base + index].byte_offset = offset;
+
+    m_dynamic_register_infos[z_reg_base + index].byte_size =
+        mode * SVE_QUAD_WORD_BYTES;
+    offset += m_dynamic_register_infos[z_reg_base + index].byte_size;
+  }
+
+  // Update P registers and FFR size and offset
+  for (uint32_t it = sve_p0; it <= sve_ffr; it++) {
+    m_dynamic_register_infos[it].byte_offset = offset;
+    m_dynamic_register_infos[it].byte_size = mode * SVE_QUAD_WORD_BYTES / 8;
+    offset += m_dynamic_register_infos[it].byte_size;
+  }
+
+  m_dynamic_register_infos[fpu_fpsr].byte_offset = offset;
+  m_dynamic_register_infos[fpu_fpcr].byte_offset = offset + 4;
+
+  m_per_vl_reg_infos.insert(std::make_pair(mode, m_dynamic_register_infos));
+
+  return m_reg_info_mode;
+}
+
+uint32_t RegisterInfoPOSIX_arm64::GetRegisterInfoMode() const {
+  return m_reg_info_mode;
+}

lldb/source/Plugins/Process/Utility/RegisterInfos_arm64.h

enum {
   dbg_wcr9,
   dbg_wcr10,
   dbg_wcr11,
   dbg_wcr12,
   dbg_wcr13,
   dbg_wcr14,
   dbg_wcr15,
 
+#ifdef DECLARE_REGISTER_INFOS_ARM64_SVE_STRUCT
+  sve_fpsr = fpu_fpsr,
+  sve_fpcr = fpu_fpcr,
+
+  sve_vg = dbg_wcr15 + 1,
+
+  sve_z0,
+  sve_z1,
+  sve_z2,
+  sve_z3,
+  sve_z4,
+  sve_z5,
+  sve_z6,
+  sve_z7,
+  sve_z8,
+  sve_z9,
+  sve_z10,
+  sve_z11,
+  sve_z12,
+  sve_z13,
+  sve_z14,
+  sve_z15,
+  sve_z16,
+  sve_z17,
+  sve_z18,
+  sve_z19,
+  sve_z20,
+  sve_z21,
+  sve_z22,
+  sve_z23,
+  sve_z24,
+  sve_z25,
+  sve_z26,
+  sve_z27,
+  sve_z28,
+  sve_z29,
+  sve_z30,
+  sve_z31,
+
+  sve_p0,
+  sve_p1,
+  sve_p2,
+  sve_p3,
+  sve_p4,
+  sve_p5,
+  sve_p6,
+  sve_p7,
+  sve_p8,
+  sve_p9,
+  sve_p10,
+  sve_p11,
+  sve_p12,
+  sve_p13,
+  sve_p14,
+  sve_p15,
+
+  sve_ffr,
+
+#endif
   k_num_registers
 };
 
 static uint32_t g_x0_invalidates[] = {gpr_w0, LLDB_INVALID_REGNUM};
 static uint32_t g_x1_invalidates[] = {gpr_w1, LLDB_INVALID_REGNUM};
 static uint32_t g_x2_invalidates[] = {gpr_w2, LLDB_INVALID_REGNUM};
 static uint32_t g_x3_invalidates[] = {gpr_w3, LLDB_INVALID_REGNUM};
 static uint32_t g_x4_invalidates[] = {gpr_w4, LLDB_INVALID_REGNUM};

lldb/source/Plugins/Process/Utility/RegisterInfos_arm64_sve.h

+//===-- RegisterInfos_arm64_sve.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
+//
+//===----------------------------------------------------------------------===//
+
+#ifdef DECLARE_REGISTER_INFOS_ARM64_SVE_STRUCT
+
+#ifndef SVE_OFFSET_VG
+#error SVE_OFFSET_VG must be defined before including this header file
+#endif
+
+static uint32_t g_sve_s0_invalidates[] = {sve_z0, fpu_v0, fpu_d0,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s1_invalidates[] = {sve_z1, fpu_v1, fpu_d1,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s2_invalidates[] = {sve_z2, fpu_v2, fpu_d2,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s3_invalidates[] = {sve_z3, fpu_v3, fpu_d3,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s4_invalidates[] = {sve_z4, fpu_v4, fpu_d4,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s5_invalidates[] = {sve_z5, fpu_v5, fpu_d5,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s6_invalidates[] = {sve_z6, fpu_v6, fpu_d6,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s7_invalidates[] = {sve_z7, fpu_v7, fpu_d7,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s8_invalidates[] = {sve_z8, fpu_v8, fpu_d8,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s9_invalidates[] = {sve_z9, fpu_v9, fpu_d9,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s10_invalidates[] = {sve_z10, fpu_v10, fpu_d10,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s11_invalidates[] = {sve_z11, fpu_v11, fpu_d11,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s12_invalidates[] = {sve_z12, fpu_v12, fpu_d12,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s13_invalidates[] = {sve_z13, fpu_v13, fpu_d13,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s14_invalidates[] = {sve_z14, fpu_v14, fpu_d14,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s15_invalidates[] = {sve_z15, fpu_v15, fpu_d15,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s16_invalidates[] = {sve_z16, fpu_v16, fpu_d16,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s17_invalidates[] = {sve_z17, fpu_v17, fpu_d17,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s18_invalidates[] = {sve_z18, fpu_v18, fpu_d18,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s19_invalidates[] = {sve_z19, fpu_v19, fpu_d19,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s20_invalidates[] = {sve_z20, fpu_v20, fpu_d20,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s21_invalidates[] = {sve_z21, fpu_v21, fpu_d21,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s22_invalidates[] = {sve_z22, fpu_v22, fpu_d22,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s23_invalidates[] = {sve_z23, fpu_v23, fpu_d23,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s24_invalidates[] = {sve_z24, fpu_v24, fpu_d24,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s25_invalidates[] = {sve_z25, fpu_v25, fpu_d25,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s26_invalidates[] = {sve_z26, fpu_v26, fpu_d26,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s27_invalidates[] = {sve_z27, fpu_v27, fpu_d27,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s28_invalidates[] = {sve_z28, fpu_v28, fpu_d28,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s29_invalidates[] = {sve_z29, fpu_v29, fpu_d29,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s30_invalidates[] = {sve_z30, fpu_v30, fpu_d30,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_s31_invalidates[] = {sve_z31, fpu_v31, fpu_d31,
+                                           LLDB_INVALID_REGNUM};
+
+static uint32_t g_sve_d0_invalidates[] = {sve_z0, fpu_v0, fpu_s0,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d1_invalidates[] = {sve_z1, fpu_v1, fpu_s1,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d2_invalidates[] = {sve_z2, fpu_v2, fpu_s2,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d3_invalidates[] = {sve_z3, fpu_v3, fpu_s3,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d4_invalidates[] = {sve_z4, fpu_v4, fpu_s4,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d5_invalidates[] = {sve_z5, fpu_v5, fpu_s5,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d6_invalidates[] = {sve_z6, fpu_v6, fpu_s6,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d7_invalidates[] = {sve_z7, fpu_v7, fpu_s7,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d8_invalidates[] = {sve_z8, fpu_v8, fpu_s8,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d9_invalidates[] = {sve_z9, fpu_v9, fpu_s9,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d10_invalidates[] = {sve_z10, fpu_v10, fpu_s10,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d11_invalidates[] = {sve_z11, fpu_v11, fpu_s11,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d12_invalidates[] = {sve_z12, fpu_v12, fpu_s12,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d13_invalidates[] = {sve_z13, fpu_v13, fpu_s13,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d14_invalidates[] = {sve_z14, fpu_v14, fpu_s14,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d15_invalidates[] = {sve_z15, fpu_v15, fpu_s15,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d16_invalidates[] = {sve_z16, fpu_v16, fpu_s16,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d17_invalidates[] = {sve_z17, fpu_v17, fpu_s17,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d18_invalidates[] = {sve_z18, fpu_v18, fpu_s18,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d19_invalidates[] = {sve_z19, fpu_v19, fpu_s19,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d20_invalidates[] = {sve_z20, fpu_v20, fpu_s20,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d21_invalidates[] = {sve_z21, fpu_v21, fpu_s21,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d22_invalidates[] = {sve_z22, fpu_v22, fpu_s22,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d23_invalidates[] = {sve_z23, fpu_v23, fpu_s23,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d24_invalidates[] = {sve_z24, fpu_v24, fpu_s24,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d25_invalidates[] = {sve_z25, fpu_v25, fpu_s25,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d26_invalidates[] = {sve_z26, fpu_v26, fpu_s26,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d27_invalidates[] = {sve_z27, fpu_v27, fpu_s27,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d28_invalidates[] = {sve_z28, fpu_v28, fpu_s28,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d29_invalidates[] = {sve_z29, fpu_v29, fpu_s29,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d30_invalidates[] = {sve_z30, fpu_v30, fpu_s30,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_d31_invalidates[] = {sve_z31, fpu_v31, fpu_s31,
+                                           LLDB_INVALID_REGNUM};
+
+static uint32_t g_sve_v0_invalidates[] = {sve_z0, fpu_d0, fpu_s0,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v1_invalidates[] = {sve_z1, fpu_d1, fpu_s1,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v2_invalidates[] = {sve_z2, fpu_d2, fpu_s2,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v3_invalidates[] = {sve_z3, fpu_d3, fpu_s3,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v4_invalidates[] = {sve_z4, fpu_d4, fpu_s4,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v5_invalidates[] = {sve_z5, fpu_d5, fpu_s5,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v6_invalidates[] = {sve_z6, fpu_d6, fpu_s6,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v7_invalidates[] = {sve_z7, fpu_d7, fpu_s7,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v8_invalidates[] = {sve_z8, fpu_d8, fpu_s8,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v9_invalidates[] = {sve_z9, fpu_d9, fpu_s9,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v10_invalidates[] = {sve_z10, fpu_d10, fpu_s10,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v11_invalidates[] = {sve_z11, fpu_d11, fpu_s11,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v12_invalidates[] = {sve_z12, fpu_d12, fpu_s12,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v13_invalidates[] = {sve_z13, fpu_d13, fpu_s13,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v14_invalidates[] = {sve_z14, fpu_d14, fpu_s14,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v15_invalidates[] = {sve_z15, fpu_d15, fpu_s15,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v16_invalidates[] = {sve_z16, fpu_d16, fpu_s16,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v17_invalidates[] = {sve_z17, fpu_d17, fpu_s17,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v18_invalidates[] = {sve_z18, fpu_d18, fpu_s18,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v19_invalidates[] = {sve_z19, fpu_d19, fpu_s19,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v20_invalidates[] = {sve_z20, fpu_d20, fpu_s20,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v21_invalidates[] = {sve_z21, fpu_d21, fpu_s21,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v22_invalidates[] = {sve_z22, fpu_d22, fpu_s22,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v23_invalidates[] = {sve_z23, fpu_d23, fpu_s23,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v24_invalidates[] = {sve_z24, fpu_d24, fpu_s24,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v25_invalidates[] = {sve_z25, fpu_d25, fpu_s25,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v26_invalidates[] = {sve_z26, fpu_d26, fpu_s26,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v27_invalidates[] = {sve_z27, fpu_d27, fpu_s27,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v28_invalidates[] = {sve_z28, fpu_d28, fpu_s28,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v29_invalidates[] = {sve_z29, fpu_d29, fpu_s29,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v30_invalidates[] = {sve_z30, fpu_d30, fpu_s30,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_v31_invalidates[] = {sve_z31, fpu_d31, fpu_s31,
+                                           LLDB_INVALID_REGNUM};
+
+static uint32_t g_sve_z0_invalidates[] = {fpu_v0, fpu_d0, fpu_s0,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z1_invalidates[] = {fpu_v1, fpu_d1, fpu_s1,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z2_invalidates[] = {fpu_v2, fpu_d2, fpu_s2,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z3_invalidates[] = {fpu_v3, fpu_d3, fpu_s3,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z4_invalidates[] = {fpu_v4, fpu_d4, fpu_s4,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z5_invalidates[] = {fpu_v5, fpu_d5, fpu_s5,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z6_invalidates[] = {fpu_v6, fpu_d6, fpu_s6,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z7_invalidates[] = {fpu_v7, fpu_d7, fpu_s7,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z8_invalidates[] = {fpu_v8, fpu_d8, fpu_s8,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z9_invalidates[] = {fpu_v9, fpu_d9, fpu_s9,
+                                          LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z10_invalidates[] = {fpu_v10, fpu_d10, fpu_s10,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z11_invalidates[] = {fpu_v11, fpu_d11, fpu_s11,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z12_invalidates[] = {fpu_v12, fpu_d12, fpu_s12,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z13_invalidates[] = {fpu_v13, fpu_d13, fpu_s13,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z14_invalidates[] = {fpu_v14, fpu_d14, fpu_s14,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z15_invalidates[] = {fpu_v15, fpu_d15, fpu_s15,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z16_invalidates[] = {fpu_v16, fpu_d16, fpu_s16,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z17_invalidates[] = {fpu_v17, fpu_d17, fpu_s17,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z18_invalidates[] = {fpu_v18, fpu_d18, fpu_s18,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z19_invalidates[] = {fpu_v19, fpu_d19, fpu_s19,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z20_invalidates[] = {fpu_v20, fpu_d20, fpu_s20,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z21_invalidates[] = {fpu_v21, fpu_d21, fpu_s21,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z22_invalidates[] = {fpu_v22, fpu_d22, fpu_s22,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z23_invalidates[] = {fpu_v23, fpu_d23, fpu_s23,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z24_invalidates[] = {fpu_v24, fpu_d24, fpu_s24,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z25_invalidates[] = {fpu_v25, fpu_d25, fpu_s25,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z26_invalidates[] = {fpu_v26, fpu_d26, fpu_s26,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z27_invalidates[] = {fpu_v27, fpu_d27, fpu_s27,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z28_invalidates[] = {fpu_v28, fpu_d28, fpu_s28,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z29_invalidates[] = {fpu_v29, fpu_d29, fpu_s29,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z30_invalidates[] = {fpu_v30, fpu_d30, fpu_s30,
+                                           LLDB_INVALID_REGNUM};
+static uint32_t g_sve_z31_invalidates[] = {fpu_v31, fpu_d31, fpu_s31,
+                                           LLDB_INVALID_REGNUM};
+
+static uint32_t g_contained_z0[] = {sve_z0, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z1[] = {sve_z1, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z2[] = {sve_z2, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z3[] = {sve_z3, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z4[] = {sve_z4, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z5[] = {sve_z5, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z6[] = {sve_z6, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z7[] = {sve_z7, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z8[] = {sve_z8, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z9[] = {sve_z9, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z10[] = {sve_z10, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z11[] = {sve_z11, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z12[] = {sve_z12, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z13[] = {sve_z13, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z14[] = {sve_z14, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z15[] = {sve_z15, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z16[] = {sve_z16, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z17[] = {sve_z17, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z18[] = {sve_z18, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z19[] = {sve_z19, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z20[] = {sve_z20, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z21[] = {sve_z21, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z22[] = {sve_z22, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z23[] = {sve_z23, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z24[] = {sve_z24, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z25[] = {sve_z25, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z26[] = {sve_z26, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z27[] = {sve_z27, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z28[] = {sve_z28, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z29[] = {sve_z29, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z30[] = {sve_z30, LLDB_INVALID_REGNUM};
+static uint32_t g_contained_z31[] = {sve_z31, LLDB_INVALID_REGNUM};
+
+#define VG_OFFSET_NAME(reg) SVE_OFFSET_VG
+
+#define SVE_REG_KIND(reg) MISC_KIND_GENERIC(reg, sve, LLDB_INVALID_REGNUM)
+#define MISC_VG_KIND(lldb_kind) MISC_KIND_GENERIC(vg, sve, LLDB_INVALID_REGNUM)
+
+// Default offset SVE Z registers and all corresponding pseudo registers
+// ( S, D and V registers) is zero and will be configured during execution.
+
+// Defines sve pseudo vector (V) register with 16-byte size
+#define DEFINE_VREG_SVE(vreg, zreg)                                            \
+  {                                                                            \
+    #vreg, nullptr, 16, 0, lldb::eEncodingVector, lldb::eFormatVectorOfUInt8,  \
+        VREG_KIND(vreg), g_contained_##zreg, g_sve_##vreg##_invalidates,       \
+        nullptr, 0                                                             \
+  }
+
+// Defines S and D pseudo registers mapping over corresponding vector register
+#define DEFINE_FPU_PSEUDO_SVE(reg, size, zreg)                                 \
+  {                                                                            \
+    #reg, nullptr, size, 0, lldb::eEncodingIEEE754, lldb::eFormatFloat,        \
+        MISC_KIND(fpu_##reg), g_contained_##zreg, g_sve_##reg##_invalidates,   \
+        nullptr, 0                                                             \
+  }
+
+// Defines a Z vector register with 16-byte default size
+#define DEFINE_ZREG(reg)                                                       \
+  {                                                                            \
+    #reg, nullptr, 16, 0, lldb::eEncodingVector, lldb::eFormatVectorOfUInt8,   \
+        SVE_REG_KIND(reg), nullptr, g_sve_##reg##_invalidates, nullptr, 0      \
+  }
+
+// Defines a P vector register with 2-byte default size
+#define DEFINE_PREG(reg)                                                       \
+  {                                                                            \
+    #reg, nullptr, 2, 0, lldb::eEncodingVector, lldb::eFormatVectorOfUInt8,    \
+        SVE_REG_KIND(reg), nullptr, nullptr, nullptr, 0                        \
+  }
+
+static lldb_private::RegisterInfo g_register_infos_arm64_sve_le[] = {
+    // DEFINE_GPR64(name, GENERIC KIND)
+    DEFINE_GPR64(x0, nullptr, LLDB_REGNUM_GENERIC_ARG1, g_x0_invalidates),
+    DEFINE_GPR64(x1, nullptr, LLDB_REGNUM_GENERIC_ARG2, g_x1_invalidates),
+    DEFINE_GPR64(x2, nullptr, LLDB_REGNUM_GENERIC_ARG3, g_x2_invalidates),
+    DEFINE_GPR64(x3, nullptr, LLDB_REGNUM_GENERIC_ARG4, g_x3_invalidates),
+    DEFINE_GPR64(x4, nullptr, LLDB_REGNUM_GENERIC_ARG5, g_x4_invalidates),
+    DEFINE_GPR64(x5, nullptr, LLDB_REGNUM_GENERIC_ARG6, g_x5_invalidates),
+    DEFINE_GPR64(x6, nullptr, LLDB_REGNUM_GENERIC_ARG7, g_x6_invalidates),
+    DEFINE_GPR64(x7, nullptr, LLDB_REGNUM_GENERIC_ARG8, g_x7_invalidates),
+    DEFINE_GPR64(x8, nullptr, LLDB_INVALID_REGNUM, g_x8_invalidates),
+    DEFINE_GPR64(x9, nullptr, LLDB_INVALID_REGNUM, g_x9_invalidates),
+    DEFINE_GPR64(x10, nullptr, LLDB_INVALID_REGNUM, g_x10_invalidates),
+    DEFINE_GPR64(x11, nullptr, LLDB_INVALID_REGNUM, g_x11_invalidates),
+    DEFINE_GPR64(x12, nullptr, LLDB_INVALID_REGNUM, g_x12_invalidates),
+    DEFINE_GPR64(x13, nullptr, LLDB_INVALID_REGNUM, g_x13_invalidates),
+    DEFINE_GPR64(x14, nullptr, LLDB_INVALID_REGNUM, g_x14_invalidates),
+    DEFINE_GPR64(x15, nullptr, LLDB_INVALID_REGNUM, g_x15_invalidates),
+    DEFINE_GPR64(x16, nullptr, LLDB_INVALID_REGNUM, g_x16_invalidates),
+    DEFINE_GPR64(x17, nullptr, LLDB_INVALID_REGNUM, g_x17_invalidates),
+    DEFINE_GPR64(x18, nullptr, LLDB_INVALID_REGNUM, g_x18_invalidates),
+    DEFINE_GPR64(x19, nullptr, LLDB_INVALID_REGNUM, g_x19_invalidates),
+    DEFINE_GPR64(x20, nullptr, LLDB_INVALID_REGNUM, g_x20_invalidates),
+    DEFINE_GPR64(x21, nullptr, LLDB_INVALID_REGNUM, g_x21_invalidates),
+    DEFINE_GPR64(x22, nullptr, LLDB_INVALID_REGNUM, g_x22_invalidates),
+    DEFINE_GPR64(x23, nullptr, LLDB_INVALID_REGNUM, g_x23_invalidates),
+    DEFINE_GPR64(x24, nullptr, LLDB_INVALID_REGNUM, g_x24_invalidates),
+    DEFINE_GPR64(x25, nullptr, LLDB_INVALID_REGNUM, g_x25_invalidates),
+    DEFINE_GPR64(x26, nullptr, LLDB_INVALID_REGNUM, g_x26_invalidates),
+    DEFINE_GPR64(x27, nullptr, LLDB_INVALID_REGNUM, g_x27_invalidates),
+    DEFINE_GPR64(x28, nullptr, LLDB_INVALID_REGNUM, g_x28_invalidates),
+    // DEFINE_GPR64(name, GENERIC KIND)
+    DEFINE_GPR64(fp, STRINGIZE(x29), LLDB_REGNUM_GENERIC_FP, nullptr),
+    DEFINE_GPR64(lr, STRINGIZE(x30), LLDB_REGNUM_GENERIC_RA, nullptr),
+    DEFINE_GPR64(sp, STRINGIZE(x31), LLDB_REGNUM_GENERIC_SP, nullptr),
+    DEFINE_GPR64(pc, nullptr, LLDB_REGNUM_GENERIC_PC, nullptr),
+
+    // DEFINE_MISC_REGS(name, size, TYPE, lldb kind)
+    DEFINE_MISC_REGS(cpsr, 4, CPSR, gpr_cpsr),
+
+    // DEFINE_GPR32(name, parent name)
+    DEFINE_GPR32(w0, x0),
+    DEFINE_GPR32(w1, x1),
+    DEFINE_GPR32(w2, x2),
+    DEFINE_GPR32(w3, x3),
+    DEFINE_GPR32(w4, x4),
+    DEFINE_GPR32(w5, x5),
+    DEFINE_GPR32(w6, x6),
+    DEFINE_GPR32(w7, x7),
+    DEFINE_GPR32(w8, x8),
+    DEFINE_GPR32(w9, x9),
+    DEFINE_GPR32(w10, x10),
+    DEFINE_GPR32(w11, x11),
+    DEFINE_GPR32(w12, x12),
+    DEFINE_GPR32(w13, x13),
+    DEFINE_GPR32(w14, x14),
+    DEFINE_GPR32(w15, x15),
+    DEFINE_GPR32(w16, x16),
+    DEFINE_GPR32(w17, x17),
+    DEFINE_GPR32(w18, x18),
+    DEFINE_GPR32(w19, x19),
+    DEFINE_GPR32(w20, x20),
+    DEFINE_GPR32(w21, x21),
+    DEFINE_GPR32(w22, x22),
+    DEFINE_GPR32(w23, x23),
+    DEFINE_GPR32(w24, x24),
+    DEFINE_GPR32(w25, x25),
+    DEFINE_GPR32(w26, x26),
+    DEFINE_GPR32(w27, x27),
+    DEFINE_GPR32(w28, x28),
+
+    // DEFINE_VREG_SVE(v register, z register)
+    DEFINE_VREG_SVE(v0, z0),
+    DEFINE_VREG_SVE(v1, z1),
+    DEFINE_VREG_SVE(v2, z2),
+    DEFINE_VREG_SVE(v3, z3),
+    DEFINE_VREG_SVE(v4, z4),
+    DEFINE_VREG_SVE(v5, z5),
+    DEFINE_VREG_SVE(v6, z6),
+    DEFINE_VREG_SVE(v7, z7),
+    DEFINE_VREG_SVE(v8, z8),
+    DEFINE_VREG_SVE(v9, z9),
+    DEFINE_VREG_SVE(v10, z10),
+    DEFINE_VREG_SVE(v11, z11),
+    DEFINE_VREG_SVE(v12, z12),
+    DEFINE_VREG_SVE(v13, z13),
+    DEFINE_VREG_SVE(v14, z14),
+    DEFINE_VREG_SVE(v15, z15),
+    DEFINE_VREG_SVE(v16, z16),
+    DEFINE_VREG_SVE(v17, z17),
+    DEFINE_VREG_SVE(v18, z18),
+    DEFINE_VREG_SVE(v19, z19),
+    DEFINE_VREG_SVE(v20, z20),
+    DEFINE_VREG_SVE(v21, z21),
+    DEFINE_VREG_SVE(v22, z22),
+    DEFINE_VREG_SVE(v23, z23),
+    DEFINE_VREG_SVE(v24, z24),
+    DEFINE_VREG_SVE(v25, z25),
+    DEFINE_VREG_SVE(v26, z26),
+    DEFINE_VREG_SVE(v27, z27),
+    DEFINE_VREG_SVE(v28, z28),
+    DEFINE_VREG_SVE(v29, z29),
+    DEFINE_VREG_SVE(v30, z30),
+    DEFINE_VREG_SVE(v31, z31),
+
+    // DEFINE_FPU_PSEUDO(name, size, ENDIAN OFFSET, parent register)
+    DEFINE_FPU_PSEUDO_SVE(s0, 4, z0),
+    DEFINE_FPU_PSEUDO_SVE(s1, 4, z1),
+    DEFINE_FPU_PSEUDO_SVE(s2, 4, z2),
+    DEFINE_FPU_PSEUDO_SVE(s3, 4, z3),
+    DEFINE_FPU_PSEUDO_SVE(s4, 4, z4),
+    DEFINE_FPU_PSEUDO_SVE(s5, 4, z5),
+    DEFINE_FPU_PSEUDO_SVE(s6, 4, z6),
+    DEFINE_FPU_PSEUDO_SVE(s7, 4, z7),
+    DEFINE_FPU_PSEUDO_SVE(s8, 4, z8),
+    DEFINE_FPU_PSEUDO_SVE(s9, 4, z9),
+    DEFINE_FPU_PSEUDO_SVE(s10, 4, z10),
+    DEFINE_FPU_PSEUDO_SVE(s11, 4, z11),
+    DEFINE_FPU_PSEUDO_SVE(s12, 4, z12),
+    DEFINE_FPU_PSEUDO_SVE(s13, 4, z13),
+    DEFINE_FPU_PSEUDO_SVE(s14, 4, z14),
+    DEFINE_FPU_PSEUDO_SVE(s15, 4, z15),
+    DEFINE_FPU_PSEUDO_SVE(s16, 4, z16),
+    DEFINE_FPU_PSEUDO_SVE(s17, 4, z17),
+    DEFINE_FPU_PSEUDO_SVE(s18, 4, z18),
+    DEFINE_FPU_PSEUDO_SVE(s19, 4, z19),
+    DEFINE_FPU_PSEUDO_SVE(s20, 4, z20),
+    DEFINE_FPU_PSEUDO_SVE(s21, 4, z21),
+    DEFINE_FPU_PSEUDO_SVE(s22, 4, z22),
+    DEFINE_FPU_PSEUDO_SVE(s23, 4, z23),
+    DEFINE_FPU_PSEUDO_SVE(s24, 4, z24),
+    DEFINE_FPU_PSEUDO_SVE(s25, 4, z25),
+    DEFINE_FPU_PSEUDO_SVE(s26, 4, z26),
+    DEFINE_FPU_PSEUDO_SVE(s27, 4, z27),
+    DEFINE_FPU_PSEUDO_SVE(s28, 4, z28),
+    DEFINE_FPU_PSEUDO_SVE(s29, 4, z29),
+    DEFINE_FPU_PSEUDO_SVE(s30, 4, z30),
+    DEFINE_FPU_PSEUDO_SVE(s31, 4, z31),
+
+    DEFINE_FPU_PSEUDO_SVE(d0, 8, z0),
+    DEFINE_FPU_PSEUDO_SVE(d1, 8, z1),
+    DEFINE_FPU_PSEUDO_SVE(d2, 8, z2),
+    DEFINE_FPU_PSEUDO_SVE(d3, 8, z3),
+    DEFINE_FPU_PSEUDO_SVE(d4, 8, z4),
+    DEFINE_FPU_PSEUDO_SVE(d5, 8, z5),
+    DEFINE_FPU_PSEUDO_SVE(d6, 8, z6),
+    DEFINE_FPU_PSEUDO_SVE(d7, 8, z7),
+    DEFINE_FPU_PSEUDO_SVE(d8, 8, z8),
+    DEFINE_FPU_PSEUDO_SVE(d9, 8, z9),
+    DEFINE_FPU_PSEUDO_SVE(d10, 8, z10),
+    DEFINE_FPU_PSEUDO_SVE(d11, 8, z11),
+    DEFINE_FPU_PSEUDO_SVE(d12, 8, z12),
+    DEFINE_FPU_PSEUDO_SVE(d13, 8, z13),
+    DEFINE_FPU_PSEUDO_SVE(d14, 8, z14),
+    DEFINE_FPU_PSEUDO_SVE(d15, 8, z15),
+    DEFINE_FPU_PSEUDO_SVE(d16, 8, z16),
+    DEFINE_FPU_PSEUDO_SVE(d17, 8, z17),
+    DEFINE_FPU_PSEUDO_SVE(d18, 8, z18),
+    DEFINE_FPU_PSEUDO_SVE(d19, 8, z19),
+    DEFINE_FPU_PSEUDO_SVE(d20, 8, z20),
+    DEFINE_FPU_PSEUDO_SVE(d21, 8, z21),
+    DEFINE_FPU_PSEUDO_SVE(d22, 8, z22),
+    DEFINE_FPU_PSEUDO_SVE(d23, 8, z23),
+    DEFINE_FPU_PSEUDO_SVE(d24, 8, z24),
+    DEFINE_FPU_PSEUDO_SVE(d25, 8, z25),
+    DEFINE_FPU_PSEUDO_SVE(d26, 8, z26),
+    DEFINE_FPU_PSEUDO_SVE(d27, 8, z27),
+    DEFINE_FPU_PSEUDO_SVE(d28, 8, z28),
+    DEFINE_FPU_PSEUDO_SVE(d29, 8, z29),
+    DEFINE_FPU_PSEUDO_SVE(d30, 8, z30),
+    DEFINE_FPU_PSEUDO_SVE(d31, 8, z31),
+
+    // DEFINE_MISC_REGS(name, size, TYPE, lldb kind)
+    DEFINE_MISC_REGS(fpsr, 4, FPU, fpu_fpsr),
+    DEFINE_MISC_REGS(fpcr, 4, FPU, fpu_fpcr),
+    DEFINE_MISC_REGS(far, 8, EXC, exc_far),
+    DEFINE_MISC_REGS(esr, 4, EXC, exc_esr),
+    DEFINE_MISC_REGS(exception, 4, EXC, exc_exception),
+
+    {DEFINE_DBG(bvr, 0)},
+    {DEFINE_DBG(bvr, 1)},
+    {DEFINE_DBG(bvr, 2)},
+    {DEFINE_DBG(bvr, 3)},
+    {DEFINE_DBG(bvr, 4)},
+    {DEFINE_DBG(bvr, 5)},
+    {DEFINE_DBG(bvr, 6)},
+    {DEFINE_DBG(bvr, 7)},
+    {DEFINE_DBG(bvr, 8)},
+    {DEFINE_DBG(bvr, 9)},
+    {DEFINE_DBG(bvr, 10)},
+    {DEFINE_DBG(bvr, 11)},
+    {DEFINE_DBG(bvr, 12)},
+    {DEFINE_DBG(bvr, 13)},
+    {DEFINE_DBG(bvr, 14)},
+    {DEFINE_DBG(bvr, 15)},
+
+    {DEFINE_DBG(bcr, 0)},
+    {DEFINE_DBG(bcr, 1)},
+    {DEFINE_DBG(bcr, 2)},
+    {DEFINE_DBG(bcr, 3)},
+    {DEFINE_DBG(bcr, 4)},
+    {DEFINE_DBG(bcr, 5)},
+    {DEFINE_DBG(bcr, 6)},
+    {DEFINE_DBG(bcr, 7)},
+    {DEFINE_DBG(bcr, 8)},
+    {DEFINE_DBG(bcr, 9)},
+    {DEFINE_DBG(bcr, 10)},
+    {DEFINE_DBG(bcr, 11)},
+    {DEFINE_DBG(bcr, 12)},
+    {DEFINE_DBG(bcr, 13)},
+    {DEFINE_DBG(bcr, 14)},
+    {DEFINE_DBG(bcr, 15)},
+
+    {DEFINE_DBG(wvr, 0)},
+    {DEFINE_DBG(wvr, 1)},
+    {DEFINE_DBG(wvr, 2)},
+    {DEFINE_DBG(wvr, 3)},
+    {DEFINE_DBG(wvr, 4)},
+    {DEFINE_DBG(wvr, 5)},
+    {DEFINE_DBG(wvr, 6)},
+    {DEFINE_DBG(wvr, 7)},
+    {DEFINE_DBG(wvr, 8)},
+    {DEFINE_DBG(wvr, 9)},
+    {DEFINE_DBG(wvr, 10)},
+    {DEFINE_DBG(wvr, 11)},
+    {DEFINE_DBG(wvr, 12)},
+    {DEFINE_DBG(wvr, 13)},
+    {DEFINE_DBG(wvr, 14)},
+    {DEFINE_DBG(wvr, 15)},
+
+    {DEFINE_DBG(wcr, 0)},
+    {DEFINE_DBG(wcr, 1)},
+    {DEFINE_DBG(wcr, 2)},
+    {DEFINE_DBG(wcr, 3)},
+    {DEFINE_DBG(wcr, 4)},
+    {DEFINE_DBG(wcr, 5)},
+    {DEFINE_DBG(wcr, 6)},
+    {DEFINE_DBG(wcr, 7)},
+    {DEFINE_DBG(wcr, 8)},
+    {DEFINE_DBG(wcr, 9)},
+    {DEFINE_DBG(wcr, 10)},
+    {DEFINE_DBG(wcr, 11)},
+    {DEFINE_DBG(wcr, 12)},
+    {DEFINE_DBG(wcr, 13)},
+    {DEFINE_DBG(wcr, 14)},
+    {DEFINE_DBG(wcr, 15)},
+
+    DEFINE_MISC_REGS(vg, 8, VG, sve_vg),
+    // DEFINE_ZREG(name)
+    DEFINE_ZREG(z0),
+    DEFINE_ZREG(z1),
+    DEFINE_ZREG(z2),
+    DEFINE_ZREG(z3),
+    DEFINE_ZREG(z4),
+    DEFINE_ZREG(z5),
+    DEFINE_ZREG(z6),
+    DEFINE_ZREG(z7),
+    DEFINE_ZREG(z8),
+    DEFINE_ZREG(z9),
+    DEFINE_ZREG(z10),
+    DEFINE_ZREG(z11),
+    DEFINE_ZREG(z12),
+    DEFINE_ZREG(z13),
+    DEFINE_ZREG(z14),
+    DEFINE_ZREG(z15),
+    DEFINE_ZREG(z16),
+    DEFINE_ZREG(z17),
+    DEFINE_ZREG(z18),
+    DEFINE_ZREG(z19),
+    DEFINE_ZREG(z20),
+    DEFINE_ZREG(z21),
+    DEFINE_ZREG(z22),
+    DEFINE_ZREG(z23),
+    DEFINE_ZREG(z24),
+    DEFINE_ZREG(z25),
+    DEFINE_ZREG(z26),
+    DEFINE_ZREG(z27),
+    DEFINE_ZREG(z28),
+    DEFINE_ZREG(z29),
+    DEFINE_ZREG(z30),
+    DEFINE_ZREG(z31),
+
+    // DEFINE_PREG(name)
+    DEFINE_PREG(p0),
+    DEFINE_PREG(p1),
+    DEFINE_PREG(p2),
+    DEFINE_PREG(p3),
+    DEFINE_PREG(p4),
+    DEFINE_PREG(p5),
+    DEFINE_PREG(p6),
+    DEFINE_PREG(p7),
+    DEFINE_PREG(p8),
+    DEFINE_PREG(p9),
+    DEFINE_PREG(p10),
+    DEFINE_PREG(p11),
+    DEFINE_PREG(p12),
+    DEFINE_PREG(p13),
+    DEFINE_PREG(p14),
+    DEFINE_PREG(p15),
+
+    // DEFINE FFR
+    DEFINE_PREG(ffr)};
+
+#endif // DECLARE_REGISTER_INFOS_ARM64_SVE_STRUCT

lldb/source/Plugins/Process/Utility/lldb-arm64-register-enums.h

enum {
   dbg_wcr9_arm64,
   dbg_wcr10_arm64,
   dbg_wcr11_arm64,
   dbg_wcr12_arm64,
   dbg_wcr13_arm64,
   dbg_wcr14_arm64,
   dbg_wcr15_arm64,
 
+  k_first_sve_arm64,
+  sve_vg_arm64 = k_first_sve_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,
+  k_last_sve_arm64 = sve_ffr_arm64,
+
   k_num_registers_arm64,
   k_num_gpr_registers_arm64 = k_last_gpr_arm64 - k_first_gpr_arm64 + 1,
-  k_num_fpr_registers_arm64 = k_last_fpr_arm64 - k_first_fpr_arm64 + 1
+  k_num_fpr_registers_arm64 = k_last_fpr_arm64 - k_first_fpr_arm64 + 1,
+  k_num_sve_registers_arm64 = k_last_sve_arm64 - k_first_sve_arm64 + 1
+
 };
 }
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_LLDB_ARM64_REGISTER_ENUMS_H

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.h

 //===-- RegisterContextPOSIXCore_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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_PROCESS_ELF_CORE_REGISTERCONTEXTPOSIXCORE_ARM64_H
 #define LLDB_SOURCE_PLUGINS_PROCESS_ELF_CORE_REGISTERCONTEXTPOSIXCORE_ARM64_H
 
 #include "Plugins/Process/Utility/RegisterContextPOSIX_arm64.h"
 #include "Plugins/Process/elf-core/RegisterUtilities.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 
+#ifndef SVE_PT_REGS_SVE
+#define INCLUDE_LINUX_PTRACE_DEFINITIONS_FOR_SVE_ARM64
+#include "Plugins/Process/Linux/LinuxPTraceDefines_arm64sve.h"
+#endif
+
+enum class SVE_STATE {
+  SVE_STATE_UNKNOWN,
+  SVE_STATE_DISABLED,
+  SVE_STATE_FPSIMD,
+  SVE_STATE_FULL
+};
+
 class RegisterContextCorePOSIX_arm64 : public RegisterContextPOSIX_arm64 {
 public:
   RegisterContextCorePOSIX_arm64(
       lldb_private::Thread &thread,
       lldb_private::RegisterInfoInterface *register_info,
       const lldb_private::DataExtractor &gpregset,
       llvm::ArrayRef<lldb_private::CoreNote> notes);
 
   ~RegisterContextCorePOSIX_arm64() override;
 
   bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
                     lldb_private::RegisterValue &value) override;
 
   bool WriteRegister(const lldb_private::RegisterInfo *reg_info,
                      const lldb_private::RegisterValue &value) override;
 
   bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
 
   bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
   bool HardwareSingleStep(bool enable) override;
 
+  void ConfigureRegisterContext();
+
+  uint32_t CalculateSVEOffset(uint32_t reg_num) const;
+
 protected:
   bool ReadGPR() override;
 
   bool ReadFPR() override;
 
   bool WriteGPR() override;
 
   bool WriteFPR() override;
 
+  uint64_t GetSVERegVG() { return m_sve_header.vl / 8; }
+
+  void *GetSVEBuffer();
+
 private:
   lldb::DataBufferSP m_gpr_buffer;
   lldb_private::DataExtractor m_gpr;
   lldb_private::DataExtractor m_fpregset;
+  lldb_private::DataExtractor m_sveregset;
+
+  mutable SVE_STATE m_sve_state;
+  struct user_sve_header m_sve_header;
+  std::vector<uint8_t> m_sve_note_payload;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_ELF_CORE_REGISTERCONTEXTPOSIXCORE_ARM64_H

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/RegisterValue.h"
 
 #include <memory>
 
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_arm64::RegisterContextCorePOSIX_arm64(
     Thread &thread, RegisterInfoInterface *register_info,
     const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_arm64(thread, 0, register_info) {
   m_gpr_buffer = std::make_shared<DataBufferHeap>(gpregset.GetDataStart(),
                                                   gpregset.GetByteSize());
   m_gpr.SetData(m_gpr_buffer);
   m_gpr.SetByteOrder(gpregset.GetByteOrder());
 
   m_fpregset = getRegset(
       notes, register_info->GetTargetArchitecture().GetTriple(), FPR_Desc);
+
+  m_sveregset =
+      getRegset(notes, register_info->GetTargetArchitecture().GetTriple(),
+                AARCH64_SVE_Desc);
+
+  ConfigureRegisterContext();
 }
 
 RegisterContextCorePOSIX_arm64::~RegisterContextCorePOSIX_arm64() {}
 
+void *RegisterContextCorePOSIX_arm64::GetSVEBuffer() {
+  if (m_sve_state == SVE_STATE::SVE_STATE_FPSIMD)
+    return m_sve_note_payload.data() + SVE_PT_FPSIMD_OFFSET;
+  return m_sve_note_payload.data();
+}
+
+void RegisterContextCorePOSIX_arm64::ConfigureRegisterContext() {
+  if (m_sveregset.GetByteSize() > sizeof(m_sve_header)) {
+    m_sve_note_payload.resize(m_sveregset.GetByteSize());
+    ::memcpy(GetSVEBuffer(), m_sveregset.GetDataStart(),
+             m_sveregset.GetByteSize());
+    ::memcpy(&m_sve_header, m_sveregset.GetDataStart(), sizeof(m_sve_header));
+
+    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);
+      m_register_info_up->SetRegisterInfoMode(vq);
+      m_sve_enabled = true;
+    } else
+      m_sve_state = SVE_STATE::SVE_STATE_DISABLED;
+  } else
+    m_sve_state = SVE_STATE::SVE_STATE_DISABLED;
+}
+
+uint32_t
+RegisterContextCorePOSIX_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;
+}
+
 bool RegisterContextCorePOSIX_arm64::ReadGPR() { return true; }
 
 bool RegisterContextCorePOSIX_arm64::ReadFPR() { return false; }
 
 bool RegisterContextCorePOSIX_arm64::WriteGPR() {
   assert(0);
   return false;
 }
 
 bool RegisterContextCorePOSIX_arm64::WriteFPR() {
   assert(0);
   return false;
 }
 
 bool RegisterContextCorePOSIX_arm64::ReadRegister(const RegisterInfo *reg_info,
                                                   RegisterValue &value) {
-  lldb::offset_t offset = reg_info->byte_offset;
+  Status error;
+  uint8_t *src;
+  lldb::offset_t offset;
+  uint64_t sve_vg;
+  std::vector<uint8_t> sve_reg_non_live;
+
+  offset = reg_info->byte_offset;
   if (offset < GetGPRSize() && offset < m_gpr.GetByteSize()) {
     uint64_t v = m_gpr.GetMaxU64(&offset, reg_info->byte_size);
     if (offset == reg_info->byte_offset + reg_info->byte_size) {
       value = v;
       return true;
     }
   }
 
   const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
   if (reg == LLDB_INVALID_REGNUM)
     return false;
 
+  if (IsFPR(reg)) {
+    if (m_sve_state == SVE_STATE::SVE_STATE_DISABLED) {
+      // SVE is disabled take legacy route for FPU register access
       offset -= GetGPRSize();
       if (IsFPR(reg) && offset < m_fpregset.GetByteSize()) {
-    Status error;
         value.SetFromMemoryData(reg_info, m_fpregset.GetDataStart() + offset,
-                            reg_info->byte_size, lldb::eByteOrderLittle, error);
+                                reg_info->byte_size, lldb::eByteOrderLittle,
+                                error);
         return error.Success();
       }
-
+    } else {
+      // 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 < m_sveregset.GetByteSize());
+        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 false;
+    else {
+      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 < m_sveregset.GetByteSize());
+          ::memcpy(sve_reg_non_live.data(),
+                   (const 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 < m_sveregset.GetByteSize());
+        src = (uint8_t *)GetSVEBuffer() + offset;
+      }
+    }
+  } else
     return false;
+
+  value.SetFromMemoryData(reg_info, src, reg_info->byte_size,
+                          lldb::eByteOrderLittle, error);
+
+  return error.Success();
 }
 
 bool RegisterContextCorePOSIX_arm64::ReadAllRegisterValues(
     lldb::DataBufferSP &data_sp) {
   return false;
 }
 
 bool RegisterContextCorePOSIX_arm64::WriteRegister(const RegisterInfo *reg_info,
                                                    const RegisterValue &value) {

lldb/source/Plugins/Process/elf-core/RegisterUtilities.h

constexpr RegsetDesc FPR_Desc[] = {
     // The result from FXSAVE is in NT_PRXFPREG for i386 core files
     {llvm::Triple::Linux, llvm::Triple::x86, llvm::ELF::NT_PRXFPREG},
     {llvm::Triple::Linux, llvm::Triple::UnknownArch, llvm::ELF::NT_FPREGSET},
     {llvm::Triple::NetBSD, llvm::Triple::aarch64, NETBSD::AARCH64::NT_FPREGS},
     {llvm::Triple::NetBSD, llvm::Triple::x86_64, NETBSD::AMD64::NT_FPREGS},
     {llvm::Triple::OpenBSD, llvm::Triple::UnknownArch, OPENBSD::NT_FPREGS},
 };
 
+constexpr RegsetDesc AARCH64_SVE_Desc[] = {
+    {llvm::Triple::Linux, llvm::Triple::aarch64, llvm::ELF::NT_ARM_SVE},
+};
+
 constexpr RegsetDesc PPC_VMX_Desc[] = {
     {llvm::Triple::FreeBSD, llvm::Triple::UnknownArch, llvm::ELF::NT_PPC_VMX},
     {llvm::Triple::Linux, llvm::Triple::UnknownArch, llvm::ELF::NT_PPC_VMX},
 };
 
 constexpr RegsetDesc PPC_VSX_Desc[] = {
     {llvm::Triple::Linux, llvm::Triple::UnknownArch, llvm::ELF::NT_PPC_VSX},
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_ELF_CORE_REGISTERUTILITIES_H

lldb/source/Utility/ARM64_DWARF_Registers.h

enum {
   x29 = 29,
   fp = x29,
   x30 = 30,
   lr = x30,
   x31 = 31,
   sp = x31,
   pc = 32,
   cpsr = 33,
-  // 34-63 reserved
+  // 34-45 reserved
+
+  // 64-bit SVE Vector granule pseudo register
+  vg = 46,
+
+  // VG ́8-bit SVE first fault register
+  ffr = 47,
+
+  // VG x ́8-bit SVE predicate registers
+  p0 = 48,
+  p1,
+  p2,
+  p3,
+  p4,
+  p5,
+  p6,
+  p7,
+  p8,
+  p9,
+  p10,
+  p11,
+  p12,
+  p13,
+  p14,
+  p15,
 
   // V0-V31 (128 bit vector registers)
   v0 = 64,
   v1,
   v2,
   v3,
   v4,
   v5,
   v6,
   v7,
   v8,
   v9,
   v10,
   v11,
   v12,
   v13,
   v14,
   v15,
   v16,
   v17,
   v18,
   v19,
   v20,
   v21,
   v22,
   v23,
   v24,
   v25,
   v26,
   v27,
   v28,
   v29,
   v30,
-  v31
+  v31,
 
-  // 96-127 reserved
+  // VG ́64-bit SVE vector registers
+  z0 = 96,
+  z1,
+  z2,
+  z3,
+  z4,
+  z5,
+  z6,
+  z7,
+  z8,
+  z9,
+  z10,
+  z11,
+  z12,
+  z13,
+  z14,
+  z15,
+  z16,
+  z17,
+  z18,
+  z19,
+  z20,
+  z21,
+  z22,
+  z23,
+  z24,
+  z25,
+  z26,
+  z27,
+  z28,
+  z29,
+  z30,
+  z31
 };
 
 } // namespace arm64_dwarf
 
 #endif // LLDB_SOURCE_UTILITY_ARM64_DWARF_REGISTERS_H

lldb/source/Utility/ARM64_ehframe_Registers.h

enum {
   x25,
   x26,
   x27,
   x28,
   fp, // aka x29
   lr, // aka x30
   sp, // aka x31 aka wzr
   pc, // value is 32
-  cpsr
-};
+  cpsr,
+  // 34-45 reserved
 
-enum {
+  // 64-bit SVE Vector granule pseudo register
+  vg = 46,
+
+  // VG ́8-bit SVE first fault register
+  ffr = 47,
+
+  // VG x ́8-bit SVE predicate registers
+  p0 = 48,
+  p1,
+  p2,
+  p3,
+  p4,
+  p5,
+  p6,
+  p7,
+  p8,
+  p9,
+  p10,
+  p11,
+  p12,
+  p13,
+  p14,
+  p15,
+
+  // V0-V31 (128 bit vector registers)
   v0 = 64,
   v1,
   v2,
   v3,
   v4,
   v5,
   v6,
   v7,
enum {
   v23,
   v24,
   v25,
   v26,
   v27,
   v28,
   v29,
   v30,
-  v31 // 95
+  v31,
+
+  // VG ́64-bit SVE vector registers
+  z0 = 96,
+  z1,
+  z2,
+  z3,
+  z4,
+  z5,
+  z6,
+  z7,
+  z8,
+  z9,
+  z10,
+  z11,
+  z12,
+  z13,
+  z14,
+  z15,
+  z16,
+  z17,
+  z18,
+  z19,
+  z20,
+  z21,
+  z22,
+  z23,
+  z24,
+  z25,
+  z26,
+  z27,
+  z28,
+  z29,
+  z30,
+  z31
 };
 }
 
 #endif // LLDB_SOURCE_UTILITY_ARM64_EHFRAME_REGISTERS_H

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 = 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])
 No newline at end of file

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

lldb/test/API/functionalities/postmortem/elf-core/TestLinuxCore.py

def test_aarch64_regs(self):
         values["fpsr"] = "0x00000000"
         values["fpcr"] = "0x00000000"
 
         for regname, value in values.items():
             self.expect("register read {}".format(regname), substrs=["{} = {}".format(regname, value)])
 
         self.expect("register read --all")
 
     @skipIf(triple='^mips')
+    @skipIfLLVMTargetMissing("AArch64")
+    def test_aarch64_sve_regs(self):
+        # check 64 bit ARM core files
+        target = self.dbg.CreateTarget(None)
+        self.assertTrue(target, VALID_TARGET)
+        process = target.LoadCore("linux-aarch64-sve.core")
+
+        values = {}
+        values["fp"] = "0x0000fffffc1ff4f0"
+        values["lr"] = "0x0000000000400170"
+        values["sp"] = "0x0000fffffc1ff4d0"
+        values["pc"] = "0x000000000040013c"
+        values["v0"] = "{0x00 0x00 0xf0 0x40 0x00 0x00 0xf0 0x40 0x00 0x00 0xf0 0x40 0x00 0x00 0xf0 0x40}"
+        values["v1"] = "{0x00 0x00 0x38 0x41 0x00 0x00 0x38 0x41 0x00 0x00 0x38 0x41 0x00 0x00 0x38 0x41}"
+        values["v2"] = "{0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00}"
+        values["v3"] = "{0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41}"
+        values["s0"] = "7.5"
+        values["s1"] = "11.5"
+        values["s2"] = "0"
+        values["s3"] = "15.5"
+        values["d0"] = "65536.0158538818"
+        values["d1"] = "1572864.25476074"
+        values["d2"] = "0"
+        values["d3"] = "25165828.0917969"
+        values["vg"] = "0x0000000000000004"
+        values["z0"] = "{0x00 0x00 0xf0 0x40 0x00 0x00 0xf0 0x40 0x00 0x00 0xf0 0x40 0x00 0x00 0xf0 0x40 0x00 0x00 0xf0 0x40 0x00 0x00 0xf0 0x40 0x00 0x00 0xf0 0x40 0x00 0x00 0xf0 0x40}"
+        values["z1"] = "{0x00 0x00 0x38 0x41 0x00 0x00 0x38 0x41 0x00 0x00 0x38 0x41 0x00 0x00 0x38 0x41 0x00 0x00 0x38 0x41 0x00 0x00 0x38 0x41 0x00 0x00 0x38 0x41 0x00 0x00 0x38 0x41}"
+        values["z2"] = "{0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00}"
+        values["z3"] = "{0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41 0x00 0x00 0x78 0x41}"
+        values["p0"] = "{0x11 0x11 0x11 0x11}"
+        values["p1"] = "{0x11 0x11 0x11 0x11}"
+        values["p2"] = "{0x00 0x00 0x00 0x00}"
+        values["p3"] = "{0x11 0x11 0x11 0x11}"
+        values["p4"] = "{0x00 0x00 0x00 0x00}"
+
+        for regname, value in values.items():
+            self.expect("register read {}".format(regname), substrs=["{} = {}".format(regname, value)])
+
+        self.expect("register read --all")
+
+    @skipIf(triple='^mips')
     @skipIfLLVMTargetMissing("ARM")
     def test_arm_core(self):
         # check 32 bit ARM core file
         target = self.dbg.CreateTarget(None)
         self.assertTrue(target, VALID_TARGET)
         process = target.LoadCore("linux-arm.core")
 
         values = {}

lldb/test/API/functionalities/postmortem/elf-core/linux-aarch64-sve.c

+// compile with -march=armv8-a+sve on compatible aarch64 compiler
+// linux-aarch64-sve.core was generated by: aarch64-linux-gnu-gcc-8
+// commandline: -march=armv8-a+sve -nostdlib -static -g linux-aarch64-sve.c
+static void bar(char *boom) {
+  char F = 'b';
+  asm volatile("ptrue p0.s\n\t");
+  asm volatile("fcpy  z0.s, p0/m, #7.5\n\t");
+  asm volatile("ptrue p1.s\n\t");
+  asm volatile("fcpy  z1.s, p1/m, #11.5\n\t");
+  asm volatile("ptrue p3.s\n\t");
+  asm volatile("fcpy  z3.s, p3/m, #15.5\n\t");
+
+  *boom = 47; // Frame bar
+}
+
+static void foo(char *boom, void (*boomer)(char *)) {
+  char F = 'f';
+  boomer(boom); // Frame foo
+}
+
+void _start(void) {
+  char F = '_';
+  foo(0, bar); // Frame _start
+}