1 //===-- RegisterValue.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 //===----------------------------------------------------------------------===//
10 #include "lldb/Core/RegisterValue.h"
14 // Other libraries and framework includes
16 #include "lldb/Core/DataExtractor.h"
17 #include "lldb/Core/Error.h"
18 #include "lldb/Core/Scalar.h"
19 #include "lldb/Core/Stream.h"
20 #include "lldb/Core/StreamString.h"
21 #include "lldb/Interpreter/Args.h"
24 using namespace lldb_private;
28 RegisterValue::Dump (Stream *s,
29 const RegisterInfo *reg_info,
30 bool prefix_with_name,
31 bool prefix_with_alt_name,
33 uint32_t reg_name_right_align_at) const
38 bool name_printed = false;
39 // For simplicity, alignment of the register name printing applies only
40 // in the most common case where:
42 // prefix_with_name^prefix_with_alt_name is true
44 StreamString format_string;
45 if (reg_name_right_align_at && (prefix_with_name^prefix_with_alt_name))
46 format_string.Printf("%%%us", reg_name_right_align_at);
48 format_string.Printf("%%s");
49 const char *fmt = format_string.GetData();
54 s->Printf (fmt, reg_info->name);
57 else if (reg_info->alt_name)
59 s->Printf (fmt, reg_info->alt_name);
60 prefix_with_alt_name = false;
64 if (prefix_with_alt_name)
68 if (reg_info->alt_name)
70 s->Printf (fmt, reg_info->alt_name);
73 else if (!name_printed)
75 // No alternate name but we were asked to display a name, so show the main name
76 s->Printf (fmt, reg_info->name);
81 s->PutCString (" = ");
83 if (format == eFormatDefault)
84 format = reg_info->format;
87 0, // Offset in "data"
88 format, // Format to use when dumping
89 reg_info->byte_size, // item_byte_size
91 UINT32_MAX, // num_per_line
92 LLDB_INVALID_ADDRESS, // base_addr
94 0); // item_bit_offset
102 RegisterValue::GetData (DataExtractor &data) const
104 return data.SetData(GetBytes(), GetByteSize(), GetByteOrder()) > 0;
109 RegisterValue::GetAsMemoryData (const RegisterInfo *reg_info,
112 lldb::ByteOrder dst_byte_order,
115 if (reg_info == NULL)
117 error.SetErrorString ("invalid register info argument.");
121 // ReadRegister should have already been called on tgus object prior to
123 if (GetType() == eTypeInvalid)
125 // No value has been read into this object...
126 error.SetErrorStringWithFormat("invalid register value type for register %s", reg_info->name);
130 if (dst_len > kMaxRegisterByteSize)
132 error.SetErrorString ("destination is too big");
136 const uint32_t src_len = reg_info->byte_size;
138 // Extract the register data into a data extractor
139 DataExtractor reg_data;
140 if (!GetData(reg_data))
142 error.SetErrorString ("invalid register value to copy into");
146 // Prepare a memory buffer that contains some or all of the register value
147 const uint32_t bytes_copied = reg_data.CopyByteOrderedData (0, // src offset
148 src_len, // src length
150 dst_len, // dst length
151 dst_byte_order); // dst byte order
152 if (bytes_copied == 0)
153 error.SetErrorStringWithFormat("failed to copy data for register write of %s", reg_info->name);
159 RegisterValue::SetFromMemoryData (const RegisterInfo *reg_info,
162 lldb::ByteOrder src_byte_order,
165 if (reg_info == NULL)
167 error.SetErrorString ("invalid register info argument.");
171 // Moving from addr into a register
173 // Case 1: src_len == dst_len
175 // |AABBCCDD| Address contents
176 // |AABBCCDD| Register contents
178 // Case 2: src_len > dst_len
180 // Error! (The register should always be big enough to hold the data)
182 // Case 3: src_len < dst_len
184 // |AABB| Address contents
185 // |AABB0000| Register contents [on little-endian hardware]
186 // |0000AABB| Register contents [on big-endian hardware]
187 if (src_len > kMaxRegisterByteSize)
189 error.SetErrorStringWithFormat ("register buffer is too small to receive %u bytes of data.", src_len);
193 const uint32_t dst_len = reg_info->byte_size;
195 if (src_len > dst_len)
197 error.SetErrorStringWithFormat("%u bytes is too big to store in register %s (%u bytes)", src_len, reg_info->name, dst_len);
201 // Use a data extractor to correctly copy and pad the bytes read into the
203 DataExtractor src_data (src, src_len, src_byte_order, 4);
205 // Given the register info, set the value type of this RegisterValue object
207 // And make sure we were able to figure out what that register value was
208 RegisterValue::Type value_type = GetType();
209 if (value_type == eTypeInvalid)
211 // No value has been read into this object...
212 error.SetErrorStringWithFormat("invalid register value type for register %s", reg_info->name);
215 else if (value_type == eTypeBytes)
217 m_data.buffer.byte_order = src_byte_order;
218 // Make sure to set the buffer length of the destination buffer to avoid
219 // problems due to uninitalized variables.
220 m_data.buffer.length = src_len;
223 const uint32_t bytes_copied = src_data.CopyByteOrderedData (0, // src offset
224 src_len, // src length
225 GetBytes(), // dst buffer
226 GetByteSize(), // dst length
227 GetByteOrder()); // dst byte order
228 if (bytes_copied == 0)
229 error.SetErrorStringWithFormat("failed to copy data for register write of %s", reg_info->name);
235 RegisterValue::GetScalarValue (Scalar &scalar) const
239 case eTypeInvalid: break;
242 switch (m_data.buffer.length)
245 case 1: scalar = m_data.uint8; return true;
246 case 2: scalar = m_data.uint16; return true;
247 case 4: scalar = m_data.uint32; return true;
248 case 8: scalar = m_data.uint64; return true;
251 case eTypeUInt8: scalar = m_data.uint8; return true;
252 case eTypeUInt16: scalar = m_data.uint16; return true;
253 case eTypeUInt32: scalar = m_data.uint32; return true;
254 case eTypeUInt64: scalar = m_data.uint64; return true;
255 #if defined (ENABLE_128_BIT_SUPPORT)
256 case eTypeUInt128: break;
258 case eTypeFloat: scalar = m_data.ieee_float; return true;
259 case eTypeDouble: scalar = m_data.ieee_double; return true;
260 case eTypeLongDouble: scalar = m_data.ieee_long_double; return true;
266 RegisterValue::Clear()
268 m_type = eTypeInvalid;
272 RegisterValue::SetType (const RegisterInfo *reg_info)
274 m_type = eTypeInvalid;
275 const uint32_t byte_size = reg_info->byte_size;
276 switch (reg_info->encoding)
278 case eEncodingInvalid:
285 else if (byte_size <= 2)
286 m_type = eTypeUInt16;
287 else if (byte_size <= 4)
288 m_type = eTypeUInt32;
289 else if (byte_size <= 8)
290 m_type = eTypeUInt64;
291 #if defined (ENABLE_128_BIT_SUPPORT)
292 else if (byte_size <= 16)
293 m_type = eTypeUInt128;
297 case eEncodingIEEE754:
298 if (byte_size == sizeof(float))
300 else if (byte_size == sizeof(double))
301 m_type = eTypeDouble;
302 else if (byte_size == sizeof(long double))
303 m_type = eTypeLongDouble;
306 case eEncodingVector:
314 RegisterValue::SetValueFromData (const RegisterInfo *reg_info, DataExtractor &src, lldb::offset_t src_offset, bool partial_data_ok)
318 if (src.GetByteSize() == 0)
320 error.SetErrorString ("empty data.");
324 if (reg_info->byte_size == 0)
326 error.SetErrorString ("invalid register info.");
330 uint32_t src_len = src.GetByteSize() - src_offset;
332 if (!partial_data_ok && (src_len < reg_info->byte_size))
334 error.SetErrorString ("not enough data.");
338 // Cap the data length if there is more than enough bytes for this register
340 if (src_len > reg_info->byte_size)
341 src_len = reg_info->byte_size;
343 // Zero out the value in case we get partial data...
344 memset (m_data.buffer.bytes, 0, sizeof (m_data.buffer.bytes));
346 switch (SetType (reg_info))
349 error.SetErrorString("");
351 case eTypeUInt8: SetUInt8 (src.GetMaxU32 (&src_offset, src_len)); break;
352 case eTypeUInt16: SetUInt16 (src.GetMaxU32 (&src_offset, src_len)); break;
353 case eTypeUInt32: SetUInt32 (src.GetMaxU32 (&src_offset, src_len)); break;
354 case eTypeUInt64: SetUInt64 (src.GetMaxU64 (&src_offset, src_len)); break;
355 #if defined (ENABLE_128_BIT_SUPPORT)
358 __uint128_t data1 = src.GetU64 (&src_offset);
359 __uint128_t data2 = src.GetU64 (&src_offset);
360 if (src.GetByteSize() == eByteOrderBig)
361 SetUInt128 (data1 << 64 + data2);
363 SetUInt128 (data2 << 64 + data1);
367 case eTypeFloat: SetFloat (src.GetFloat (&src_offset)); break;
368 case eTypeDouble: SetDouble(src.GetDouble (&src_offset)); break;
369 case eTypeLongDouble: SetFloat (src.GetLongDouble (&src_offset)); break;
372 m_data.buffer.length = reg_info->byte_size;
373 m_data.buffer.byte_order = src.GetByteOrder();
374 assert (m_data.buffer.length <= kMaxRegisterByteSize);
375 if (m_data.buffer.length > kMaxRegisterByteSize)
376 m_data.buffer.length = kMaxRegisterByteSize;
377 if (src.CopyByteOrderedData (src_offset, // offset within "src" to start extracting data
378 src_len, // src length
379 m_data.buffer.bytes, // dst buffer
380 m_data.buffer.length, // dst length
381 m_data.buffer.byte_order) == 0)// dst byte order
383 error.SetErrorString ("data copy failed data.");
392 #include "llvm/ADT/StringRef.h"
394 static inline void StripSpaces(llvm::StringRef &Str)
396 while (!Str.empty() && isspace(Str[0]))
398 while (!Str.empty() && isspace(Str.back()))
399 Str = Str.substr(0, Str.size()-1);
401 static inline void LStrip(llvm::StringRef &Str, char c)
403 if (!Str.empty() && Str.front() == c)
406 static inline void RStrip(llvm::StringRef &Str, char c)
408 if (!Str.empty() && Str.back() == c)
409 Str = Str.substr(0, Str.size()-1);
411 // Helper function for RegisterValue::SetValueFromCString()
413 ParseVectorEncoding(const RegisterInfo *reg_info, const char *vector_str, const uint32_t byte_size, RegisterValue *reg_value)
415 // Example: vector_str = "{0x2c 0x4b 0x2a 0x3e 0xd0 0x4f 0x2a 0x3e 0xac 0x4a 0x2a 0x3e 0x84 0x4f 0x2a 0x3e}".
416 llvm::StringRef Str(vector_str);
424 // The first split should give us:
425 // ('0x2c', '0x4b 0x2a 0x3e 0xd0 0x4f 0x2a 0x3e 0xac 0x4a 0x2a 0x3e 0x84 0x4f 0x2a 0x3e').
426 std::pair<llvm::StringRef, llvm::StringRef> Pair = Str.split(Sep);
427 std::vector<uint8_t> bytes;
430 // Using radix auto-sensing by passing 0 as the radix.
431 // Keep on processing the vector elements as long as the parsing succeeds and the vector size is < byte_size.
432 while (!Pair.first.getAsInteger(0, byte) && bytes.size() < byte_size) {
433 bytes.push_back(byte);
434 Pair = Pair.second.split(Sep);
437 // Check for vector of exact byte_size elements.
438 if (bytes.size() != byte_size)
441 reg_value->SetBytes(&(bytes.front()), byte_size, eByteOrderLittle);
445 RegisterValue::SetValueFromCString (const RegisterInfo *reg_info, const char *value_str)
448 if (reg_info == NULL)
450 error.SetErrorString ("Invalid register info argument.");
454 if (value_str == NULL || value_str[0] == '\0')
456 error.SetErrorString ("Invalid c-string value string.");
459 bool success = false;
460 const uint32_t byte_size = reg_info->byte_size;
461 switch (reg_info->encoding)
463 case eEncodingInvalid:
464 error.SetErrorString ("Invalid encoding.");
468 if (byte_size <= sizeof (uint64_t))
470 uint64_t uval64 = Args::StringToUInt64(value_str, UINT64_MAX, 0, &success);
472 error.SetErrorStringWithFormat ("'%s' is not a valid unsigned integer string value", value_str);
473 else if (!Args::UInt64ValueIsValidForByteSize (uval64, byte_size))
474 error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %u byte unsigned integer value", uval64, byte_size);
477 if (!SetUInt (uval64, reg_info->byte_size))
478 error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %u", byte_size);
483 error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %u", byte_size);
489 if (byte_size <= sizeof (long long))
491 uint64_t sval64 = Args::StringToSInt64(value_str, INT64_MAX, 0, &success);
493 error.SetErrorStringWithFormat ("'%s' is not a valid signed integer string value", value_str);
494 else if (!Args::SInt64ValueIsValidForByteSize (sval64, byte_size))
495 error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %u byte signed integer value", sval64, byte_size);
498 if (!SetUInt (sval64, reg_info->byte_size))
499 error.SetErrorStringWithFormat ("unsupported signed integer byte size: %u", byte_size);
504 error.SetErrorStringWithFormat ("unsupported signed integer byte size: %u", byte_size);
509 case eEncodingIEEE754:
510 if (byte_size == sizeof (float))
512 if (::sscanf (value_str, "%f", &m_data.ieee_float) == 1)
515 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
517 else if (byte_size == sizeof (double))
519 if (::sscanf (value_str, "%lf", &m_data.ieee_double) == 1)
520 m_type = eTypeDouble;
522 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
524 else if (byte_size == sizeof (long double))
526 if (::sscanf (value_str, "%Lf", &m_data.ieee_long_double) == 1)
527 m_type = eTypeLongDouble;
529 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
533 error.SetErrorStringWithFormat ("unsupported float byte size: %u", byte_size);
538 case eEncodingVector:
539 if (!ParseVectorEncoding(reg_info, value_str, byte_size, this))
540 error.SetErrorString ("unrecognized vector encoding string value.");
544 m_type = eTypeInvalid;
551 RegisterValue::SignExtend (uint32_t sign_bitpos)
559 if (sign_bitpos == (8-1))
561 else if (sign_bitpos < (8-1))
563 uint8_t sign_bit = 1u << sign_bitpos;
564 if (m_data.uint8 & sign_bit)
566 const uint8_t mask = ~(sign_bit) + 1u;
567 m_data.uint8 |= mask;
574 if (sign_bitpos == (16-1))
576 else if (sign_bitpos < (16-1))
578 uint16_t sign_bit = 1u << sign_bitpos;
579 if (m_data.uint16 & sign_bit)
581 const uint16_t mask = ~(sign_bit) + 1u;
582 m_data.uint16 |= mask;
589 if (sign_bitpos == (32-1))
591 else if (sign_bitpos < (32-1))
593 uint32_t sign_bit = 1u << sign_bitpos;
594 if (m_data.uint32 & sign_bit)
596 const uint32_t mask = ~(sign_bit) + 1u;
597 m_data.uint32 |= mask;
604 if (sign_bitpos == (64-1))
606 else if (sign_bitpos < (64-1))
608 uint64_t sign_bit = 1ull << sign_bitpos;
609 if (m_data.uint64 & sign_bit)
611 const uint64_t mask = ~(sign_bit) + 1ull;
612 m_data.uint64 |= mask;
618 #if defined (ENABLE_128_BIT_SUPPORT)
620 if (sign_bitpos == (128-1))
622 else if (sign_bitpos < (128-1))
624 __uint128_t sign_bit = (__uint128_t)1u << sign_bitpos;
625 if (m_data.uint128 & sign_bit)
627 const uint128_t mask = ~(sign_bit) + 1u;
628 m_data.uint128 |= mask;
636 case eTypeLongDouble:
644 RegisterValue::CopyValue (const RegisterValue &rhs)
651 case eTypeUInt8: m_data.uint8 = rhs.m_data.uint8; break;
652 case eTypeUInt16: m_data.uint16 = rhs.m_data.uint16; break;
653 case eTypeUInt32: m_data.uint32 = rhs.m_data.uint32; break;
654 case eTypeUInt64: m_data.uint64 = rhs.m_data.uint64; break;
655 #if defined (ENABLE_128_BIT_SUPPORT)
656 case eTypeUInt128: m_data.uint128 = rhs.m_data.uint128; break;
658 case eTypeFloat: m_data.ieee_float = rhs.m_data.ieee_float; break;
659 case eTypeDouble: m_data.ieee_double = rhs.m_data.ieee_double; break;
660 case eTypeLongDouble: m_data.ieee_long_double = rhs.m_data.ieee_long_double; break;
662 assert (rhs.m_data.buffer.length <= kMaxRegisterByteSize);
663 ::memcpy (m_data.buffer.bytes, rhs.m_data.buffer.bytes, kMaxRegisterByteSize);
664 m_data.buffer.length = rhs.m_data.buffer.length;
665 m_data.buffer.byte_order = rhs.m_data.buffer.byte_order;
672 RegisterValue::GetAsUInt16 (uint16_t fail_value, bool *success_ptr) const
680 case eTypeUInt8: return m_data.uint8;
681 case eTypeUInt16: return m_data.uint16;
684 switch (m_data.buffer.length)
687 case 1: return m_data.uint8;
688 case 2: return m_data.uint16;
694 *success_ptr = false;
699 RegisterValue::GetAsUInt32 (uint32_t fail_value, bool *success_ptr) const
706 case eTypeUInt8: return m_data.uint8;
707 case eTypeUInt16: return m_data.uint16;
708 case eTypeUInt32: return m_data.uint32;
710 if (sizeof(float) == sizeof(uint32_t))
711 return m_data.uint32;
714 if (sizeof(double) == sizeof(uint32_t))
715 return m_data.uint32;
717 case eTypeLongDouble:
718 if (sizeof(long double) == sizeof(uint32_t))
719 return m_data.uint32;
723 switch (m_data.buffer.length)
726 case 1: return m_data.uint8;
727 case 2: return m_data.uint16;
728 case 4: return m_data.uint32;
734 *success_ptr = false;
739 RegisterValue::GetAsUInt64 (uint64_t fail_value, bool *success_ptr) const
746 case eTypeUInt8: return m_data.uint8;
747 case eTypeUInt16: return m_data.uint16;
748 case eTypeUInt32: return m_data.uint32;
749 case eTypeUInt64: return m_data.uint64;
751 if (sizeof(float) == sizeof(uint64_t))
752 return m_data.uint64;
755 if (sizeof(double) == sizeof(uint64_t))
756 return m_data.uint64;
758 case eTypeLongDouble:
759 if (sizeof(long double) == sizeof(uint64_t))
760 return m_data.uint64;
764 switch (m_data.buffer.length)
767 case 1: return m_data.uint8;
768 case 2: return m_data.uint16;
769 case 4: return m_data.uint32;
770 case 8: return m_data.uint64;
776 *success_ptr = false;
780 #if defined (ENABLE_128_BIT_SUPPORT)
782 RegisterValue::GetAsUInt128 (__uint128_t fail_value, bool *success_ptr) const
789 case eTypeUInt8: return m_data.uint8;
790 case eTypeUInt16: return m_data.uint16;
791 case eTypeUInt32: return m_data.uint32;
792 case eTypeUInt64: return m_data.uint64;
793 case eTypeUInt128: return m_data.uint128;
795 if (sizeof(float) == sizeof(__uint128_t))
796 return m_data.uint128;
799 if (sizeof(double) == sizeof(__uint128_t))
800 return m_data.uint128;
802 case eTypeLongDouble:
803 if (sizeof(long double) == sizeof(__uint128_t))
804 return m_data.uint128;
808 switch (m_data.buffer.length)
812 case 1: return m_data.uint8;
813 case 2: return m_data.uint16;
814 case 4: return m_data.uint32;
815 case 8: return m_data.uint64;
816 case 16: return m_data.uint128;
822 *success_ptr = false;
827 RegisterValue::GetAsFloat (float fail_value, bool *success_ptr) const
835 if (sizeof(float) == sizeof(m_data.uint32))
836 return m_data.ieee_float;
839 if (sizeof(float) == sizeof(m_data.uint64))
840 return m_data.ieee_float;
842 #if defined (ENABLE_128_BIT_SUPPORT)
844 if (sizeof(float) == sizeof(m_data.uint128))
845 return m_data.ieee_float;
848 case eTypeFloat: return m_data.ieee_float;
850 if (sizeof(float) == sizeof(double))
851 return m_data.ieee_float;
853 case eTypeLongDouble:
854 if (sizeof(float) == sizeof(long double))
855 return m_data.ieee_float;
859 *success_ptr = false;
864 RegisterValue::GetAsDouble (double fail_value, bool *success_ptr) const
874 if (sizeof(double) == sizeof(m_data.uint32))
875 return m_data.ieee_double;
879 if (sizeof(double) == sizeof(m_data.uint64))
880 return m_data.ieee_double;
883 #if defined (ENABLE_128_BIT_SUPPORT)
885 if (sizeof(double) == sizeof(m_data.uint128))
886 return m_data.ieee_double;
888 case eTypeFloat: return m_data.ieee_float;
889 case eTypeDouble: return m_data.ieee_double;
891 case eTypeLongDouble:
892 if (sizeof(double) == sizeof(long double))
893 return m_data.ieee_double;
897 *success_ptr = false;
902 RegisterValue::GetAsLongDouble (long double fail_value, bool *success_ptr) const
912 if (sizeof(long double) == sizeof(m_data.uint32))
913 return m_data.ieee_long_double;
917 if (sizeof(long double) == sizeof(m_data.uint64))
918 return m_data.ieee_long_double;
921 #if defined (ENABLE_128_BIT_SUPPORT)
923 if (sizeof(long double) == sizeof(m_data.uint128))
924 return m_data.ieee_long_double;
926 case eTypeFloat: return m_data.ieee_float;
927 case eTypeDouble: return m_data.ieee_double;
928 case eTypeLongDouble: return m_data.ieee_long_double;
932 *success_ptr = false;
937 RegisterValue::GetBytes () const
941 case eTypeInvalid: break;
942 case eTypeUInt8: return &m_data.uint8;
943 case eTypeUInt16: return &m_data.uint16;
944 case eTypeUInt32: return &m_data.uint32;
945 case eTypeUInt64: return &m_data.uint64;
946 #if defined (ENABLE_128_BIT_SUPPORT)
947 case eTypeUInt128: return &m_data.uint128;
949 case eTypeFloat: return &m_data.ieee_float;
950 case eTypeDouble: return &m_data.ieee_double;
951 case eTypeLongDouble: return &m_data.ieee_long_double;
952 case eTypeBytes: return m_data.buffer.bytes;
958 RegisterValue::GetBytes ()
962 case eTypeInvalid: break;
963 case eTypeUInt8: return &m_data.uint8;
964 case eTypeUInt16: return &m_data.uint16;
965 case eTypeUInt32: return &m_data.uint32;
966 case eTypeUInt64: return &m_data.uint64;
967 #if defined (ENABLE_128_BIT_SUPPORT)
968 case eTypeUInt128: return &m_data.uint128;
970 case eTypeFloat: return &m_data.ieee_float;
971 case eTypeDouble: return &m_data.ieee_double;
972 case eTypeLongDouble: return &m_data.ieee_long_double;
973 case eTypeBytes: return m_data.buffer.bytes;
979 RegisterValue::GetByteSize () const
983 case eTypeInvalid: break;
984 case eTypeUInt8: return sizeof(m_data.uint8);
985 case eTypeUInt16: return sizeof(m_data.uint16);
986 case eTypeUInt32: return sizeof(m_data.uint32);
987 case eTypeUInt64: return sizeof(m_data.uint64);
988 #if defined (ENABLE_128_BIT_SUPPORT)
989 case eTypeUInt128: return sizeof(m_data.uint128);
991 case eTypeFloat: return sizeof(m_data.ieee_float);
992 case eTypeDouble: return sizeof(m_data.ieee_double);
993 case eTypeLongDouble: return sizeof(m_data.ieee_long_double);
994 case eTypeBytes: return m_data.buffer.length;
1001 RegisterValue::SetUInt (uint64_t uint, uint32_t byte_size)
1007 else if (byte_size == 1)
1011 else if (byte_size <= 2)
1015 else if (byte_size <= 4)
1019 else if (byte_size <= 8)
1023 #if defined (ENABLE_128_BIT_SUPPORT)
1024 else if (byte_size <= 16)
1035 RegisterValue::SetBytes (const void *bytes, size_t length, lldb::ByteOrder byte_order)
1037 // If this assertion fires off we need to increase the size of
1038 // m_data.buffer.bytes, or make it something that is allocated on
1039 // the heap. Since the data buffer is in a union, we can't make it
1040 // a collection class like SmallVector...
1041 if (bytes && length > 0)
1043 assert (length <= sizeof (m_data.buffer.bytes) && "Storing too many bytes in a RegisterValue.");
1044 m_type = eTypeBytes;
1045 m_data.buffer.length = length;
1046 memcpy (m_data.buffer.bytes, bytes, length);
1047 m_data.buffer.byte_order = byte_order;
1051 m_type = eTypeInvalid;
1052 m_data.buffer.length = 0;
1058 RegisterValue::operator == (const RegisterValue &rhs) const
1060 if (m_type == rhs.m_type)
1064 case eTypeInvalid: return true;
1065 case eTypeUInt8: return m_data.uint8 == rhs.m_data.uint8;
1066 case eTypeUInt16: return m_data.uint16 == rhs.m_data.uint16;
1067 case eTypeUInt32: return m_data.uint32 == rhs.m_data.uint32;
1068 case eTypeUInt64: return m_data.uint64 == rhs.m_data.uint64;
1069 #if defined (ENABLE_128_BIT_SUPPORT)
1070 case eTypeUInt128: return m_data.uint128 == rhs.m_data.uint128;
1072 case eTypeFloat: return m_data.ieee_float == rhs.m_data.ieee_float;
1073 case eTypeDouble: return m_data.ieee_double == rhs.m_data.ieee_double;
1074 case eTypeLongDouble: return m_data.ieee_long_double == rhs.m_data.ieee_long_double;
1076 if (m_data.buffer.length != rhs.m_data.buffer.length)
1080 uint8_t length = m_data.buffer.length;
1081 if (length > kMaxRegisterByteSize)
1082 length = kMaxRegisterByteSize;
1083 return memcmp (m_data.buffer.bytes, rhs.m_data.buffer.bytes, length) == 0;
1092 RegisterValue::operator != (const RegisterValue &rhs) const
1094 if (m_type != rhs.m_type)
1098 case eTypeInvalid: return false;
1099 case eTypeUInt8: return m_data.uint8 != rhs.m_data.uint8;
1100 case eTypeUInt16: return m_data.uint16 != rhs.m_data.uint16;
1101 case eTypeUInt32: return m_data.uint32 != rhs.m_data.uint32;
1102 case eTypeUInt64: return m_data.uint64 != rhs.m_data.uint64;
1103 #if defined (ENABLE_128_BIT_SUPPORT)
1104 case eTypeUInt128: return m_data.uint128 != rhs.m_data.uint128;
1106 case eTypeFloat: return m_data.ieee_float != rhs.m_data.ieee_float;
1107 case eTypeDouble: return m_data.ieee_double != rhs.m_data.ieee_double;
1108 case eTypeLongDouble: return m_data.ieee_long_double != rhs.m_data.ieee_long_double;
1110 if (m_data.buffer.length != rhs.m_data.buffer.length)
1116 uint8_t length = m_data.buffer.length;
1117 if (length > kMaxRegisterByteSize)
1118 length = kMaxRegisterByteSize;
1119 return memcmp (m_data.buffer.bytes, rhs.m_data.buffer.bytes, length) != 0;
1127 RegisterValue::ClearBit (uint32_t bit)
1137 m_data.uint8 &= ~(1u << bit);
1145 m_data.uint16 &= ~(1u << bit);
1153 m_data.uint32 &= ~(1u << bit);
1161 m_data.uint64 &= ~(1ull << (uint64_t)bit);
1165 #if defined (ENABLE_128_BIT_SUPPORT)
1169 m_data.uint128 &= ~((__uint128_t)1ull << (__uint128_t)bit);
1175 case eTypeLongDouble:
1179 if (m_data.buffer.byte_order == eByteOrderBig || m_data.buffer.byte_order == eByteOrderLittle)
1182 if (m_data.buffer.byte_order == eByteOrderBig)
1183 byte_idx = m_data.buffer.length - (bit / 8) - 1;
1187 const uint32_t byte_bit = bit % 8;
1188 if (byte_idx < m_data.buffer.length)
1190 m_data.buffer.bytes[byte_idx] &= ~(1u << byte_bit);
1201 RegisterValue::SetBit (uint32_t bit)
1211 m_data.uint8 |= (1u << bit);
1219 m_data.uint16 |= (1u << bit);
1227 m_data.uint32 |= (1u << bit);
1235 m_data.uint64 |= (1ull << (uint64_t)bit);
1239 #if defined (ENABLE_128_BIT_SUPPORT)
1243 m_data.uint128 |= ((__uint128_t)1ull << (__uint128_t)bit);
1249 case eTypeLongDouble:
1253 if (m_data.buffer.byte_order == eByteOrderBig || m_data.buffer.byte_order == eByteOrderLittle)
1256 if (m_data.buffer.byte_order == eByteOrderBig)
1257 byte_idx = m_data.buffer.length - (bit / 8) - 1;
1261 const uint32_t byte_bit = bit % 8;
1262 if (byte_idx < m_data.buffer.length)
1264 m_data.buffer.bytes[byte_idx] |= (1u << byte_bit);