1 //===-- RegisterContext.cpp -------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
12 // Other libraries and framework includes
14 #include "lldb/Target/RegisterContext.h"
15 #include "lldb/Core/DataExtractor.h"
16 #include "lldb/Core/Module.h"
17 #include "lldb/Core/RegisterValue.h"
18 #include "lldb/Core/Scalar.h"
19 #include "lldb/Core/Value.h"
20 #include "lldb/Expression/DWARFExpression.h"
21 #include "lldb/Host/Endian.h"
22 #include "lldb/Target/ExecutionContext.h"
23 #include "lldb/Target/Process.h"
24 #include "lldb/Target/StackFrame.h"
25 #include "lldb/Target/Target.h"
26 #include "lldb/Target/Thread.h"
29 using namespace lldb_private;
31 RegisterContext::RegisterContext(Thread &thread, uint32_t concrete_frame_idx)
32 : m_thread(thread), m_concrete_frame_idx(concrete_frame_idx),
33 m_stop_id(thread.GetProcess()->GetStopID()) {}
35 RegisterContext::~RegisterContext() = default;
37 void RegisterContext::InvalidateIfNeeded(bool force) {
38 ProcessSP process_sp(m_thread.GetProcess());
39 bool invalidate = force;
40 uint32_t process_stop_id = UINT32_MAX;
43 process_stop_id = process_sp->GetStopID();
48 invalidate = process_stop_id != GetStopID();
51 InvalidateAllRegisters();
52 SetStopID(process_stop_id);
57 RegisterContext::GetRegisterInfoByName(llvm::StringRef reg_name,
62 const uint32_t num_registers = GetRegisterCount();
63 for (uint32_t reg = start_idx; reg < num_registers; ++reg) {
64 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
66 if (reg_name.equals_lower(reg_info->name) ||
67 reg_name.equals_lower(reg_info->alt_name))
74 RegisterContext::UpdateDynamicRegisterSize(const lldb_private::ArchSpec &arch,
75 RegisterInfo *reg_info) {
76 ExecutionContext exe_ctx(CalculateThread());
78 // In MIPS, the floating point registers size is depends on FR bit of SR
80 // if SR.FR == 1 then all floating point registers are 64 bits.
81 // else they are all 32 bits.
84 uint32_t addr_size = arch.GetAddressByteSize();
85 const uint8_t *dwarf_opcode_ptr = reg_info->dynamic_size_dwarf_expr_bytes;
86 const size_t dwarf_opcode_len = reg_info->dynamic_size_dwarf_len;
88 DataExtractor dwarf_data(dwarf_opcode_ptr, dwarf_opcode_len,
89 arch.GetByteOrder(), addr_size);
91 DWARFExpression dwarf_expr(opcode_ctx, dwarf_data, nullptr, 0,
95 const lldb::offset_t offset = 0;
96 if (dwarf_expr.Evaluate(&exe_ctx, nullptr, nullptr, this, opcode_ctx,
97 dwarf_data, nullptr, offset, dwarf_opcode_len,
98 eRegisterKindDWARF, nullptr, nullptr, result,
100 expr_result = result.GetScalar().SInt(-1);
101 switch (expr_result) {
107 return reg_info->byte_size;
110 printf("Error executing DwarfExpression::Evaluate %s\n", error.AsCString());
111 return reg_info->byte_size;
115 const RegisterInfo *RegisterContext::GetRegisterInfo(lldb::RegisterKind kind,
117 const uint32_t reg_num = ConvertRegisterKindToRegisterNumber(kind, num);
118 if (reg_num == LLDB_INVALID_REGNUM)
120 return GetRegisterInfoAtIndex(reg_num);
123 const char *RegisterContext::GetRegisterName(uint32_t reg) {
124 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
126 return reg_info->name;
130 uint64_t RegisterContext::GetPC(uint64_t fail_value) {
131 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
132 LLDB_REGNUM_GENERIC_PC);
133 uint64_t pc = ReadRegisterAsUnsigned(reg, fail_value);
135 if (pc != fail_value) {
136 TargetSP target_sp = m_thread.CalculateTarget();
138 Target *target = target_sp.get();
140 pc = target->GetOpcodeLoadAddress(pc, eAddressClassCode);
147 bool RegisterContext::SetPC(uint64_t pc) {
148 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
149 LLDB_REGNUM_GENERIC_PC);
150 bool success = WriteRegisterFromUnsigned(reg, pc);
152 StackFrameSP frame_sp(
153 m_thread.GetFrameWithConcreteFrameIndex(m_concrete_frame_idx));
155 frame_sp->ChangePC(pc);
157 m_thread.ClearStackFrames();
162 bool RegisterContext::SetPC(Address addr) {
163 TargetSP target_sp = m_thread.CalculateTarget();
164 Target *target = target_sp.get();
166 lldb::addr_t callAddr = addr.GetCallableLoadAddress(target);
167 if (callAddr == LLDB_INVALID_ADDRESS)
170 return SetPC(callAddr);
173 uint64_t RegisterContext::GetSP(uint64_t fail_value) {
174 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
175 LLDB_REGNUM_GENERIC_SP);
176 return ReadRegisterAsUnsigned(reg, fail_value);
179 bool RegisterContext::SetSP(uint64_t sp) {
180 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
181 LLDB_REGNUM_GENERIC_SP);
182 return WriteRegisterFromUnsigned(reg, sp);
185 uint64_t RegisterContext::GetFP(uint64_t fail_value) {
186 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
187 LLDB_REGNUM_GENERIC_FP);
188 return ReadRegisterAsUnsigned(reg, fail_value);
191 bool RegisterContext::SetFP(uint64_t fp) {
192 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
193 LLDB_REGNUM_GENERIC_FP);
194 return WriteRegisterFromUnsigned(reg, fp);
197 uint64_t RegisterContext::GetReturnAddress(uint64_t fail_value) {
198 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
199 LLDB_REGNUM_GENERIC_RA);
200 return ReadRegisterAsUnsigned(reg, fail_value);
203 uint64_t RegisterContext::GetFlags(uint64_t fail_value) {
204 uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
205 LLDB_REGNUM_GENERIC_FLAGS);
206 return ReadRegisterAsUnsigned(reg, fail_value);
209 uint64_t RegisterContext::ReadRegisterAsUnsigned(uint32_t reg,
210 uint64_t fail_value) {
211 if (reg != LLDB_INVALID_REGNUM)
212 return ReadRegisterAsUnsigned(GetRegisterInfoAtIndex(reg), fail_value);
216 uint64_t RegisterContext::ReadRegisterAsUnsigned(const RegisterInfo *reg_info,
217 uint64_t fail_value) {
220 if (ReadRegister(reg_info, value))
221 return value.GetAsUInt64();
226 bool RegisterContext::WriteRegisterFromUnsigned(uint32_t reg, uint64_t uval) {
227 if (reg == LLDB_INVALID_REGNUM)
229 return WriteRegisterFromUnsigned(GetRegisterInfoAtIndex(reg), uval);
232 bool RegisterContext::WriteRegisterFromUnsigned(const RegisterInfo *reg_info,
236 if (value.SetUInt(uval, reg_info->byte_size))
237 return WriteRegister(reg_info, value);
242 bool RegisterContext::CopyFromRegisterContext(lldb::RegisterContextSP context) {
243 uint32_t num_register_sets = context->GetRegisterSetCount();
244 // We don't know that two threads have the same register context, so require
245 // the threads to be the same.
246 if (context->GetThreadID() != GetThreadID())
249 if (num_register_sets != GetRegisterSetCount())
252 RegisterContextSP frame_zero_context = m_thread.GetRegisterContext();
254 for (uint32_t set_idx = 0; set_idx < num_register_sets; ++set_idx) {
255 const RegisterSet *const reg_set = GetRegisterSet(set_idx);
257 const uint32_t num_registers = reg_set->num_registers;
258 for (uint32_t reg_idx = 0; reg_idx < num_registers; ++reg_idx) {
259 const uint32_t reg = reg_set->registers[reg_idx];
260 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
261 if (!reg_info || reg_info->value_regs)
263 RegisterValue reg_value;
265 // If we can reconstruct the register from the frame we are copying from,
266 // then do so, otherwise
267 // use the value from frame 0.
268 if (context->ReadRegister(reg_info, reg_value)) {
269 WriteRegister(reg_info, reg_value);
270 } else if (frame_zero_context->ReadRegister(reg_info, reg_value)) {
271 WriteRegister(reg_info, reg_value);
278 lldb::tid_t RegisterContext::GetThreadID() const { return m_thread.GetID(); }
280 uint32_t RegisterContext::NumSupportedHardwareBreakpoints() { return 0; }
282 uint32_t RegisterContext::SetHardwareBreakpoint(lldb::addr_t addr,
284 return LLDB_INVALID_INDEX32;
287 bool RegisterContext::ClearHardwareBreakpoint(uint32_t hw_idx) { return false; }
289 uint32_t RegisterContext::NumSupportedHardwareWatchpoints() { return 0; }
291 uint32_t RegisterContext::SetHardwareWatchpoint(lldb::addr_t addr, size_t size,
292 bool read, bool write) {
293 return LLDB_INVALID_INDEX32;
296 bool RegisterContext::ClearHardwareWatchpoint(uint32_t hw_index) {
300 bool RegisterContext::HardwareSingleStep(bool enable) { return false; }
302 Error RegisterContext::ReadRegisterValueFromMemory(const RegisterInfo *reg_info,
303 lldb::addr_t src_addr,
305 RegisterValue ®_value) {
307 if (reg_info == nullptr) {
308 error.SetErrorString("invalid register info argument.");
312 // Moving from addr into a register
314 // Case 1: src_len == dst_len
316 // |AABBCCDD| Address contents
317 // |AABBCCDD| Register contents
319 // Case 2: src_len > dst_len
321 // Error! (The register should always be big enough to hold the data)
323 // Case 3: src_len < dst_len
325 // |AABB| Address contents
326 // |AABB0000| Register contents [on little-endian hardware]
327 // |0000AABB| Register contents [on big-endian hardware]
328 if (src_len > RegisterValue::kMaxRegisterByteSize) {
329 error.SetErrorString("register too small to receive memory data");
333 const uint32_t dst_len = reg_info->byte_size;
335 if (src_len > dst_len) {
336 error.SetErrorStringWithFormat(
337 "%u bytes is too big to store in register %s (%u bytes)", src_len,
338 reg_info->name, dst_len);
342 ProcessSP process_sp(m_thread.GetProcess());
344 uint8_t src[RegisterValue::kMaxRegisterByteSize];
347 const uint32_t bytes_read =
348 process_sp->ReadMemory(src_addr, src, src_len, error);
350 // Make sure the memory read succeeded...
351 if (bytes_read != src_len) {
352 if (error.Success()) {
353 // This might happen if we read _some_ bytes but not all
354 error.SetErrorStringWithFormat("read %u of %u bytes", bytes_read,
360 // We now have a memory buffer that contains the part or all of the register
361 // value. Set the register value using this memory data.
362 // TODO: we might need to add a parameter to this function in case the byte
363 // order of the memory data doesn't match the process. For now we are
365 // they are the same.
366 reg_value.SetFromMemoryData(reg_info, src, src_len,
367 process_sp->GetByteOrder(), error);
369 error.SetErrorString("invalid process");
374 Error RegisterContext::WriteRegisterValueToMemory(
375 const RegisterInfo *reg_info, lldb::addr_t dst_addr, uint32_t dst_len,
376 const RegisterValue ®_value) {
377 uint8_t dst[RegisterValue::kMaxRegisterByteSize];
381 ProcessSP process_sp(m_thread.GetProcess());
384 // TODO: we might need to add a parameter to this function in case the byte
385 // order of the memory data doesn't match the process. For now we are
387 // they are the same.
389 const uint32_t bytes_copied = reg_value.GetAsMemoryData(
390 reg_info, dst, dst_len, process_sp->GetByteOrder(), error);
392 if (error.Success()) {
393 if (bytes_copied == 0) {
394 error.SetErrorString("byte copy failed.");
396 const uint32_t bytes_written =
397 process_sp->WriteMemory(dst_addr, dst, bytes_copied, error);
398 if (bytes_written != bytes_copied) {
399 if (error.Success()) {
400 // This might happen if we read _some_ bytes but not all
401 error.SetErrorStringWithFormat("only wrote %u of %u bytes",
402 bytes_written, bytes_copied);
408 error.SetErrorString("invalid process");
413 bool RegisterContext::ReadAllRegisterValues(
414 lldb_private::RegisterCheckpoint ®_checkpoint) {
415 return ReadAllRegisterValues(reg_checkpoint.GetData());
418 bool RegisterContext::WriteAllRegisterValues(
419 const lldb_private::RegisterCheckpoint ®_checkpoint) {
420 return WriteAllRegisterValues(reg_checkpoint.GetData());
423 TargetSP RegisterContext::CalculateTarget() {
424 return m_thread.CalculateTarget();
427 ProcessSP RegisterContext::CalculateProcess() {
428 return m_thread.CalculateProcess();
431 ThreadSP RegisterContext::CalculateThread() {
432 return m_thread.shared_from_this();
435 StackFrameSP RegisterContext::CalculateStackFrame() {
436 // Register contexts might belong to many frames if we have inlined
437 // functions inside a frame since all inlined functions share the
438 // same registers, so we can't definitively say which frame we come from...
439 return StackFrameSP();
442 void RegisterContext::CalculateExecutionContext(ExecutionContext &exe_ctx) {
443 m_thread.CalculateExecutionContext(exe_ctx);
446 bool RegisterContext::ConvertBetweenRegisterKinds(lldb::RegisterKind source_rk,
447 uint32_t source_regnum,
448 lldb::RegisterKind target_rk,
449 uint32_t &target_regnum) {
450 const uint32_t num_registers = GetRegisterCount();
451 for (uint32_t reg = 0; reg < num_registers; ++reg) {
452 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
454 if (reg_info->kinds[source_rk] == source_regnum) {
455 target_regnum = reg_info->kinds[target_rk];
456 return (target_regnum != LLDB_INVALID_REGNUM);
463 // RegisterContext::ReadRegisterValue (uint32_t reg, Scalar &value)
465 // DataExtractor data;
466 // if (!ReadRegisterBytes (reg, data))
469 // const RegisterInfo *reg_info = GetRegisterInfoAtIndex (reg);
470 // uint32_t offset = 0;
471 // switch (reg_info->encoding)
473 // case eEncodingInvalid:
474 // case eEncodingVector:
477 // case eEncodingUint:
478 // switch (reg_info->byte_size)
482 // value = data.GetU8 (&offset);
487 // value = data.GetU16 (&offset);
492 // value = data.GetU32 (&offset);
497 // value = data.GetU64 (&offset);
502 // case eEncodingSint:
503 // switch (reg_info->byte_size)
508 // if (data.ExtractBytes (0, sizeof (int8_t),
509 // endian::InlHostByteOrder(), &v) != sizeof (int8_t))
517 // if (data.ExtractBytes (0, sizeof (int16_t),
518 // endian::InlHostByteOrder(), &v) != sizeof (int16_t))
526 // if (data.ExtractBytes (0, sizeof (int32_t),
527 // endian::InlHostByteOrder(), &v) != sizeof (int32_t))
535 // if (data.ExtractBytes (0, sizeof (int64_t),
536 // endian::InlHostByteOrder(), &v) != sizeof (int64_t))
543 // case eEncodingIEEE754:
544 // switch (reg_info->byte_size)
546 // case sizeof (float):
549 // if (data.ExtractBytes (0, sizeof (float),
550 // endian::InlHostByteOrder(), &v) != sizeof (float))
555 // case sizeof (double):
558 // if (data.ExtractBytes (0, sizeof (double),
559 // endian::InlHostByteOrder(), &v) != sizeof (double))
564 // case sizeof (long double):
567 // if (data.ExtractBytes (0, sizeof (long double),
568 // endian::InlHostByteOrder(), &v) != sizeof (long double))
580 // RegisterContext::WriteRegisterValue (uint32_t reg, const Scalar &value)
582 // DataExtractor data;
583 // if (!value.IsValid())
585 // if (!value.GetData (data))
588 // return WriteRegisterBytes (reg, data);