While implementing unwind information using UnwindAssemblyInstEmulation I ran
into some cleanup I have been wanting to do when reading/writing registers.
Previously all RegisterContext subclasses would need to implement:
virtual bool
ReadRegisterBytes (uint32_t reg, DataExtractor &data);
virtual bool
WriteRegisterBytes (uint32_t reg, DataExtractor &data, uint32_t data_offset = 0);
There is now a new class specifically designed to hold register values:
lldb_private::RegisterValue
The new register context calls that subclasses must implement are:
virtual bool
ReadRegister (const RegisterInfo *reg_info, RegisterValue ®_value) = 0;
virtual bool
WriteRegister (const RegisterInfo *reg_info, const RegisterValue ®_value) = 0;
The RegisterValue class must be big enough to handle any register value. The
class contains an enumeration for the value type, and then a union for the
data value. Any integer/float values are stored directly in an appropriate
host integer/float. Anything bigger is stored in a byte buffer that has a length
and byte order. The RegisterValue class also knows how to copy register value
bytes into in a buffer with a specified byte order which can be used to write
the register value down into memory, and this does the right thing when not
all bytes from the register values are needed (getting a uint8 from a uint32
register value..).
All RegiterContext and other sources have been switched over to using the new
regiter value class.
llvm-svn: 131096
diff --git a/lldb/source/Core/DataExtractor.cpp b/lldb/source/Core/DataExtractor.cpp
index 10a2029..9c07dc9 100644
--- a/lldb/source/Core/DataExtractor.cpp
+++ b/lldb/source/Core/DataExtractor.cpp
@@ -1035,6 +1035,116 @@
return bytes;
}
+// Extract data and swap if needed when doing the copy
+uint32_t
+DataExtractor::CopyByteOrderedData (uint32_t src_offset,
+ uint32_t src_len,
+ void *dst_void_ptr,
+ uint32_t dst_len,
+ ByteOrder dst_byte_order) const
+{
+ // Validate the source info
+ assert (ValidOffsetForDataOfSize(src_offset, src_len));
+ assert (src_len > 0);
+ assert (m_byte_order == eByteOrderBig || m_byte_order == eByteOrderLittle);
+
+ // Validate the destination info
+ assert (dst_void_ptr != NULL);
+ assert (dst_len > 0);
+ assert (dst_byte_order == eByteOrderBig || dst_byte_order == eByteOrderLittle);
+
+ // Must have valid byte orders set in this object and for destination
+ if (!(dst_byte_order == eByteOrderBig || dst_byte_order == eByteOrderLittle) ||
+ !(m_byte_order == eByteOrderBig || m_byte_order == eByteOrderLittle))
+ return 0;
+
+ uint32_t i;
+ uint8_t* dst = (uint8_t*)dst_void_ptr;
+ const uint8_t* src = (const uint8_t *)PeekData (src_offset, src_len);
+ if (src)
+ {
+ if (src_len >= dst_len)
+ {
+ // We are copying the entire value from src into dst.
+ // Calculate how many, if any, zeroes we need for the most
+ // significant bytes if "dst_len" is greater than "src_len"...
+ const uint32_t num_zeroes = dst_len - src_len;
+ if (dst_byte_order == eByteOrderBig)
+ {
+ // Big endian, so we lead with zeroes...
+ if (num_zeroes > 0)
+ ::memset (dst, 0, num_zeroes);
+ // Then either copy or swap the rest
+ if (m_byte_order == eByteOrderBig)
+ {
+ ::memcpy (dst + num_zeroes, src, src_len);
+ }
+ else
+ {
+ for (i=0; i<src_len; ++i)
+ dst[i+num_zeroes] = src[src_len - 1 - i];
+ }
+ }
+ else
+ {
+ // Little endian destination, so we lead the value bytes
+ if (m_byte_order == eByteOrderBig)
+ {
+ for (i=0; i<src_len; ++i)
+ dst[i] = src[src_len - 1 - i];
+ }
+ else
+ {
+ ::memcpy (dst, src, src_len);
+ }
+ // And zero the rest...
+ if (num_zeroes > 0)
+ ::memset (dst + src_len, 0, num_zeroes);
+ }
+ return src_len;
+ }
+ else
+ {
+ // We are only copying some of the value from src into dst..
+
+ if (dst_byte_order == eByteOrderBig)
+ {
+ // Big endian dst
+ if (m_byte_order == eByteOrderBig)
+ {
+ // Big endian dst, with big endian src
+ ::memcpy (dst, src + (src_len - dst_len), dst_len);
+ }
+ else
+ {
+ // Big endian dst, with little endian src
+ for (i=0; i<dst_len; ++i)
+ dst[i] = src[dst_len - 1 - i];
+ }
+ }
+ else
+ {
+ // Little endian dst
+ if (m_byte_order == eByteOrderBig)
+ {
+ // Little endian dst, with big endian src
+ for (i=0; i<dst_len; ++i)
+ dst[i] = src[src_len - 1 - i];
+ }
+ else
+ {
+ // Little endian dst, with big endian src
+ ::memcpy (dst, src, dst_len);
+ }
+ }
+ return dst_len;
+ }
+
+ }
+ return 0;
+}
+
+
//----------------------------------------------------------------------
// Extracts a AsCString (fixed length, or variable length) from
// the data at the offset pointed to by "offset_ptr". If
diff --git a/lldb/source/Core/Debugger.cpp b/lldb/source/Core/Debugger.cpp
index f328c62..7ae54bd 100644
--- a/lldb/source/Core/Debugger.cpp
+++ b/lldb/source/Core/Debugger.cpp
@@ -11,6 +11,7 @@
#include "lldb/Core/ConnectionFileDescriptor.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/InputReader.h"
+#include "lldb/Core/RegisterValue.h"
#include "lldb/Core/State.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Timer.h"
@@ -1088,10 +1089,11 @@
if (reg_info != NULL)
{
- DataExtractor reg_data;
- var_success = reg_ctx->ReadRegisterBytes (reg_info->kinds[eRegisterKindLLDB], reg_data);
+ RegisterValue reg_value;
+ var_success = reg_ctx->ReadRegister (reg_info, reg_value);
+ if (var_success)
{
- reg_data.Dump(&s, 0, reg_info->format, reg_info->byte_size, 1, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0);
+ reg_value.Dump(&s, reg_info, false);
}
}
diff --git a/lldb/source/Core/Disassembler.cpp b/lldb/source/Core/Disassembler.cpp
index 7c28a5b..995a82c 100644
--- a/lldb/source/Core/Disassembler.cpp
+++ b/lldb/source/Core/Disassembler.cpp
@@ -782,10 +782,10 @@
Instruction::Emulate (const ArchSpec &arch,
uint32_t evaluate_options,
void *baton,
- EmulateInstruction::ReadMemory read_mem_callback,
- EmulateInstruction::WriteMemory write_mem_callback,
- EmulateInstruction::ReadRegister read_reg_callback,
- EmulateInstruction::WriteRegister write_reg_callback)
+ EmulateInstruction::ReadMemoryCallback read_mem_callback,
+ EmulateInstruction::WriteMemoryCallback write_mem_callback,
+ EmulateInstruction::ReadRegisterCallback read_reg_callback,
+ EmulateInstruction::WriteRegisterCallback write_reg_callback)
{
std::auto_ptr<EmulateInstruction> insn_emulator_ap (EmulateInstruction::FindPlugin (arch, eInstructionTypeAny, NULL));
if (insn_emulator_ap.get())
diff --git a/lldb/source/Core/EmulateInstruction.cpp b/lldb/source/Core/EmulateInstruction.cpp
index 9ae9a1c..ac149e0 100644
--- a/lldb/source/Core/EmulateInstruction.cpp
+++ b/lldb/source/Core/EmulateInstruction.cpp
@@ -14,6 +14,8 @@
#include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/RegisterValue.h"
+#include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Host/Endian.h"
#include "lldb/Symbol/UnwindPlan.h"
@@ -64,42 +66,114 @@
}
-uint64_t
-EmulateInstruction::ReadRegisterUnsigned (uint32_t reg_kind, uint32_t reg_num, uint64_t fail_value, bool *success_ptr)
+bool
+EmulateInstruction::ReadRegister (const RegisterInfo *reg_info, RegisterValue& reg_value)
+{
+ if (m_read_reg_callback)
+ return m_read_reg_callback (this, m_baton, reg_info, reg_value);
+ return false;
+}
+
+bool
+EmulateInstruction::ReadRegister (uint32_t reg_kind, uint32_t reg_num, RegisterValue& reg_value)
{
RegisterInfo reg_info;
if (GetRegisterInfo(reg_kind, reg_num, reg_info))
- return ReadRegisterUnsigned (reg_info, fail_value, success_ptr);
+ return ReadRegister (®_info, reg_value);
+ return false;
+}
+
+uint64_t
+EmulateInstruction::ReadRegisterUnsigned (uint32_t reg_kind,
+ uint32_t reg_num,
+ uint64_t fail_value,
+ bool *success_ptr)
+{
+ RegisterValue reg_value;
+ if (ReadRegister (reg_kind, reg_num, reg_value))
+ return reg_value.GetAsUInt64(fail_value, success_ptr);
if (success_ptr)
*success_ptr = false;
return fail_value;
}
uint64_t
-EmulateInstruction::ReadRegisterUnsigned (const RegisterInfo ®_info, uint64_t fail_value, bool *success_ptr)
+EmulateInstruction::ReadRegisterUnsigned (const RegisterInfo *reg_info,
+ uint64_t fail_value,
+ bool *success_ptr)
{
- uint64_t uval64 = 0;
- bool success = m_read_reg_callback (this, m_baton, reg_info, uval64);
+ RegisterValue reg_value;
+ if (ReadRegister (reg_info, reg_value))
+ return reg_value.GetAsUInt64(fail_value, success_ptr);
if (success_ptr)
- *success_ptr = success;
- if (!success)
- uval64 = fail_value;
- return uval64;
+ *success_ptr = false;
+ return fail_value;
}
bool
-EmulateInstruction::WriteRegisterUnsigned (const Context &context, uint32_t reg_kind, uint32_t reg_num, uint64_t reg_value)
+EmulateInstruction::WriteRegister (const Context &context,
+ const RegisterInfo *reg_info,
+ const RegisterValue& reg_value)
{
- RegisterInfo reg_info;
- if (GetRegisterInfo(reg_kind, reg_num, reg_info))
- return WriteRegisterUnsigned (context, reg_info, reg_value);
+ if (m_write_reg_callback)
+ return m_write_reg_callback (this, m_baton, context, reg_info, reg_value);
return false;
}
bool
-EmulateInstruction::WriteRegisterUnsigned (const Context &context, const RegisterInfo ®_info, uint64_t reg_value)
+EmulateInstruction::WriteRegister (const Context &context,
+ uint32_t reg_kind,
+ uint32_t reg_num,
+ const RegisterValue& reg_value)
{
- return m_write_reg_callback (this, m_baton, context, reg_info, reg_value);
+ RegisterInfo reg_info;
+ if (GetRegisterInfo(reg_kind, reg_num, reg_info))
+ return WriteRegister (context, ®_info, reg_value);
+ return false;
+}
+
+
+bool
+EmulateInstruction::WriteRegisterUnsigned (const Context &context,
+ uint32_t reg_kind,
+ uint32_t reg_num,
+ uint64_t uint_value)
+{
+
+ RegisterInfo reg_info;
+ if (GetRegisterInfo(reg_kind, reg_num, reg_info))
+ {
+ RegisterValue reg_value;
+ if (reg_value.SetUInt(uint_value, reg_info.byte_size))
+ return WriteRegister (context, ®_info, reg_value);
+ }
+ return false;
+}
+
+bool
+EmulateInstruction::WriteRegisterUnsigned (const Context &context,
+ const RegisterInfo *reg_info,
+ uint64_t uint_value)
+{
+
+ if (reg_info)
+ {
+ RegisterValue reg_value;
+ if (reg_value.SetUInt(uint_value, reg_info->byte_size))
+ return WriteRegister (context, reg_info, reg_value);
+ }
+ return false;
+}
+
+size_t
+EmulateInstruction::ReadMemory (const Context &context,
+ lldb::addr_t addr,
+ void *dst,
+ size_t dst_len)
+{
+ if (m_read_mem_callback)
+ return m_read_mem_callback (this, m_baton, context, addr, dst, dst_len) == dst_len;
+ return false;
}
uint64_t
@@ -144,6 +218,17 @@
return false;
}
+bool
+EmulateInstruction::WriteMemory (const Context &context,
+ lldb::addr_t addr,
+ const void *src,
+ size_t src_len)
+{
+ if (m_write_mem_callback)
+ return m_write_mem_callback (this, m_baton, context, addr, src, src_len) == src_len;
+ return false;
+}
+
void
EmulateInstruction::SetBaton (void *baton)
@@ -152,10 +237,10 @@
}
void
-EmulateInstruction::SetCallbacks (ReadMemory read_mem_callback,
- WriteMemory write_mem_callback,
- ReadRegister read_reg_callback,
- WriteRegister write_reg_callback)
+EmulateInstruction::SetCallbacks (ReadMemoryCallback read_mem_callback,
+ WriteMemoryCallback write_mem_callback,
+ ReadRegisterCallback read_reg_callback,
+ WriteRegisterCallback write_reg_callback)
{
m_read_mem_callback = read_mem_callback;
m_write_mem_callback = write_mem_callback;
@@ -164,28 +249,28 @@
}
void
-EmulateInstruction::SetReadMemCallback (ReadMemory read_mem_callback)
+EmulateInstruction::SetReadMemCallback (ReadMemoryCallback read_mem_callback)
{
m_read_mem_callback = read_mem_callback;
}
void
-EmulateInstruction::SetWriteMemCallback (WriteMemory write_mem_callback)
+EmulateInstruction::SetWriteMemCallback (WriteMemoryCallback write_mem_callback)
{
m_write_mem_callback = write_mem_callback;
}
void
-EmulateInstruction::SetReadRegCallback (ReadRegister read_reg_callback)
+EmulateInstruction::SetReadRegCallback (ReadRegisterCallback read_reg_callback)
{
m_read_reg_callback = read_reg_callback;
}
void
-EmulateInstruction::SetWriteRegCallback (WriteRegister write_reg_callback)
+EmulateInstruction::SetWriteRegCallback (WriteRegisterCallback write_reg_callback)
{
m_write_reg_callback = write_reg_callback;
}
@@ -255,46 +340,28 @@
bool
EmulateInstruction::ReadRegisterFrame (EmulateInstruction *instruction,
void *baton,
- const RegisterInfo ®_info,
- uint64_t ®_value)
+ const RegisterInfo *reg_info,
+ RegisterValue ®_value)
{
if (!baton)
return false;
StackFrame *frame = (StackFrame *) baton;
- RegisterContext *reg_ctx = frame->GetRegisterContext().get();
- Scalar value;
-
- const uint32_t internal_reg_num = GetInternalRegisterNumber (reg_ctx, reg_info);
-
- if (internal_reg_num != LLDB_INVALID_REGNUM)
- {
- if (reg_ctx->ReadRegisterValue (internal_reg_num, value))
- {
- reg_value = value.GetRawBits64 (0);
- return true;
- }
- }
- return false;
+ return frame->GetRegisterContext()->ReadRegister (reg_info, reg_value);
}
bool
EmulateInstruction::WriteRegisterFrame (EmulateInstruction *instruction,
void *baton,
const Context &context,
- const RegisterInfo ®_info,
- uint64_t reg_value)
+ const RegisterInfo *reg_info,
+ const RegisterValue ®_value)
{
if (!baton)
return false;
StackFrame *frame = (StackFrame *) baton;
- RegisterContext *reg_ctx = frame->GetRegisterContext().get();
- Scalar value (reg_value);
- const uint32_t internal_reg_num = GetInternalRegisterNumber (reg_ctx, reg_info);
- if (internal_reg_num != LLDB_INVALID_REGNUM)
- return reg_ctx->WriteRegisterValue (internal_reg_num, value);
- return false;
+ return frame->GetRegisterContext()->WriteRegister (reg_info, reg_value);
}
size_t
@@ -327,15 +394,15 @@
bool
EmulateInstruction::ReadRegisterDefault (EmulateInstruction *instruction,
void *baton,
- const RegisterInfo ®_info,
- uint64_t ®_value)
+ const RegisterInfo *reg_info,
+ RegisterValue ®_value)
{
- fprintf (stdout, " Read Register (%s)\n", reg_info.name);
+ fprintf (stdout, " Read Register (%s)\n", reg_info->name);
uint32_t reg_kind, reg_num;
if (GetBestRegisterKindAndNumber (reg_info, reg_kind, reg_num))
- reg_value = (uint64_t)reg_kind << 24 | reg_num;
+ reg_value.SetUInt64((uint64_t)reg_kind << 24 | reg_num);
else
- reg_value = 0;
+ reg_value.SetUInt64(0);
return true;
}
@@ -344,10 +411,13 @@
EmulateInstruction::WriteRegisterDefault (EmulateInstruction *instruction,
void *baton,
const Context &context,
- const RegisterInfo ®_info,
- uint64_t reg_value)
+ const RegisterInfo *reg_info,
+ const RegisterValue ®_value)
{
- fprintf (stdout, " Write to Register (name = %s, value = 0x%llx, context = ", reg_info.name, reg_value);
+ StreamFile strm (stdout, false);
+ strm.Printf (" Write to Register (name = %s, value = " , reg_info->name);
+ reg_value.Dump(&strm, reg_info, false);
+ strm.PutCString (", context = ");
context.Dump (stdout, instruction);
return true;
}
@@ -548,41 +618,41 @@
}
bool
-EmulateInstruction::GetBestRegisterKindAndNumber (const RegisterInfo ®_info,
+EmulateInstruction::GetBestRegisterKindAndNumber (const RegisterInfo *reg_info,
uint32_t ®_kind,
uint32_t ®_num)
{
// Generic and DWARF should be the two most popular register kinds when
// emulating instructions since they are the most platform agnostic...
- reg_num = reg_info.kinds[eRegisterKindGeneric];
+ reg_num = reg_info->kinds[eRegisterKindGeneric];
if (reg_num != LLDB_INVALID_REGNUM)
{
reg_kind = eRegisterKindGeneric;
return true;
}
- reg_num = reg_info.kinds[eRegisterKindDWARF];
+ reg_num = reg_info->kinds[eRegisterKindDWARF];
if (reg_num != LLDB_INVALID_REGNUM)
{
reg_kind = eRegisterKindDWARF;
return true;
}
- reg_num = reg_info.kinds[eRegisterKindLLDB];
+ reg_num = reg_info->kinds[eRegisterKindLLDB];
if (reg_num != LLDB_INVALID_REGNUM)
{
reg_kind = eRegisterKindLLDB;
return true;
}
- reg_num = reg_info.kinds[eRegisterKindGCC];
+ reg_num = reg_info->kinds[eRegisterKindGCC];
if (reg_num != LLDB_INVALID_REGNUM)
{
reg_kind = eRegisterKindGCC;
return true;
}
- reg_num = reg_info.kinds[eRegisterKindGDB];
+ reg_num = reg_info->kinds[eRegisterKindGDB];
if (reg_num != LLDB_INVALID_REGNUM)
{
reg_kind = eRegisterKindGDB;
@@ -595,7 +665,7 @@
EmulateInstruction::GetInternalRegisterNumber (RegisterContext *reg_ctx, const RegisterInfo ®_info)
{
uint32_t reg_kind, reg_num;
- if (reg_ctx && GetBestRegisterKindAndNumber (reg_info, reg_kind, reg_num))
+ if (reg_ctx && GetBestRegisterKindAndNumber (®_info, reg_kind, reg_num))
return reg_ctx->ConvertRegisterKindToRegisterNumber (reg_kind, reg_num);
return LLDB_INVALID_REGNUM;
}
diff --git a/lldb/source/Core/RegisterValue.cpp b/lldb/source/Core/RegisterValue.cpp
new file mode 100644
index 0000000..bc66a8c
--- /dev/null
+++ b/lldb/source/Core/RegisterValue.cpp
@@ -0,0 +1,896 @@
+//===-- RegisterValue.cpp ----------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Core/RegisterValue.h"
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/Scalar.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Interpreter/Args.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+
+bool
+RegisterValue::Dump (Stream *s, const RegisterInfo *reg_info, bool prefix_with_name, Format format) const
+{
+ DataExtractor data;
+ if (GetData (data))
+ {
+ if (prefix_with_name && reg_info->name != NULL)
+ s->Printf ("%s = ", reg_info->name);
+ if (format == eFormatDefault)
+ format = reg_info->format;
+
+ data.Dump (s,
+ 0, // Offset in "data"
+ format, // Format to use when dumping
+ reg_info->byte_size, // item_byte_size
+ 1, // item_count
+ UINT32_MAX, // num_per_line
+ LLDB_INVALID_ADDRESS, // base_addr
+ 0, // item_bit_size
+ 0); // item_bit_offset
+ return true;
+ }
+ return false;
+}
+
+
+bool
+RegisterValue::GetData (DataExtractor &data) const
+{
+ return data.SetData(GetBytes(), GetByteSize(), GetByteOrder()) > 0;
+}
+
+
+uint32_t
+RegisterValue::GetAsMemoryData (const RegisterInfo *reg_info,
+ void *dst,
+ uint32_t dst_len,
+ lldb::ByteOrder dst_byte_order,
+ Error &error) const
+{
+ if (reg_info == NULL)
+ {
+ error.SetErrorString ("invalid register info argument.");
+ return 0;
+ }
+
+ // ReadRegister should have already been called on tgus object prior to
+ // calling this.
+ if (GetType() == eTypeInvalid)
+ {
+ // No value has been read into this object...
+ error.SetErrorStringWithFormat("invalid register value type for register %s", reg_info->name);
+ return 0;
+ }
+
+ if (dst_len > kMaxRegisterByteSize)
+ {
+ error.SetErrorString ("destination is too big");
+ return 0;
+ }
+
+ const uint32_t src_len = reg_info->byte_size;
+
+ // Extract the register data into a data extractor
+ DataExtractor reg_data;
+ if (!GetData(reg_data))
+ {
+ error.SetErrorString ("invalid register value to copy into");
+ return 0;
+ }
+
+ // Prepare a memory buffer that contains some or all of the register value
+ const uint32_t bytes_copied = reg_data.CopyByteOrderedData (0, // src offset
+ src_len, // src length
+ dst, // dst buffer
+ dst_len, // dst length
+ dst_byte_order); // dst byte order
+ if (bytes_copied == 0)
+ error.SetErrorStringWithFormat("failed to copy data for register write of %s", reg_info->name);
+
+ return bytes_copied;
+}
+
+uint32_t
+RegisterValue::SetFromMemoryData (const RegisterInfo *reg_info,
+ const void *src,
+ uint32_t src_len,
+ lldb::ByteOrder src_byte_order,
+ Error &error)
+{
+ if (reg_info == NULL)
+ {
+ error.SetErrorString ("invalid register info argument.");
+ return 0;
+ }
+
+ // Moving from addr into a register
+ //
+ // Case 1: src_len == dst_len
+ //
+ // |AABBCCDD| Address contents
+ // |AABBCCDD| Register contents
+ //
+ // Case 2: src_len > dst_len
+ //
+ // Error! (The register should always be big enough to hold the data)
+ //
+ // Case 3: src_len < dst_len
+ //
+ // |AABB| Address contents
+ // |AABB0000| Register contents [on little-endian hardware]
+ // |0000AABB| Register contents [on big-endian hardware]
+ if (src_len > kMaxRegisterByteSize)
+ {
+ error.SetErrorStringWithFormat ("register buffer is too small to receive %u bytes of data.", src_len);
+ return 0;
+ }
+
+ const uint32_t dst_len = reg_info->byte_size;
+
+ if (src_len > dst_len)
+ {
+ error.SetErrorStringWithFormat("%u bytes is too big to store in register %s (%u bytes)", src_len, reg_info->name, dst_len);
+ return 0;
+ }
+
+ // Use a data extractor to correctly copy and pad the bytes read into the
+ // register value
+ DataExtractor src_data (src, src_len, src_byte_order, 4);
+
+ // Given the register info, set the value type of this RegisterValue object
+ SetType (reg_info);
+ // And make sure we were able to figure out what that register value was
+ RegisterValue::Type value_type = GetType();
+ if (value_type == eTypeInvalid)
+ {
+ // No value has been read into this object...
+ error.SetErrorStringWithFormat("invalid register value type for register %s", reg_info->name);
+ return 0;
+ }
+ else if (value_type == eTypeBytes)
+ {
+ m_data.buffer.byte_order = src_byte_order;
+ }
+
+ const uint32_t bytes_copied = src_data.CopyByteOrderedData (0, // src offset
+ src_len, // src length
+ GetBytes(), // dst buffer
+ GetByteSize(), // dst length
+ GetByteOrder()); // dst byte order
+ if (bytes_copied == 0)
+ error.SetErrorStringWithFormat("failed to copy data for register write of %s", reg_info->name);
+
+ return bytes_copied;
+}
+
+bool
+RegisterValue::GetScalarValue (Scalar &scalar) const
+{
+ switch (m_type)
+ {
+ case eTypeInvalid: break;
+ case eTypeBytes: break;
+ case eTypeUInt8: scalar = m_data.uint8; return true;
+ case eTypeUInt16: scalar = m_data.uint16; return true;
+ case eTypeUInt32: scalar = m_data.uint32; return true;
+ case eTypeUInt64: scalar = m_data.uint64; return true;
+#if defined (ENABLE_128_BIT_SUPPORT)
+ case eTypeUInt128: break;
+#endif
+ case eTypeFloat: scalar = m_data.ieee_float; return true;
+ case eTypeDouble: scalar = m_data.ieee_double; return true;
+ case eTypeLongDouble: scalar = m_data.ieee_long_double; return true;
+ }
+ return false;
+}
+
+void
+RegisterValue::Clear()
+{
+ m_type = eTypeInvalid;
+}
+
+RegisterValue::Type
+RegisterValue::SetType (const RegisterInfo *reg_info)
+{
+ m_type = eTypeInvalid;
+ const uint32_t byte_size = reg_info->byte_size;
+ switch (reg_info->encoding)
+ {
+ case eEncodingInvalid:
+ break;
+
+ case eEncodingUint:
+ case eEncodingSint:
+ if (byte_size == 1)
+ m_type = eTypeUInt8;
+ else if (byte_size <= 2)
+ m_type = eTypeUInt16;
+ else if (byte_size <= 4)
+ m_type = eTypeUInt32;
+ else if (byte_size <= 8)
+ m_type = eTypeUInt64;
+#if defined (ENABLE_128_BIT_SUPPORT)
+ else if (byte_size <= 16)
+ m_type = eTypeUInt128;
+#endif
+ break;
+
+ case eEncodingIEEE754:
+ if (byte_size == sizeof(float))
+ m_type = eTypeFloat;
+ if (byte_size == sizeof(double))
+ m_type = eTypeDouble;
+ if (byte_size == sizeof(long double))
+ m_type = eTypeLongDouble;
+ break;
+
+ case eEncodingVector:
+ m_type = eTypeBytes;
+ break;
+ }
+ return m_type;
+}
+
+Error
+RegisterValue::SetValueFromData (const RegisterInfo *reg_info, DataExtractor &src, uint32_t src_offset, bool partial_data_ok)
+{
+ Error error;
+
+ if (src.GetByteSize() == 0)
+ {
+ error.SetErrorString ("empty data.");
+ return error;
+ }
+
+ if (reg_info->byte_size == 0)
+ {
+ error.SetErrorString ("invalid register info.");
+ return error;
+ }
+
+ uint32_t src_len = src.GetByteSize() - src_offset;
+
+ if (!partial_data_ok && (src_len < reg_info->byte_size))
+ {
+ error.SetErrorString ("not enough data.");
+ return error;
+ }
+
+ // Cap the data length if there is more than enough bytes for this register
+ // value
+ if (src_len > reg_info->byte_size)
+ src_len = reg_info->byte_size;
+
+ // Zero out the value in case we get partial data...
+ memset (m_data.buffer.bytes, 0, sizeof (m_data.buffer.bytes));
+
+ switch (SetType (reg_info))
+ {
+ case eTypeInvalid:
+ error.SetErrorString("");
+ break;
+ case eTypeUInt8: SetUInt8 (src.GetMaxU32 (&src_offset, src_len)); break;
+ case eTypeUInt16: SetUInt16 (src.GetMaxU32 (&src_offset, src_len)); break;
+ case eTypeUInt32: SetUInt32 (src.GetMaxU32 (&src_offset, src_len)); break;
+ case eTypeUInt64: SetUInt64 (src.GetMaxU64 (&src_offset, src_len)); break;
+#if defined (ENABLE_128_BIT_SUPPORT)
+ case eTypeUInt128:
+ {
+ __uint128_t data1 = src.GetU64 (&src_offset);
+ __uint128_t data2 = src.GetU64 (&src_offset);
+ if (src.GetByteSize() == eByteOrderBig)
+ SetUInt128 (data1 << 64 + data2);
+ else
+ SetUInt128 (data2 << 64 + data1);
+ }
+ break;
+#endif
+ case eTypeFloat: SetFloat (src.GetFloat (&src_offset)); break;
+ case eTypeDouble: SetDouble(src.GetDouble (&src_offset)); break;
+ case eTypeLongDouble: SetFloat (src.GetLongDouble (&src_offset)); break;
+ case eTypeBytes:
+ {
+ m_data.buffer.length = reg_info->byte_size;
+ m_data.buffer.byte_order = src.GetByteOrder();
+ assert (m_data.buffer.length <= kMaxRegisterByteSize);
+ if (m_data.buffer.length > kMaxRegisterByteSize)
+ m_data.buffer.length = kMaxRegisterByteSize;
+ if (src.CopyByteOrderedData (src_offset, // offset within "src" to start extracting data
+ src_len, // src length
+ m_data.buffer.bytes, // dst buffer
+ m_data.buffer.length, // dst length
+ m_data.buffer.byte_order) == 0)// dst byte order
+ {
+ error.SetErrorString ("data copy failed data.");
+ return error;
+ }
+ }
+ }
+
+ return error;
+}
+
+Error
+RegisterValue::SetValueFromCString (const RegisterInfo *reg_info, const char *value_str)
+{
+ Error error;
+ if (reg_info == NULL)
+ {
+ error.SetErrorString ("Invalid register info argument.");
+ return error;
+ }
+
+ if (value_str == NULL && value_str[0] == '\0')
+ {
+ error.SetErrorString ("Invalid c-string value string.");
+ return error;
+ }
+ bool success = false;
+ const uint32_t byte_size = reg_info->byte_size;
+ switch (reg_info->encoding)
+ {
+ default:
+ case eEncodingInvalid:
+ error.SetErrorString ("Invalid encoding.");
+ break;
+
+ case eEncodingUint:
+ if (byte_size <= sizeof (uint64_t))
+ {
+ uint64_t uval64 = Args::StringToUInt64(value_str, UINT64_MAX, 0, &success);
+ if (!success)
+ error.SetErrorStringWithFormat ("'%s' is not a valid unsigned integer string value.\n", value_str);
+ else if (!Args::UInt64ValueIsValidForByteSize (uval64, byte_size))
+ error.SetErrorStringWithFormat ("Value 0x%llx is too large to fit in a %u byte unsigned integer value.\n", uval64, byte_size);
+ else
+ {
+ if (!SetUInt (uval64, reg_info->byte_size))
+ error.SetErrorStringWithFormat ("Unsupported unsigned integer byte size: %u.\n", byte_size);
+ }
+ }
+ else
+ {
+ error.SetErrorStringWithFormat ("Unsupported unsigned integer byte size: %u.\n", byte_size);
+ return error;
+ }
+ break;
+
+ case eEncodingSint:
+ if (byte_size <= sizeof (long long))
+ {
+ uint64_t sval64 = Args::StringToSInt64(value_str, INT64_MAX, 0, &success);
+ if (!success)
+ error.SetErrorStringWithFormat ("'%s' is not a valid signed integer string value.\n", value_str);
+ else if (!Args::SInt64ValueIsValidForByteSize (sval64, byte_size))
+ error.SetErrorStringWithFormat ("Value 0x%llx is too large to fit in a %u byte signed integer value.\n", sval64, byte_size);
+ else
+ {
+ if (!SetUInt (sval64, reg_info->byte_size))
+ error.SetErrorStringWithFormat ("Unsupported signed integer byte size: %u.\n", byte_size);
+ }
+ }
+ else
+ {
+ error.SetErrorStringWithFormat ("Unsupported signed integer byte size: %u.\n", byte_size);
+ return error;
+ }
+ break;
+
+ case eEncodingIEEE754:
+ if (byte_size == sizeof (float))
+ {
+ if (::sscanf (value_str, "%f", &m_data.ieee_float) == 1)
+ m_type = eTypeFloat;
+ else
+ error.SetErrorStringWithFormat ("'%s' is not a valid float string value.\n", value_str);
+ }
+ else if (byte_size == sizeof (double))
+ {
+ if (::sscanf (value_str, "%lf", &m_data.ieee_double) == 1)
+ m_type = eTypeDouble;
+ else
+ error.SetErrorStringWithFormat ("'%s' is not a valid float string value.\n", value_str);
+ }
+ else if (byte_size == sizeof (long double))
+ {
+ if (::sscanf (value_str, "%Lf", &m_data.ieee_long_double) == 1)
+ m_type = eTypeLongDouble;
+ else
+ error.SetErrorStringWithFormat ("'%s' is not a valid float string value.\n", value_str);
+ }
+ else
+ {
+ error.SetErrorStringWithFormat ("Unsupported float byte size: %u.\n", byte_size);
+ return error;
+ }
+ break;
+
+ case eEncodingVector:
+ error.SetErrorString ("Vector encoding unsupported.");
+ break;
+ }
+ if (error.Fail())
+ m_type = eTypeInvalid;
+
+ return error;
+}
+
+
+bool
+RegisterValue::SignExtend (uint32_t sign_bitpos)
+{
+ switch (m_type)
+ {
+ case eTypeInvalid:
+ break;
+
+ case eTypeUInt8:
+ if (sign_bitpos == (8-1))
+ return true;
+ else if (sign_bitpos < (8-1))
+ {
+ uint8_t sign_bit = 1u << sign_bitpos;
+ if (m_data.uint8 & sign_bit)
+ {
+ const uint8_t mask = ~(sign_bit) + 1u;
+ m_data.uint8 |= mask;
+ }
+ return true;
+ }
+ break;
+
+ case eTypeUInt16:
+ if (sign_bitpos == (16-1))
+ return true;
+ else if (sign_bitpos < (16-1))
+ {
+ uint16_t sign_bit = 1u << sign_bitpos;
+ if (m_data.uint16 & sign_bit)
+ {
+ const uint16_t mask = ~(sign_bit) + 1u;
+ m_data.uint16 |= mask;
+ }
+ return true;
+ }
+ break;
+
+ case eTypeUInt32:
+ if (sign_bitpos == (32-1))
+ return true;
+ else if (sign_bitpos < (32-1))
+ {
+ uint32_t sign_bit = 1u << sign_bitpos;
+ if (m_data.uint32 & sign_bit)
+ {
+ const uint32_t mask = ~(sign_bit) + 1u;
+ m_data.uint32 |= mask;
+ }
+ return true;
+ }
+ break;
+
+ case eTypeUInt64:
+ if (sign_bitpos == (64-1))
+ return true;
+ else if (sign_bitpos < (64-1))
+ {
+ uint64_t sign_bit = 1ull << sign_bitpos;
+ if (m_data.uint64 & sign_bit)
+ {
+ const uint64_t mask = ~(sign_bit) + 1ull;
+ m_data.uint64 |= mask;
+ }
+ return true;
+ }
+ break;
+
+#if defined (ENABLE_128_BIT_SUPPORT)
+ case eTypeUInt128:
+ if (sign_bitpos == (128-1))
+ return true;
+ else if (sign_bitpos < (128-1))
+ {
+ __uint128_t sign_bit = (__uint128_t)1u << sign_bitpos;
+ if (m_data.uint128 & sign_bit)
+ {
+ const uint128_t mask = ~(sign_bit) + 1u;
+ m_data.uint128 |= mask;
+ }
+ return true;
+ }
+ break;
+#endif
+ case eTypeFloat:
+ case eTypeDouble:
+ case eTypeLongDouble:
+ case eTypeBytes:
+ break;
+ }
+ return false;
+}
+
+bool
+RegisterValue::CopyValue (const RegisterValue &rhs)
+{
+ m_type = rhs.m_type;
+ switch (m_type)
+ {
+ default:
+ case eTypeInvalid:
+ return false;
+ case eTypeUInt8: m_data.uint8 = rhs.m_data.uint8; break;
+ case eTypeUInt16: m_data.uint16 = rhs.m_data.uint16; break;
+ case eTypeUInt32: m_data.uint32 = rhs.m_data.uint32; break;
+ case eTypeUInt64: m_data.uint64 = rhs.m_data.uint64; break;
+#if defined (ENABLE_128_BIT_SUPPORT)
+ case eTypeUInt128: m_data.uint128 = rhs.m_data.uint128; break;
+#endif
+ case eTypeFloat: m_data.ieee_float = rhs.m_data.ieee_float; break;
+ case eTypeDouble: m_data.ieee_double = rhs.m_data.ieee_double; break;
+ case eTypeLongDouble: m_data.ieee_long_double = rhs.m_data.ieee_long_double; break;
+ case eTypeBytes:
+ assert (rhs.m_data.buffer.length <= kMaxRegisterByteSize);
+ ::memcpy (m_data.buffer.bytes, rhs.m_data.buffer.bytes, kMaxRegisterByteSize);
+ m_data.buffer.length = rhs.m_data.buffer.length;
+ m_data.buffer.byte_order = rhs.m_data.buffer.byte_order;
+ break;
+ }
+ return true;
+}
+
+uint16_t
+RegisterValue::GetAsUInt16 (uint16_t fail_value, bool *success_ptr) const
+{
+ if (success_ptr)
+ *success_ptr = true;
+
+ switch (m_type)
+ {
+ default: break;
+ case eTypeUInt8: return m_data.uint8;
+ case eTypeUInt16: return m_data.uint16;
+ }
+ if (success_ptr)
+ *success_ptr = false;
+ return fail_value;
+}
+
+uint32_t
+RegisterValue::GetAsUInt32 (uint32_t fail_value, bool *success_ptr) const
+{
+ if (success_ptr)
+ *success_ptr = true;
+ switch (m_type)
+ {
+ default: break;
+ case eTypeUInt8: return m_data.uint8;
+ case eTypeUInt16: return m_data.uint16;
+ case eTypeUInt32: return m_data.uint32;
+ case eTypeFloat:
+ if (sizeof(float) == sizeof(uint32_t))
+ return m_data.uint32;
+ break;
+ case eTypeDouble:
+ if (sizeof(double) == sizeof(uint32_t))
+ return m_data.uint32;
+ break;
+ case eTypeLongDouble:
+ if (sizeof(long double) == sizeof(uint32_t))
+ return m_data.uint32;
+ break;
+ }
+ if (success_ptr)
+ *success_ptr = false;
+ return fail_value;
+}
+
+uint64_t
+RegisterValue::GetAsUInt64 (uint64_t fail_value, bool *success_ptr) const
+{
+ if (success_ptr)
+ *success_ptr = true;
+ switch (m_type)
+ {
+ default: break;
+ case eTypeUInt8: return m_data.uint8;
+ case eTypeUInt16: return m_data.uint16;
+ case eTypeUInt32: return m_data.uint32;
+ case eTypeUInt64: return m_data.uint64;
+ case eTypeFloat:
+ if (sizeof(float) == sizeof(uint64_t))
+ return m_data.uint64;
+ break;
+ case eTypeDouble:
+ if (sizeof(double) == sizeof(uint64_t))
+ return m_data.uint64;
+ break;
+ case eTypeLongDouble:
+ if (sizeof(long double) == sizeof(uint64_t))
+ return m_data.uint64;
+ break;
+ }
+ if (success_ptr)
+ *success_ptr = false;
+ return fail_value;
+}
+
+#if defined (ENABLE_128_BIT_SUPPORT)
+__uint128_t
+RegisterValue::GetAsUInt128 (__uint128_t fail_value, bool *success_ptr) const
+{
+ if (success_ptr)
+ *success_ptr = true;
+ switch (m_type)
+ {
+ default: break;
+ case eTypeUInt8: return m_data.uint8;
+ case eTypeUInt16: return m_data.uint16;
+ case eTypeUInt32: return m_data.uint32;
+ case eTypeUInt64: return m_data.uint64;
+ case eTypeUInt128: return m_data.uint128;
+ case eTypeFloat:
+ if (sizeof(float) == sizeof(__uint128_t))
+ return m_data.uint128;
+ break;
+ case eTypeDouble:
+ if (sizeof(double) == sizeof(__uint128_t))
+ return m_data.uint128;
+ break;
+ case eTypeLongDouble:
+ if (sizeof(long double) == sizeof(__uint128_t))
+ return m_data.uint128;
+ break;
+ }
+ if (success_ptr)
+ *success_ptr = false;
+ return fail_value;
+}
+#endif
+float
+RegisterValue::GetAsFloat (float fail_value, bool *success_ptr) const
+{
+ if (success_ptr)
+ *success_ptr = true;
+ switch (m_type)
+ {
+ default: break;
+ case eTypeUInt32:
+ if (sizeof(float) == sizeof(m_data.uint32))
+ return m_data.ieee_float;
+ break;
+ case eTypeUInt64:
+ if (sizeof(float) == sizeof(m_data.uint64))
+ return m_data.ieee_float;
+ break;
+#if defined (ENABLE_128_BIT_SUPPORT)
+ case eTypeUInt128:
+ if (sizeof(float) == sizeof(m_data.uint128))
+ return m_data.ieee_float;
+ break;
+#endif
+ case eTypeFloat: return m_data.ieee_float;
+ case eTypeDouble:
+ if (sizeof(float) == sizeof(double))
+ return m_data.ieee_float;
+ break;
+ case eTypeLongDouble:
+ if (sizeof(float) == sizeof(long double))
+ return m_data.ieee_float;
+ break;
+ }
+ if (success_ptr)
+ *success_ptr = false;
+ return fail_value;
+}
+
+double
+RegisterValue::GetAsDouble (double fail_value, bool *success_ptr) const
+{
+ if (success_ptr)
+ *success_ptr = true;
+ switch (m_type)
+ {
+ default:
+ break;
+
+ case eTypeUInt32:
+ if (sizeof(double) == sizeof(m_data.uint32))
+ return m_data.ieee_double;
+ break;
+
+ case eTypeUInt64:
+ if (sizeof(double) == sizeof(m_data.uint64))
+ return m_data.ieee_double;
+ break;
+
+#if defined (ENABLE_128_BIT_SUPPORT)
+ case eTypeUInt128:
+ if (sizeof(double) == sizeof(m_data.uint128))
+ return m_data.ieee_double;
+#endif
+ case eTypeFloat: return m_data.ieee_float;
+ case eTypeDouble: return m_data.ieee_double;
+
+ case eTypeLongDouble:
+ if (sizeof(double) == sizeof(long double))
+ return m_data.ieee_double;
+ break;
+ }
+ if (success_ptr)
+ *success_ptr = false;
+ return fail_value;
+}
+
+long double
+RegisterValue::GetAsLongDouble (long double fail_value, bool *success_ptr) const
+{
+ if (success_ptr)
+ *success_ptr = true;
+ switch (m_type)
+ {
+ default:
+ break;
+
+ case eTypeUInt32:
+ if (sizeof(long double) == sizeof(m_data.uint32))
+ return m_data.ieee_long_double;
+ break;
+
+ case eTypeUInt64:
+ if (sizeof(long double) == sizeof(m_data.uint64))
+ return m_data.ieee_long_double;
+ break;
+
+#if defined (ENABLE_128_BIT_SUPPORT)
+ case eTypeUInt128:
+ if (sizeof(long double) == sizeof(m_data.uint128))
+ return m_data.ieee_long_double;
+#endif
+ case eTypeFloat: return m_data.ieee_float;
+ case eTypeDouble: return m_data.ieee_double;
+ case eTypeLongDouble: return m_data.ieee_long_double;
+ break;
+ }
+ if (success_ptr)
+ *success_ptr = false;
+ return fail_value;
+}
+
+const void *
+RegisterValue::GetBytes () const
+{
+ switch (m_type)
+ {
+ case eTypeInvalid: break;
+ case eTypeUInt8: return &m_data.uint8;
+ case eTypeUInt16: return &m_data.uint16;
+ case eTypeUInt32: return &m_data.uint32;
+ case eTypeUInt64: return &m_data.uint64;
+#if defined (ENABLE_128_BIT_SUPPORT)
+ case eTypeUInt128: return &m_data.uint128;
+#endif
+ case eTypeFloat: return &m_data.ieee_float;
+ case eTypeDouble: return &m_data.ieee_double;
+ case eTypeLongDouble: return &m_data.ieee_long_double;
+ case eTypeBytes: return m_data.buffer.bytes;
+ }
+ return NULL;
+}
+
+void *
+RegisterValue::GetBytes ()
+{
+ switch (m_type)
+ {
+ case eTypeInvalid: break;
+ case eTypeUInt8: return &m_data.uint8;
+ case eTypeUInt16: return &m_data.uint16;
+ case eTypeUInt32: return &m_data.uint32;
+ case eTypeUInt64: return &m_data.uint64;
+#if defined (ENABLE_128_BIT_SUPPORT)
+ case eTypeUInt128: return &m_data.uint128;
+#endif
+ case eTypeFloat: return &m_data.ieee_float;
+ case eTypeDouble: return &m_data.ieee_double;
+ case eTypeLongDouble: return &m_data.ieee_long_double;
+ case eTypeBytes: return m_data.buffer.bytes;
+ }
+ return NULL;
+}
+
+uint32_t
+RegisterValue::GetByteSize () const
+{
+ switch (m_type)
+ {
+ case eTypeInvalid: break;
+ case eTypeUInt8: return sizeof(m_data.uint8);
+ case eTypeUInt16: return sizeof(m_data.uint16);
+ case eTypeUInt32: return sizeof(m_data.uint32);
+ case eTypeUInt64: return sizeof(m_data.uint64);
+#if defined (ENABLE_128_BIT_SUPPORT)
+ case eTypeUInt128: return sizeof(m_data.uint128);
+#endif
+ case eTypeFloat: return sizeof(m_data.ieee_float);
+ case eTypeDouble: return sizeof(m_data.ieee_double);
+ case eTypeLongDouble: return sizeof(m_data.ieee_long_double);
+ case eTypeBytes: return m_data.buffer.length;
+ }
+ return 0;
+}
+
+
+bool
+RegisterValue::SetUInt (uint64_t uint, uint32_t byte_size)
+{
+ if (byte_size == 0)
+ {
+ SetUInt64 (uint);
+ }
+ else if (byte_size == 1)
+ {
+ SetUInt8 (uint);
+ }
+ else if (byte_size <= 2)
+ {
+ SetUInt16 (uint);
+ }
+ else if (byte_size <= 4)
+ {
+ SetUInt32 (uint);
+ }
+ else if (byte_size <= 8)
+ {
+ SetUInt64 (uint);
+ }
+#if defined (ENABLE_128_BIT_SUPPORT)
+ else if (byte_size <= 16)
+ {
+ SetUInt128 (uint);
+ }
+#endif
+ else
+ return false;
+ return true;
+}
+
+void
+RegisterValue::SetBytes (const void *bytes, size_t length, lldb::ByteOrder byte_order)
+{
+ // If this assertion fires off we need to increase the size of
+ // m_data.buffer.bytes, or make it something that is allocated on
+ // the heap. Since the data buffer is in a union, we can't make it
+ // a collection class like SmallVector...
+ assert (length <= sizeof (m_data.buffer.bytes));
+ if (bytes && length > 0)
+ {
+ m_type = eTypeBytes;
+ m_data.buffer.length = length;
+ assert (length < sizeof (m_data.buffer.bytes));
+ memcpy (m_data.buffer.bytes, bytes, length);
+ m_data.buffer.byte_order = byte_order;
+ }
+ else
+ {
+ m_type = eTypeInvalid;
+ m_data.buffer.length = 0;
+ }
+}
+
diff --git a/lldb/source/Core/ValueObjectRegister.cpp b/lldb/source/Core/ValueObjectRegister.cpp
index df80ce3..bcefc30 100644
--- a/lldb/source/Core/ValueObjectRegister.cpp
+++ b/lldb/source/Core/ValueObjectRegister.cpp
@@ -252,28 +252,29 @@
#pragma mark ValueObjectRegister
void
-ValueObjectRegister::ConstructObject ()
+ValueObjectRegister::ConstructObject (uint32_t reg_num)
{
- m_reg_info = m_reg_ctx_sp->GetRegisterInfoAtIndex(m_reg_num);
- if (m_reg_info)
+ const RegisterInfo *reg_info = m_reg_ctx_sp->GetRegisterInfoAtIndex (reg_num);
+ if (reg_info)
{
- if (m_reg_info->name)
- m_name.SetCString(m_reg_info->name);
- else if (m_reg_info->alt_name)
- m_name.SetCString(m_reg_info->alt_name);
+ m_reg_info = *reg_info;
+ if (reg_info->name)
+ m_name.SetCString(reg_info->name);
+ else if (reg_info->alt_name)
+ m_name.SetCString(reg_info->alt_name);
}
}
-ValueObjectRegister::ValueObjectRegister (ValueObject &parent, lldb::RegisterContextSP ®_ctx, uint32_t reg_num) :
+ValueObjectRegister::ValueObjectRegister (ValueObject &parent, lldb::RegisterContextSP ®_ctx_sp, uint32_t reg_num) :
ValueObject (parent),
- m_reg_ctx_sp (reg_ctx),
- m_reg_info (NULL),
- m_reg_num (reg_num),
+ m_reg_ctx_sp (reg_ctx_sp),
+ m_reg_info (),
+ m_reg_value (),
m_type_name (),
m_clang_type (NULL)
{
- assert (reg_ctx);
- ConstructObject();
+ assert (reg_ctx_sp.get());
+ ConstructObject(reg_num);
}
ValueObjectSP
@@ -285,13 +286,13 @@
ValueObjectRegister::ValueObjectRegister (ExecutionContextScope *exe_scope, lldb::RegisterContextSP ®_ctx, uint32_t reg_num) :
ValueObject (exe_scope),
m_reg_ctx_sp (reg_ctx),
- m_reg_info (NULL),
- m_reg_num (reg_num),
+ m_reg_info (),
+ m_reg_value (),
m_type_name (),
m_clang_type (NULL)
{
assert (reg_ctx);
- ConstructObject();
+ ConstructObject(reg_num);
}
ValueObjectRegister::~ValueObjectRegister()
@@ -301,7 +302,7 @@
lldb::clang_type_t
ValueObjectRegister::GetClangType ()
{
- if (m_clang_type == NULL && m_reg_info)
+ if (m_clang_type == NULL)
{
Process *process = m_reg_ctx_sp->CalculateProcess ();
if (process)
@@ -309,7 +310,8 @@
Module *exe_module = process->GetTarget().GetExecutableModule ().get();
if (exe_module)
{
- m_clang_type = exe_module->GetClangASTContext().GetBuiltinTypeForEncodingAndBitSize (m_reg_info->encoding, m_reg_info->byte_size * 8);
+ m_clang_type = exe_module->GetClangASTContext().GetBuiltinTypeForEncodingAndBitSize (m_reg_info.encoding,
+ m_reg_info.byte_size * 8);
}
}
}
@@ -346,7 +348,7 @@
size_t
ValueObjectRegister::GetByteSize()
{
- return m_reg_info->byte_size;
+ return m_reg_info.byte_size;
}
bool
@@ -355,41 +357,26 @@
m_error.Clear();
ExecutionContextScope *exe_scope = GetExecutionContextScope();
StackFrame *frame = exe_scope->CalculateStackFrame();
- if (frame)
- {
- m_reg_ctx_sp = frame->GetRegisterContext();
- if (m_reg_ctx_sp)
- {
- const RegisterInfo *reg_info = m_reg_ctx_sp->GetRegisterInfoAtIndex(m_reg_num);
- if (m_reg_info != reg_info)
- {
- m_reg_info = reg_info;
- if (m_reg_info)
- {
- if (m_reg_info->name)
- m_name.SetCString(m_reg_info->name);
- else if (m_reg_info->alt_name)
- m_name.SetCString(m_reg_info->alt_name);
- }
- }
- }
- }
- else
+ if (frame == NULL)
{
m_reg_ctx_sp.reset();
- m_reg_info = NULL;
+ m_reg_value.Clear();
}
- if (m_reg_ctx_sp && m_reg_info)
+ if (m_reg_ctx_sp)
{
- if (m_reg_ctx_sp->ReadRegisterBytes (m_reg_num, m_data))
+ if (m_reg_ctx_sp->ReadRegister (&m_reg_info, m_reg_value))
{
- m_value.SetContext(Value::eContextTypeRegisterInfo, (void *)m_reg_info);
- m_value.SetValueType(Value::eValueTypeHostAddress);
- m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
- SetValueIsValid (true);
- return true;
+ if (m_reg_value.GetData (m_data))
+ {
+ m_data.SetAddressByteSize(m_reg_ctx_sp->GetThread().GetProcess().GetAddressByteSize());
+ m_value.SetContext(Value::eContextTypeRegisterInfo, (void *)&m_reg_info);
+ m_value.SetValueType(Value::eValueTypeHostAddress);
+ m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
+ SetValueIsValid (true);
+ return true;
+ }
}
}