//===-- 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/Core/StreamString.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,
bool prefix_with_alt_name,
Format format,
uint32_t reg_name_right_align_at) const
{
DataExtractor data;
if (GetData (data))
{
bool name_printed = false;
// For simplicity, alignment of the register name printing applies only
// in the most common case where:
//
// prefix_with_name^prefix_with_alt_name is true
//
StreamString format_string;
if (reg_name_right_align_at && (prefix_with_name^prefix_with_alt_name))
format_string.Printf("%%%us", reg_name_right_align_at);
else
format_string.Printf("%%s");
const char *fmt = format_string.GetData();
if (prefix_with_name)
{
if (reg_info->name)
{
s->Printf (fmt, reg_info->name);
name_printed = true;
}
else if (reg_info->alt_name)
{
s->Printf (fmt, reg_info->alt_name);
prefix_with_alt_name = false;
name_printed = true;
}
}
if (prefix_with_alt_name)
{
if (name_printed)
s->PutChar ('/');
if (reg_info->alt_name)
{
s->Printf (fmt, reg_info->alt_name);
name_printed = true;
}
else if (!name_printed)
{
// No alternate name but we were asked to display a name, so show the main name
s->Printf (fmt, reg_info->name);
name_printed = true;
}
}
if (name_printed)
s->PutCString (" = ");
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;
// Make sure to set the buffer length of the destination buffer to avoid
// problems due to uninitalized variables.
m_data.buffer.length = src_len;
}
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:
{
switch (m_data.buffer.length)
{
default: break;
case 1: scalar = m_data.uint8; return true;
case 2: scalar = m_data.uint16; return true;
case 4: scalar = m_data.uint32; return true;
case 8: scalar = m_data.uint64; return true;
}
}
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;
else if (byte_size == sizeof(double))
m_type = eTypeDouble;
else 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, lldb::offset_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;
}
#include "llvm/ADT/StringRef.h"
#include <vector>
static inline void StripSpaces(llvm::StringRef &Str)
{
while (!Str.empty() && isspace(Str[0]))
Str = Str.substr(1);
while (!Str.empty() && isspace(Str.back()))
Str = Str.substr(0, Str.size()-1);
}
static inline void LStrip(llvm::StringRef &Str, char c)
{
if (!Str.empty() && Str.front() == c)
Str = Str.substr(1);
}
static inline void RStrip(llvm::StringRef &Str, char c)
{
if (!Str.empty() && Str.back() == c)
Str = Str.substr(0, Str.size()-1);
}
// Helper function for RegisterValue::SetValueFromCString()
static bool
ParseVectorEncoding(const RegisterInfo *reg_info, const char *vector_str, const uint32_t byte_size, RegisterValue *reg_value)
{
// Example: vector_str = "{0x2c 0x4b 0x2a 0x3e 0xd0 0x4f 0x2a 0x3e 0xac 0x4a 0x2a 0x3e 0x84 0x4f 0x2a 0x3e}".
llvm::StringRef Str(vector_str);
StripSpaces(Str);
LStrip(Str, '{');
RStrip(Str, '}');
StripSpaces(Str);
char Sep = ' ';
// The first split should give us:
// ('0x2c', '0x4b 0x2a 0x3e 0xd0 0x4f 0x2a 0x3e 0xac 0x4a 0x2a 0x3e 0x84 0x4f 0x2a 0x3e').
std::pair<llvm::StringRef, llvm::StringRef> Pair = Str.split(Sep);
std::vector<uint8_t> bytes;
unsigned byte = 0;
// Using radix auto-sensing by passing 0 as the radix.
// Keep on processing the vector elements as long as the parsing succeeds and the vector size is < byte_size.
while (!Pair.first.getAsInteger(0, byte) && bytes.size() < byte_size) {
bytes.push_back(byte);
Pair = Pair.second.split(Sep);
}
// Check for vector of exact byte_size elements.
if (bytes.size() != byte_size)
return false;
reg_value->SetBytes(&(bytes.front()), byte_size, eByteOrderLittle);
return true;
}
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)
{
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", value_str);
else if (!Args::UInt64ValueIsValidForByteSize (uval64, byte_size))
error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %u byte unsigned integer value", uval64, byte_size);
else
{
if (!SetUInt (uval64, reg_info->byte_size))
error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %u", byte_size);
}
}
else
{
error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %u", 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", value_str);
else if (!Args::SInt64ValueIsValidForByteSize (sval64, byte_size))
error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %u byte signed integer value", sval64, byte_size);
else
{
if (!SetUInt (sval64, reg_info->byte_size))
error.SetErrorStringWithFormat ("unsupported signed integer byte size: %u", byte_size);
}
}
else
{
error.SetErrorStringWithFormat ("unsupported signed integer byte size: %u", 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", 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", 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", value_str);
}
else
{
error.SetErrorStringWithFormat ("unsupported float byte size: %u", byte_size);
return error;
}
break;
case eEncodingVector:
if (!ParseVectorEncoding(reg_info, value_str, byte_size, this))
error.SetErrorString ("unrecognized vector encoding string value.");
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)
{
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;
case eTypeBytes:
{
switch (m_data.buffer.length)
{
default: break;
case 1: return m_data.uint8;
case 2: return m_data.uint16;
}
}
break;
}
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;
case eTypeBytes:
{
switch (m_data.buffer.length)
{
default: break;
case 1: return m_data.uint8;
case 2: return m_data.uint16;
case 4: 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;
case eTypeBytes:
{
switch (m_data.buffer.length)
{
default: break;
case 1: return m_data.uint8;
case 2: return m_data.uint16;
case 4: return m_data.uint32;
case 8: 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;
case eTypeBytes:
{
switch (m_data.buffer.length)
{
default:
break;
case 1: return m_data.uint8;
case 2: return m_data.uint16;
case 4: return m_data.uint32;
case 8: return m_data.uint64;
case 16: 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...
if (bytes && length > 0)
{
assert (length <= sizeof (m_data.buffer.bytes) && "Storing too many bytes in a RegisterValue.");
m_type = eTypeBytes;
m_data.buffer.length = length;
memcpy (m_data.buffer.bytes, bytes, length);
m_data.buffer.byte_order = byte_order;
}
else
{
m_type = eTypeInvalid;
m_data.buffer.length = 0;
}
}
bool
RegisterValue::operator == (const RegisterValue &rhs) const
{
if (m_type == rhs.m_type)
{
switch (m_type)
{
case eTypeInvalid: return true;
case eTypeUInt8: return m_data.uint8 == rhs.m_data.uint8;
case eTypeUInt16: return m_data.uint16 == rhs.m_data.uint16;
case eTypeUInt32: return m_data.uint32 == rhs.m_data.uint32;
case eTypeUInt64: return m_data.uint64 == rhs.m_data.uint64;
#if defined (ENABLE_128_BIT_SUPPORT)
case eTypeUInt128: return m_data.uint128 == rhs.m_data.uint128;
#endif
case eTypeFloat: return m_data.ieee_float == rhs.m_data.ieee_float;
case eTypeDouble: return m_data.ieee_double == rhs.m_data.ieee_double;
case eTypeLongDouble: return m_data.ieee_long_double == rhs.m_data.ieee_long_double;
case eTypeBytes:
if (m_data.buffer.length != rhs.m_data.buffer.length)
return false;
else
{
uint8_t length = m_data.buffer.length;
if (length > kMaxRegisterByteSize)
length = kMaxRegisterByteSize;
return memcmp (m_data.buffer.bytes, rhs.m_data.buffer.bytes, length) == 0;
}
break;
}
}
return false;
}
bool
RegisterValue::operator != (const RegisterValue &rhs) const
{
if (m_type != rhs.m_type)
return true;
switch (m_type)
{
case eTypeInvalid: return false;
case eTypeUInt8: return m_data.uint8 != rhs.m_data.uint8;
case eTypeUInt16: return m_data.uint16 != rhs.m_data.uint16;
case eTypeUInt32: return m_data.uint32 != rhs.m_data.uint32;
case eTypeUInt64: return m_data.uint64 != rhs.m_data.uint64;
#if defined (ENABLE_128_BIT_SUPPORT)
case eTypeUInt128: return m_data.uint128 != rhs.m_data.uint128;
#endif
case eTypeFloat: return m_data.ieee_float != rhs.m_data.ieee_float;
case eTypeDouble: return m_data.ieee_double != rhs.m_data.ieee_double;
case eTypeLongDouble: return m_data.ieee_long_double != rhs.m_data.ieee_long_double;
case eTypeBytes:
if (m_data.buffer.length != rhs.m_data.buffer.length)
{
return true;
}
else
{
uint8_t length = m_data.buffer.length;
if (length > kMaxRegisterByteSize)
length = kMaxRegisterByteSize;
return memcmp (m_data.buffer.bytes, rhs.m_data.buffer.bytes, length) != 0;
}
break;
}
return true;
}
bool
RegisterValue::ClearBit (uint32_t bit)
{
switch (m_type)
{
case eTypeInvalid:
break;
case eTypeUInt8:
if (bit < 8)
{
m_data.uint8 &= ~(1u << bit);
return true;
}
break;
case eTypeUInt16:
if (bit < 16)
{
m_data.uint16 &= ~(1u << bit);
return true;
}
break;
case eTypeUInt32:
if (bit < 32)
{
m_data.uint32 &= ~(1u << bit);
return true;
}
break;
case eTypeUInt64:
if (bit < 64)
{
m_data.uint64 &= ~(1ull << (uint64_t)bit);
return true;
}
break;
#if defined (ENABLE_128_BIT_SUPPORT)
case eTypeUInt128:
if (bit < 64)
{
m_data.uint128 &= ~((__uint128_t)1ull << (__uint128_t)bit);
return true;
}
#endif
case eTypeFloat:
case eTypeDouble:
case eTypeLongDouble:
break;
case eTypeBytes:
if (m_data.buffer.byte_order == eByteOrderBig || m_data.buffer.byte_order == eByteOrderLittle)
{
uint32_t byte_idx;
if (m_data.buffer.byte_order == eByteOrderBig)
byte_idx = m_data.buffer.length - (bit / 8) - 1;
else
byte_idx = bit / 8;
const uint32_t byte_bit = bit % 8;
if (byte_idx < m_data.buffer.length)
{
m_data.buffer.bytes[byte_idx] &= ~(1u << byte_bit);
return true;
}
}
break;
}
return false;
}
bool
RegisterValue::SetBit (uint32_t bit)
{
switch (m_type)
{
case eTypeInvalid:
break;
case eTypeUInt8:
if (bit < 8)
{
m_data.uint8 |= (1u << bit);
return true;
}
break;
case eTypeUInt16:
if (bit < 16)
{
m_data.uint16 |= (1u << bit);
return true;
}
break;
case eTypeUInt32:
if (bit < 32)
{
m_data.uint32 |= (1u << bit);
return true;
}
break;
case eTypeUInt64:
if (bit < 64)
{
m_data.uint64 |= (1ull << (uint64_t)bit);
return true;
}
break;
#if defined (ENABLE_128_BIT_SUPPORT)
case eTypeUInt128:
if (bit < 64)
{
m_data.uint128 |= ((__uint128_t)1ull << (__uint128_t)bit);
return true;
}
#endif
case eTypeFloat:
case eTypeDouble:
case eTypeLongDouble:
break;
case eTypeBytes:
if (m_data.buffer.byte_order == eByteOrderBig || m_data.buffer.byte_order == eByteOrderLittle)
{
uint32_t byte_idx;
if (m_data.buffer.byte_order == eByteOrderBig)
byte_idx = m_data.buffer.length - (bit / 8) - 1;
else
byte_idx = bit / 8;
const uint32_t byte_bit = bit % 8;
if (byte_idx < m_data.buffer.length)
{
m_data.buffer.bytes[byte_idx] |= (1u << byte_bit);
return true;
}
}
break;
}
return false;
}