35 bool write_all_at_once)
37 m_reg_info_sp(std::move(reg_info_sp)), m_reg_valid(), m_reg_data(),
38 m_read_all_at_once(read_all_at_once),
39 m_write_all_at_once(write_all_at_once), m_gpacket_cached(false) {
61 std::vector<bool>::iterator pos, end =
m_reg_valid.end();
93 std::vector<char> combined_data;
100 combined_data.resize(offset + parent_reg->
byte_size);
102 combined_data.data() + offset) !=
110 *reg_info, combined_data.
data(), combined_data.size(),
113 const bool partial_data_ok =
false;
116 return error.Success();
123 uint32_t reg, llvm::ArrayRef<uint8_t> data) {
125 if (reg_info ==
nullptr)
131 const size_t reg_byte_size = reg_info->
byte_size;
132 memcpy(
const_cast<uint8_t *
>(
134 data.data(), std::min(data.size(), reg_byte_size));
135 bool success = data.size() >= reg_byte_size;
138 }
else if (data.size() > 0) {
147 uint64_t new_reg_val) {
149 if (reg_info ==
nullptr)
172 uint8_t *dst =
const_cast<uint8_t *
>(
199 lldb_reg, llvm::ArrayRef<uint8_t>(buffer_sp->GetBytes(),
200 buffer_sp->GetByteSize()));
209 if (process ==
nullptr || thread ==
nullptr)
224 buffer_sp->GetBytes(),
229 }
else if (buffer_sp->GetByteSize() > 0) {
234 buffer_sp->GetByteSize());
244 "error: GDBRemoteRegisterContext::ReadRegisterBytes tried "
246 "entire register context at once, expected at least %" PRId64
248 "but only got %" PRId64
" bytes.",
260 for (uint32_t idx = 0; success; ++idx) {
261 const uint32_t prim_reg = reg_info->
value_regs[idx];
268 if (prim_reg_info ==
nullptr)
302 uint32_t combined_size = 0;
325 assert(offset == combined_size);
344 {m_reg_data.PeekData(reg_info->byte_offset, reg_info->byte_size),
345 reg_info->byte_size});
350 uint32_t data_offset) {
355 if (process ==
nullptr || thread ==
nullptr)
370 uint8_t *dst =
const_cast<uint8_t *
>(
381 bool do_reconfigure_arm64_sve = arch.
IsValid() &&
383 (strcmp(reg_info->
name,
"vg") == 0);
400 {m_reg_data.GetDataStart(), size_t(m_reg_data.GetByteSize())}))
403 if (do_reconfigure_arm64_sve)
421 for (uint32_t idx = 0; success; ++idx) {
422 const uint32_t reg = reg_info->
value_regs[idx];
429 if (value_reg_info ==
nullptr)
438 if (success && do_reconfigure_arm64_sve) {
464 "error: failed to get packet sequence mutex, not sending "
465 "write register for \"%s\":\n%s",
469 "error: failed to get packet sequence mutex, not sending "
470 "write register for \"%s\"",
484 if (process ==
nullptr || thread ==
nullptr)
490 uint32_t save_id = 0;
492 reg_checkpoint.
SetID(save_id);
493 reg_checkpoint.
GetData().reset();
496 reg_checkpoint.
SetID(0);
503 uint32_t save_id = reg_checkpoint.
GetID();
509 if (process ==
nullptr || thread ==
nullptr)
527 if (process ==
nullptr || thread ==
nullptr)
533 const bool use_g_packet =
544 data_sp = std::make_shared<DataBufferHeap>(*data_buffer);
562 data_sp = std::make_shared<DataBufferHeap>(
573 "error: failed to get packet sequence mutex, not sending "
574 "read all registers:\n%s",
578 "error: failed to get packet sequence mutex, not sending "
579 "read all registers");
589 if (!data_sp || data_sp->GetBytes() ==
nullptr || data_sp->GetByteSize() == 0)
596 if (process ==
nullptr || thread ==
nullptr)
602 const bool use_g_packet =
611 {data_sp->GetBytes(), size_t(data_sp->GetByteSize())}))
614 uint32_t num_restored = 0;
633 uint64_t size_including_slice_registers = 0;
634 uint64_t size_not_including_slice_registers = 0;
635 uint64_t size_by_highest_offset = 0;
637 for (uint32_t reg_idx = 0;
639 size_including_slice_registers += reg_info->
byte_size;
641 size_not_including_slice_registers += reg_info->
byte_size;
642 if (reg_info->
byte_offset >= size_by_highest_offset)
646 bool use_byte_offset_into_buffer;
647 if (size_by_highest_offset == restore_data.
GetByteSize()) {
650 use_byte_offset_into_buffer =
true;
651 }
else if (size_not_including_slice_registers ==
655 use_byte_offset_into_buffer =
true;
656 }
else if (size_including_slice_registers == restore_data.
GetByteSize()) {
660 use_byte_offset_into_buffer =
false;
665 use_byte_offset_into_buffer =
false;
670 uint32_t running_byte_offset = 0;
671 for (uint32_t reg_idx = 0;
673 ++reg_idx, running_byte_offset += reg_info->
byte_size) {
680 uint32_t register_offset;
681 if (use_byte_offset_into_buffer) {
684 register_offset = running_byte_offset;
687 const uint32_t reg_byte_size = reg_info->
byte_size;
689 const uint8_t *restore_src =
690 restore_data.
PeekData(register_offset, reg_byte_size);
696 {restore_src, reg_byte_size}))
700 return num_restored > 0;
706 bool arm64_debugserver =
false;
711 arch.
GetMachine() == llvm::Triple::aarch64_32) &&
712 arch.
GetTriple().getVendor() == llvm::Triple::Apple &&
713 arch.
GetTriple().getOS() == llvm::Triple::IOS) {
714 arm64_debugserver =
true;
717 uint32_t num_restored = 0;
727 if (arm64_debugserver && (strcmp(reg_info->
name,
"fpsr") == 0 ||
728 strcmp(reg_info->
name,
"fpcr") == 0)) {
735 {data_sp->GetBytes() + reg_info->byte_offset,
736 reg_info->byte_size}))
739 return num_restored > 0;
748 "error: failed to get packet sequence mutex, not sending "
749 "write all registers:\n%s",
753 "error: failed to get packet sequence mutex, not sending "
754 "write all registers");
762 return m_reg_info_sp->ConvertRegisterKindToRegisterNumber(kind, num);
772 std::optional<uint64_t> vg_reg_value;
779 if (reg_value != fail_value && reg_value <= 32)
780 vg_reg_value = reg_value;
783 std::optional<uint64_t> svg_reg_value;
788 if (reg_value != fail_value && reg_value <= 32)
789 svg_reg_value = reg_value;
799 if (vg_reg_value || svg_reg_value) {
812 uint32_t z_reg_byte_size = vg * 8;
817 for (
auto ® :
m_regs) {
818 if (reg.value_regs ==
nullptr) {
819 if (reg.name[0] ==
'z' && isdigit(reg.name[1]))
820 reg.byte_size = z_reg_byte_size;
821 else if (reg.name[0] ==
'p' && isdigit(reg.name[1]))
823 else if (strcmp(reg.name,
"ffr") == 0)
831 for (
auto ® :
m_regs) {
832 if (strcmp(reg.name,
"za") == 0) {
834 reg.byte_size = (svg * 8) * (svg * 8);
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOGF(log,...)
An architecture specification class.
bool IsValid() const
Tests if this ArchSpec is valid.
llvm::Triple & GetTriple()
Architecture triple accessor.
llvm::Triple::ArchType GetMachine() const
Returns a machine family for the current architecture.
A subclass of DataBuffer that stores a data buffer on the heap.
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
Process * GetProcessPtr() const
Returns a pointer to the process object.
Thread * GetThreadPtr() const
Returns a pointer to the thread object.
A plug-in interface definition class for debugging a process.
virtual void DumpPluginHistory(Stream &s)
The underlying plugin might store the low-level communication history for this session.
Target & GetTarget()
Get the target object pointer for this module.
lldb::WritableDataBufferSP & GetData()
void InvalidateIfNeeded(bool force)
uint64_t ReadRegisterAsUnsigned(uint32_t reg, uint64_t fail_value)
const RegisterInfo * GetRegisterInfo(lldb::RegisterKind reg_kind, uint32_t reg_num)
lldb::ThreadSP CalculateThread() override
virtual lldb::ByteOrder GetByteOrder()
uint32_t SetFromMemoryData(const RegisterInfo ®_info, const void *src, uint32_t src_len, lldb::ByteOrder src_byte_order, Status &error)
bool GetData(DataExtractor &data) const
Status SetValueFromData(const RegisterInfo ®_info, DataExtractor &data, lldb::offset_t offset, bool partial_data_ok)
const char * GetData() const
const ArchSpec & GetArchitecture() const
virtual lldb::user_id_t GetProtocolID() const
lldb::ProcessSP GetProcess() const
lldb::DataBufferSP ReadRegister(lldb::tid_t tid, uint32_t reg_num)
bool RestoreRegisterState(lldb::tid_t tid, uint32_t save_id)
bool AvoidGPackets(ProcessGDBRemote *process)
bool WriteAllRegisters(lldb::tid_t tid, llvm::ArrayRef< uint8_t > data)
bool WriteRegister(lldb::tid_t tid, uint32_t reg_num, llvm::ArrayRef< uint8_t > data)
bool SyncThreadState(lldb::tid_t tid)
lldb::DataBufferSP ReadAllRegisters(lldb::tid_t tid)
bool SaveRegisterState(lldb::tid_t tid, uint32_t &save_id)
void UpdateARM64SVERegistersInfos(uint64_t vg)
void UpdateARM64SMERegistersInfos(uint64_t svg)
const RegisterInfo * GetRegisterInfoAtIndex(size_t reg) override
const RegisterSet * GetRegisterSet(size_t reg_set) override
bool ReadRegisterBytes(const RegisterInfo *reg_info)
~GDBRemoteRegisterContext() override
std::vector< bool > m_reg_valid
void SetAllRegisterValid(bool b)
bool GetRegisterIsValid(uint32_t reg) const
GDBRemoteRegisterContext(ThreadGDBRemote &thread, uint32_t concrete_frame_idx, GDBRemoteDynamicRegisterInfoSP reg_info_sp, bool read_all_at_once, bool write_all_at_once)
GDBRemoteDynamicRegisterInfoSP m_reg_info_sp
bool WriteRegisterBytes(const RegisterInfo *reg_info, DataExtractor &data, uint32_t data_offset)
bool PrivateSetRegisterValue(uint32_t reg, llvm::ArrayRef< uint8_t > data)
bool ReadRegister(const RegisterInfo *reg_info, RegisterValue &value) override
size_t GetRegisterCount() override
void AArch64Reconfigure()
bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override
void InvalidateAllRegisters() override
bool WriteRegister(const RegisterInfo *reg_info, const RegisterValue &value) override
bool ReadAllRegisterValues(lldb::WritableDataBufferSP &data_sp) override
size_t GetRegisterSetCount() override
void SetRegisterIsValid(const RegisterInfo *reg_info, bool valid)
bool SetPrimordialRegister(const RegisterInfo *reg_info, GDBRemoteCommunicationClient &gdb_comm)
uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, uint32_t num) override
Convert from a given register numbering scheme to the lldb register numbering scheme.
bool GetPrimordialRegister(const RegisterInfo *reg_info, GDBRemoteCommunicationClient &gdb_comm)
#define LLDB_INVALID_INDEX32
#define LLDB_INVALID_ADDRESS
#define LLDB_INVALID_REGNUM
lldb::ByteOrder InlHostByteOrder()
std::shared_ptr< GDBRemoteDynamicRegisterInfo > GDBRemoteDynamicRegisterInfoSP
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
std::shared_ptr< lldb_private::DataBuffer > DataBufferSP
std::shared_ptr< lldb_private::WritableDataBuffer > WritableDataBufferSP
RegisterKind
Register numbering types.
@ eRegisterKindLLDB
lldb's internal register numbers
@ eRegisterKindProcessPlugin
num used by the process plugin - e.g.
Every register is described in detail including its name, alternate name (optional),...
uint32_t * value_regs
List of registers (terminated with LLDB_INVALID_REGNUM).
uint32_t byte_offset
The byte offset in the register context data where this register's value is found.
uint32_t byte_size
Size in bytes of the register.
uint32_t kinds[lldb::kNumRegisterKinds]
Holds all of the various register numbers for all register kinds.
llvm::ArrayRef< uint8_t > data(const uint8_t *context_base) const
const char * name
Name of this register, can't be NULL.
uint32_t * invalidate_regs
List of registers (terminated with LLDB_INVALID_REGNUM).
Registers are grouped into register sets.
lldb::user_id_t GetID() const
Get accessor for the user ID.
void SetID(lldb::user_id_t uid)
Set accessor for the user ID.