From da70c17bfce29c136bad88600afaa36aa0b91259 Mon Sep 17 00:00:00 2001 From: Ulrich Weigand Date: Thu, 14 Apr 2016 17:22:18 +0000 Subject: [PATCH] Revert r266311 - Fix usage of APInt.getRawData for big-endian systems Try to get 32-bit build bots running again. llvm-svn: 266341 --- lldb/include/lldb/Core/Scalar.h | 20 +- lldb/include/lldb/Symbol/Type.h | 4 +- lldb/source/Core/Scalar.cpp | 515 +++++++++--------- lldb/source/Expression/IRInterpreter.cpp | 41 +- .../ExpressionParser/Clang/IRForTarget.cpp | 8 +- lldb/source/Symbol/ClangASTContext.cpp | 15 +- lldb/unittests/Core/ScalarTest.cpp | 49 -- 7 files changed, 310 insertions(+), 342 deletions(-) diff --git a/lldb/include/lldb/Core/Scalar.h b/lldb/include/lldb/Core/Scalar.h index be2176e2b50e..db103ffc9850 100644 --- a/lldb/include/lldb/Core/Scalar.h +++ b/lldb/include/lldb/Core/Scalar.h @@ -162,9 +162,6 @@ public: bool MakeSigned (); - bool - MakeUnsigned (); - static const char * GetValueTypeAsCString (Scalar::Type value_type); @@ -242,10 +239,22 @@ public: int SInt(int fail_value = 0) const; + // Return the raw unsigned integer without any casting or conversion + unsigned int + RawUInt () const; + + // Return the raw unsigned long without any casting or conversion + unsigned long + RawULong () const; + + // Return the raw unsigned long long without any casting or conversion + unsigned long long + RawULongLong () const; + unsigned char UChar(unsigned char fail_value = 0) const; - signed char + char SChar(char fail_value = 0) const; unsigned short @@ -290,6 +299,9 @@ public: long double LongDouble(long double fail_value = 0.0) const; + uint64_t + GetRawBits64 (uint64_t fail_value) const; + Error SetValueFromCString (const char *s, lldb::Encoding encoding, size_t byte_size); diff --git a/lldb/include/lldb/Symbol/Type.h b/lldb/include/lldb/Symbol/Type.h index 9158f28998e3..5524cea4fb8b 100644 --- a/lldb/include/lldb/Symbol/Type.h +++ b/lldb/include/lldb/Symbol/Type.h @@ -958,13 +958,13 @@ public: uint64_t GetValueAsUnsigned () const { - return m_value.getZExtValue(); + return *m_value.getRawData(); } int64_t GetValueAsSigned () const { - return m_value.getSExtValue(); + return (int64_t) *m_value.getRawData(); } protected: diff --git a/lldb/source/Core/Scalar.cpp b/lldb/source/Core/Scalar.cpp index 919b70bd7d27..85c37bc24c08 100644 --- a/lldb/source/Core/Scalar.cpp +++ b/lldb/source/Core/Scalar.cpp @@ -16,8 +16,6 @@ #include // Other libraries and framework includes -#include "llvm/ADT/SmallString.h" - // Project includes #include "lldb/Interpreter/Args.h" #include "lldb/Core/Error.h" @@ -136,10 +134,10 @@ bool Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const { size_t byte_size = GetByteSize(); + static float f_val; + static double d_val; if (byte_size > 0) { - const uint8_t *bytes = reinterpret_cast(GetBytes()); - if (limit_byte_size < byte_size) { if (endian::InlHostByteOrder() == eByteOrderLittle) @@ -147,19 +145,105 @@ Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const // On little endian systems if we want fewer bytes from the // current type we just specify fewer bytes since the LSByte // is first... - byte_size = limit_byte_size; + switch(m_type) + { + case e_void: + break; + case e_sint: + case e_uint: + case e_slong: + case e_ulong: + case e_slonglong: + case e_ulonglong: + case e_sint128: + case e_uint128: + case e_sint256: + case e_uint256: + data.SetData((const uint8_t *)m_integer.getRawData(), limit_byte_size, endian::InlHostByteOrder()); + return true; + case e_float: + f_val = m_float.convertToFloat(); + data.SetData((uint8_t *)&f_val, limit_byte_size, endian::InlHostByteOrder()); + return true; + case e_double: + d_val = m_float.convertToDouble(); + data.SetData((uint8_t *)&d_val, limit_byte_size, endian::InlHostByteOrder()); + return true; + case e_long_double: + static llvm::APInt ldbl_val = m_float.bitcastToAPInt(); + data.SetData((const uint8_t *)ldbl_val.getRawData(), limit_byte_size, endian::InlHostByteOrder()); + return true; + } } else if (endian::InlHostByteOrder() == eByteOrderBig) { // On big endian systems if we want fewer bytes from the // current type have to advance our initial byte pointer and // trim down the number of bytes since the MSByte is first - bytes += byte_size - limit_byte_size; - byte_size = limit_byte_size; + switch(m_type) + { + case e_void: + break; + case e_sint: + case e_uint: + case e_slong: + case e_ulong: + case e_slonglong: + case e_ulonglong: + case e_sint128: + case e_uint128: + case e_sint256: + case e_uint256: + data.SetData((const uint8_t *)m_integer.getRawData() + byte_size - limit_byte_size, limit_byte_size, endian::InlHostByteOrder()); + return true; + case e_float: + f_val = m_float.convertToFloat(); + data.SetData((uint8_t *)&f_val + byte_size - limit_byte_size, limit_byte_size, endian::InlHostByteOrder()); + return true; + case e_double: + d_val = m_float.convertToDouble(); + data.SetData((uint8_t *)&d_val + byte_size - limit_byte_size, limit_byte_size, endian::InlHostByteOrder()); + return true; + case e_long_double: + static llvm::APInt ldbl_val = m_float.bitcastToAPInt(); + data.SetData((const uint8_t *)ldbl_val.getRawData() + byte_size - limit_byte_size, limit_byte_size, endian::InlHostByteOrder()); + return true; + } + } + } + else + { + // We want all of the data + switch(m_type) + { + case e_void: + break; + case e_sint: + case e_uint: + case e_slong: + case e_ulong: + case e_slonglong: + case e_ulonglong: + case e_sint128: + case e_uint128: + case e_sint256: + case e_uint256: + data.SetData((const uint8_t *)m_integer.getRawData(), byte_size, endian::InlHostByteOrder()); + return true; + case e_float: + f_val = m_float.convertToFloat(); + data.SetData((uint8_t *)&f_val, byte_size, endian::InlHostByteOrder()); + return true; + case e_double: + d_val = m_float.convertToDouble(); + data.SetData((uint8_t *)&d_val, byte_size, endian::InlHostByteOrder()); + return true; + case e_long_double: + static llvm::APInt ldbl_val = m_float.bitcastToAPInt(); + data.SetData((const uint8_t *)ldbl_val.getRawData(), byte_size, endian::InlHostByteOrder()); + return true; } } - - data.SetData(bytes, byte_size, endian::InlHostByteOrder()); return true; } data.Clear(); @@ -169,11 +253,8 @@ Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const const void * Scalar::GetBytes() const { - const uint64_t *apint_words; - const uint8_t *bytes; static float_t flt_val; static double_t dbl_val; - static uint64_t swapped_words[4]; switch (m_type) { case e_void: @@ -184,44 +265,11 @@ Scalar::GetBytes() const case e_ulong: case e_slonglong: case e_ulonglong: - bytes = reinterpret_cast(m_integer.getRawData()); - // getRawData always returns a pointer to an uint64_t. If we have a smaller type, - // we need to update the pointer on big-endian systems. - if (endian::InlHostByteOrder() == eByteOrderBig) - { - size_t byte_size = m_integer.getBitWidth() / 8; - if (byte_size < 8) - bytes += 8 - byte_size; - } - return bytes; case e_sint128: case e_uint128: - apint_words = m_integer.getRawData(); - // getRawData always returns a pointer to an array of two uint64_t values, - // where the least-significant word always comes first. On big-endian - // systems we need to swap the two words. - if (endian::InlHostByteOrder() == eByteOrderBig) - { - swapped_words[0] = apint_words[1]; - swapped_words[1] = apint_words[0]; - apint_words = swapped_words; - } - return reinterpret_cast(apint_words); case e_sint256: case e_uint256: - apint_words = m_integer.getRawData(); - // getRawData always returns a pointer to an array of four uint64_t values, - // where the least-significant word always comes first. On big-endian - // systems we need to swap the four words. - if (endian::InlHostByteOrder() == eByteOrderBig) - { - swapped_words[0] = apint_words[3]; - swapped_words[1] = apint_words[2]; - swapped_words[2] = apint_words[1]; - swapped_words[3] = apint_words[0]; - apint_words = swapped_words; - } - return reinterpret_cast(apint_words); + return reinterpret_cast(m_integer.getRawData()); case e_float: flt_val = m_float.convertToFloat(); return reinterpret_cast(&flt_val); @@ -230,17 +278,7 @@ Scalar::GetBytes() const return reinterpret_cast(&dbl_val); case e_long_double: llvm::APInt ldbl_val = m_float.bitcastToAPInt(); - apint_words = ldbl_val.getRawData(); - // getRawData always returns a pointer to an array of two uint64_t values, - // where the least-significant word always comes first. On big-endian - // systems we need to swap the two words. - if (endian::InlHostByteOrder() == eByteOrderBig) - { - swapped_words[0] = apint_words[1]; - swapped_words[1] = apint_words[0]; - apint_words = swapped_words; - } - return reinterpret_cast(apint_words); + return reinterpret_cast(ldbl_val.getRawData()); } return nullptr; } @@ -300,6 +338,7 @@ Scalar::IsZero() const void Scalar::GetValue (Stream *s, bool show_type) const { + const uint64_t *src; if (show_type) s->Printf("(%s) ", GetTypeAsCString()); @@ -307,26 +346,28 @@ Scalar::GetValue (Stream *s, bool show_type) const { case e_void: break; - case e_sint: - case e_ulong: - case e_slonglong: + case e_sint: s->Printf("%i", *(const sint_t *) m_integer.getRawData()); break; + case e_uint: s->Printf("0x%8.8x", *(const uint_t *) m_integer.getRawData()); break; + case e_slong: s->Printf("%li", *(const slong_t *) m_integer.getRawData()); break; + case e_ulong: s->Printf("0x%8.8lx", *(const ulong_t *) m_integer.getRawData()); break; + case e_slonglong: s->Printf("%lli", *(const slonglong_t *) m_integer.getRawData()); break; + case e_ulonglong: s->Printf("0x%16.16llx", *(const ulonglong_t *) m_integer.getRawData()); break; case e_sint128: case e_sint256: s->Printf("%s",m_integer.toString(10,true).c_str()); break; - case e_uint: - case e_slong: - case e_ulonglong: case e_uint128: + src = m_integer.getRawData(); + s->Printf("0x%16.16llx%16.16llx", *(const ulonglong_t *)src, *(const ulonglong_t *)(src + 1)); + break; case e_uint256: s->Printf("%s",m_integer.toString(16,false).c_str()); break; - case e_float: - case e_double: + case e_float: s->Printf("%f", m_float.convertToFloat()); break; + case e_double: s->Printf("%g", m_float.convertToDouble()); break; case e_long_double: - llvm::SmallString<24> string; - m_float.toString(string); - s->Printf("%s", string.c_str()); + llvm::APInt ldbl_val = m_float.bitcastToAPInt(); + s->Printf("%Lg", *(const long_double_t *)ldbl_val.getRawData()); break; } } @@ -494,47 +535,39 @@ Scalar::Promote(Scalar::Type type) case e_void: break; case e_sint: success = true; break; case e_uint: - m_integer = m_integer.zextOrTrunc(sizeof(uint_t) * 8); + m_integer = llvm::APInt(sizeof(uint_t) * 8, *(const uint64_t *)m_integer.getRawData(), false); success = true; break; case e_slong: - m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8); + m_integer = llvm::APInt(sizeof(slong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true); success = true; break; case e_ulong: - m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8); + m_integer = llvm::APInt(sizeof(ulong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false); success = true; break; case e_slonglong: - m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8); + m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true); success = true; break; case e_ulonglong: - m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8); + m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false); success = true; break; case e_sint128: - m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128); - success = true; - break; - case e_uint128: - m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128); + m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData())); success = true; break; case e_sint256: - m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256); - success = true; - break; - case e_uint256: - m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256); + m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData())); success = true; break; @@ -565,42 +598,34 @@ Scalar::Promote(Scalar::Type type) case e_sint: break; case e_uint: success = true; break; case e_slong: - m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8); + m_integer = llvm::APInt(sizeof(slong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true); success = true; break; case e_ulong: - m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8); + m_integer = llvm::APInt(sizeof(ulong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false); success = true; break; case e_slonglong: - m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8); + m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true); success = true; break; case e_ulonglong: - m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8); + m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false); success = true; break; case e_sint128: - m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128); - success = true; - break; - case e_uint128: - m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128); + m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData())); success = true; break; case e_sint256: - m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256); - success = true; - break; - case e_uint256: - m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256); + m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData())); success = true; break; @@ -632,37 +657,29 @@ Scalar::Promote(Scalar::Type type) case e_uint: break; case e_slong: success = true; break; case e_ulong: - m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8); + m_integer = llvm::APInt(sizeof(ulong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false); success = true; break; case e_slonglong: - m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8); + m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true); success = true; break; case e_ulonglong: - m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8); + m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false); success = true; break; case e_sint128: - m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128); - success = true; - break; - case e_uint128: - m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128); + m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData())); success = true; break; case e_sint256: - m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256); - success = true; - break; - case e_uint256: - m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256); + m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData())); success = true; break; @@ -695,32 +712,24 @@ Scalar::Promote(Scalar::Type type) case e_slong: break; case e_ulong: success = true; break; case e_slonglong: - m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8); + m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true); success = true; break; case e_ulonglong: - m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8); + m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false); success = true; break; case e_sint128: - m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128); - success = true; - break; - case e_uint128: - m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128); + m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData())); success = true; break; case e_sint256: - m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256); - success = true; - break; - case e_uint256: - m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256); + m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData())); success = true; break; @@ -754,27 +763,19 @@ Scalar::Promote(Scalar::Type type) case e_ulong: break; case e_slonglong: success = true; break; case e_ulonglong: - m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8); + m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false); success = true; break; case e_sint128: - m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128); - success = true; - break; - case e_uint128: - m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128); + m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData())); success = true; break; case e_sint256: - m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256); - success = true; - break; - case e_uint256: - m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256); + m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData())); success = true; break; @@ -809,22 +810,14 @@ Scalar::Promote(Scalar::Type type) case e_slonglong: break; case e_ulonglong: success = true; break; case e_sint128: - m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128); - success = true; - break; - case e_uint128: - m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128); + m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData())); success = true; break; case e_sint256: - m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256); - success = true; - break; - case e_uint256: - m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256); + m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData())); success = true; break; @@ -860,17 +853,13 @@ Scalar::Promote(Scalar::Type type) case e_ulonglong: break; case e_sint128: success = true; break; case e_uint128: - m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128); + m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData())); success = true; break; case e_sint256: - m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256); - success = true; - break; - case e_uint256: - m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256); + m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData())); success = true; break; @@ -907,12 +896,8 @@ Scalar::Promote(Scalar::Type type) case e_sint128: break; case e_uint128: success = true; break; case e_sint256: - m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256); - success = true; - break; - case e_uint256: - m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256); + m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData())); success = true; break; @@ -950,7 +935,7 @@ Scalar::Promote(Scalar::Type type) case e_uint128: break; case e_sint256: success = true; break; case e_uint256: - m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256); + m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData())); success = true; break; @@ -1384,35 +1369,9 @@ Scalar::MakeSigned () case e_slonglong: success = true; break; case e_ulonglong: m_type = e_slonglong; success = true; break; case e_sint128: success = true; break; - case e_uint128: m_type = e_sint128; success = true; break; + case e_uint128: m_type = e_sint; success = true; break; case e_sint256: success = true; break; - case e_uint256: m_type = e_sint256; success = true; break; - case e_float: success = true; break; - case e_double: success = true; break; - case e_long_double: success = true; break; - } - - return success; -} - -bool -Scalar::MakeUnsigned () -{ - bool success = false; - - switch (m_type) - { - case e_void: break; - case e_sint: success = true; break; - case e_uint: m_type = e_uint; success = true; break; - case e_slong: success = true; break; - case e_ulong: m_type = e_ulong; success = true; break; - case e_slonglong: success = true; break; - case e_ulonglong: m_type = e_ulonglong; success = true; break; - case e_sint128: success = true; break; - case e_uint128: m_type = e_uint128; success = true; break; - case e_sint256: success = true; break; - case e_uint256: m_type = e_uint256; success = true; break; + case e_uint256: m_type = e_sint; success = true; break; case e_float: success = true; break; case e_double: success = true; break; case e_long_double: success = true; break; @@ -1421,7 +1380,7 @@ Scalar::MakeUnsigned () return success; } -signed char +char Scalar::SChar(char fail_value) const { switch (m_type) @@ -1437,14 +1396,14 @@ Scalar::SChar(char fail_value) const case e_uint128: case e_sint256: case e_uint256: - return (schar_t)(m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue(); + return *(const schar_t *)(m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getRawData(); case e_float: return (schar_t)m_float.convertToFloat(); case e_double: return (schar_t)m_float.convertToDouble(); case e_long_double: llvm::APInt ldbl_val = m_float.bitcastToAPInt(); - return (schar_t)(ldbl_val.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue(); + return (schar_t)*ldbl_val.getRawData(); } return fail_value; } @@ -1465,14 +1424,14 @@ Scalar::UChar(unsigned char fail_value) const case e_uint128: case e_sint256: case e_uint256: - return (uchar_t)(m_integer.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue(); + return *(const uchar_t *)m_integer.getRawData(); case e_float: return (uchar_t)m_float.convertToFloat(); case e_double: return (uchar_t)m_float.convertToDouble(); case e_long_double: llvm::APInt ldbl_val = m_float.bitcastToAPInt(); - return (uchar_t)(ldbl_val.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue(); + return (uchar_t)*ldbl_val.getRawData(); } return fail_value; } @@ -1493,14 +1452,14 @@ Scalar::SShort(short fail_value) const case e_uint128: case e_sint256: case e_uint256: - return (sshort_t)(m_integer.sextOrTrunc(sizeof(sshort_t) * 8)).getSExtValue(); + return *(const sshort_t *)(m_integer.sextOrTrunc(sizeof(sshort_t) * 8)).getRawData(); case e_float: return (sshort_t)m_float.convertToFloat(); case e_double: return (sshort_t)m_float.convertToDouble(); case e_long_double: llvm::APInt ldbl_val = m_float.bitcastToAPInt(); - return (sshort_t)(ldbl_val.sextOrTrunc(sizeof(sshort_t) * 8)).getSExtValue(); + return *(const sshort_t *)ldbl_val.getRawData(); } return fail_value; } @@ -1521,14 +1480,14 @@ Scalar::UShort(unsigned short fail_value) const case e_uint128: case e_sint256: case e_uint256: - return (ushort_t)(m_integer.zextOrTrunc(sizeof(ushort_t) * 8)).getZExtValue(); + return *(const ushort_t *)m_integer.getRawData(); case e_float: return (ushort_t)m_float.convertToFloat(); case e_double: return (ushort_t)m_float.convertToDouble(); case e_long_double: llvm::APInt ldbl_val = m_float.bitcastToAPInt(); - return (ushort_t)(ldbl_val.zextOrTrunc(sizeof(ushort_t) * 8)).getZExtValue(); + return *(const ushort_t *)ldbl_val.getRawData();; } return fail_value; } @@ -1549,14 +1508,14 @@ Scalar::SInt(int fail_value) const case e_uint128: case e_sint256: case e_uint256: - return (sint_t)(m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue(); + return *(const sint_t *)(m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getRawData(); case e_float: return (sint_t)m_float.convertToFloat(); case e_double: return (sint_t)m_float.convertToDouble(); case e_long_double: llvm::APInt ldbl_val = m_float.bitcastToAPInt(); - return (sint_t)(ldbl_val.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue(); + return *(const sint_t *)ldbl_val.getRawData(); } return fail_value; } @@ -1577,14 +1536,14 @@ Scalar::UInt(unsigned int fail_value) const case e_uint128: case e_sint256: case e_uint256: - return (uint_t)(m_integer.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue(); + return *(const uint_t *)m_integer.getRawData(); case e_float: return (uint_t)m_float.convertToFloat(); case e_double: return (uint_t)m_float.convertToDouble(); case e_long_double: llvm::APInt ldbl_val = m_float.bitcastToAPInt(); - return (uint_t)(ldbl_val.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue(); + return *(const uint_t *)ldbl_val.getRawData(); } return fail_value; } @@ -1605,14 +1564,14 @@ Scalar::SLong(long fail_value) const case e_uint128: case e_sint256: case e_uint256: - return (slong_t)(m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue(); + return *(const slong_t *)(m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getRawData(); case e_float: return (slong_t)m_float.convertToFloat(); case e_double: return (slong_t)m_float.convertToDouble(); case e_long_double: llvm::APInt ldbl_val = m_float.bitcastToAPInt(); - return (slong_t)(ldbl_val.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue(); + return *(const slong_t *)ldbl_val.getRawData(); } return fail_value; } @@ -1633,14 +1592,44 @@ Scalar::ULong(unsigned long fail_value) const case e_uint128: case e_sint256: case e_uint256: - return (ulong_t)(m_integer.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue(); + return *(const ulong_t *)m_integer.getRawData(); case e_float: return (ulong_t)m_float.convertToFloat(); case e_double: return (ulong_t)m_float.convertToDouble(); case e_long_double: llvm::APInt ldbl_val = m_float.bitcastToAPInt(); - return (ulong_t)(ldbl_val.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue(); + return *(const ulong_t *)ldbl_val.getRawData(); + } + return fail_value; +} + +uint64_t +Scalar::GetRawBits64(uint64_t fail_value) const +{ + switch (m_type) + { + case e_void: + break; + + case e_sint: + case e_uint: + case e_slong: + case e_ulong: + case e_slonglong: + case e_ulonglong: + case e_sint128: + case e_uint128: + case e_sint256: + case e_uint256: + return *m_integer.getRawData(); + case e_float: + return (uint64_t)m_float.convertToFloat(); + case e_double: + return (uint64_t)m_float.convertToDouble(); + case e_long_double: + llvm::APInt ldbl_val = m_float.bitcastToAPInt(); + return *ldbl_val.getRawData(); } return fail_value; } @@ -1661,14 +1650,14 @@ Scalar::SLongLong(long long fail_value) const case e_uint128: case e_sint256: case e_uint256: - return (slonglong_t)(m_integer.sextOrTrunc(sizeof(slonglong_t) * 8)).getSExtValue(); + return *(const slonglong_t *)(m_integer.sextOrTrunc(sizeof(slonglong_t) * 8)).getRawData(); case e_float: return (slonglong_t)m_float.convertToFloat(); case e_double: return (slonglong_t)m_float.convertToDouble(); case e_long_double: llvm::APInt ldbl_val = m_float.bitcastToAPInt(); - return (slonglong_t)(ldbl_val.sextOrTrunc(sizeof(slonglong_t) * 8)).getSExtValue(); + return *(const slonglong_t *)ldbl_val.getRawData(); } return fail_value; } @@ -1689,14 +1678,14 @@ Scalar::ULongLong(unsigned long long fail_value) const case e_uint128: case e_sint256: case e_uint256: - return (ulonglong_t)(m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue(); + return *(const ulonglong_t *)m_integer.getRawData(); case e_float: return (ulonglong_t)m_float.convertToFloat(); case e_double: return (ulonglong_t)m_float.convertToDouble(); case e_long_double: llvm::APInt ldbl_val = m_float.bitcastToAPInt(); - return (ulonglong_t)(ldbl_val.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue(); + return *(const ulonglong_t *)ldbl_val.getRawData(); } return fail_value; } @@ -1959,7 +1948,7 @@ Scalar::operator<<= (const Scalar& rhs) case e_uint128: case e_sint256: case e_uint256: - m_integer = m_integer << rhs.m_integer; + m_integer <<= *rhs.m_integer.getRawData(); break; } break; @@ -2007,8 +1996,7 @@ Scalar::ShiftRightLogical(const Scalar& rhs) case e_uint128: case e_sint256: case e_uint256: - m_integer = m_integer.lshr(rhs.m_integer); - break; + m_integer = m_integer.lshr(*(const uint_t *) rhs.m_integer.getRawData()); break; } break; } @@ -2055,7 +2043,7 @@ Scalar::operator>>= (const Scalar& rhs) case e_uint128: case e_sint256: case e_uint256: - m_integer = m_integer.ashr(rhs.m_integer); + m_integer = m_integer.ashr(*(const uint_t *)rhs.m_integer.getRawData()); break; } break; @@ -2270,24 +2258,18 @@ lldb_private::operator/ (const Scalar& lhs, const Scalar& rhs) { case Scalar::e_void: break; case Scalar::e_sint: - case Scalar::e_slong: - case Scalar::e_slonglong: - case Scalar::e_sint128: - case Scalar::e_sint256: - if (b->m_integer != 0) - { - result.m_integer = a->m_integer.sdiv(b->m_integer); - return result; - } - break; case Scalar::e_uint: + case Scalar::e_slong: case Scalar::e_ulong: + case Scalar::e_slonglong: case Scalar::e_ulonglong: + case Scalar::e_sint128: case Scalar::e_uint128: + case Scalar::e_sint256: case Scalar::e_uint256: if (b->m_integer != 0) { - result.m_integer = a->m_integer.udiv(b->m_integer); + result.m_integer = *a->m_integer.getRawData() / *b->m_integer.getRawData(); return result; } break; @@ -2423,23 +2405,18 @@ lldb_private::operator% (const Scalar& lhs, const Scalar& rhs) default: break; case Scalar::e_void: break; case Scalar::e_sint: - case Scalar::e_slong: - case Scalar::e_slonglong: - case Scalar::e_sint128: - case Scalar::e_sint256: - if (b->m_integer != 0) - { - result.m_integer = a->m_integer.srem(b->m_integer); - return result; - } case Scalar::e_uint: + case Scalar::e_slong: case Scalar::e_ulong: + case Scalar::e_slonglong: case Scalar::e_ulonglong: + case Scalar::e_sint128: case Scalar::e_uint128: + case Scalar::e_sint256: case Scalar::e_uint256: if (b->m_integer != 0) { - result.m_integer = a->m_integer.urem(b->m_integer); + result.m_integer = *a->m_integer.getRawData() % *b->m_integer.getRawData(); return result; } break; @@ -2500,6 +2477,27 @@ lldb_private::operator>> (const Scalar& lhs, const Scalar &rhs) return result; } +// Return the raw unsigned integer without any casting or conversion +unsigned int +Scalar::RawUInt () const +{ + return *(const uint_t *) m_integer.getRawData(); +} + +// Return the raw unsigned long without any casting or conversion +unsigned long +Scalar::RawULong () const +{ + return *(const ulong_t *) m_integer.getRawData(); +} + +// Return the raw unsigned long long without any casting or conversion +unsigned long long +Scalar::RawULongLong () const +{ + return *(const ulonglong_t *) m_integer.getRawData(); +} + Error Scalar::SetValueFromCString (const char *value_str, Encoding encoding, size_t byte_size) { @@ -2654,12 +2652,12 @@ Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t b if (data.GetByteOrder() == eByteOrderBig) { int128.x[1] = (uint64_t)data.GetU64 (&offset); - int128.x[0] = (uint64_t)data.GetU64 (&offset); + int128.x[0] = (uint64_t)data.GetU64 (&offset + 1); } else { int128.x[0] = (uint64_t)data.GetU64 (&offset); - int128.x[1] = (uint64_t)data.GetU64 (&offset); + int128.x[1] = (uint64_t)data.GetU64 (&offset + 1); } operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x)); break; @@ -2667,16 +2665,16 @@ Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t b if (data.GetByteOrder() == eByteOrderBig) { int256.x[3] = (uint64_t)data.GetU64 (&offset); - int256.x[2] = (uint64_t)data.GetU64 (&offset); - int256.x[1] = (uint64_t)data.GetU64 (&offset); - int256.x[0] = (uint64_t)data.GetU64 (&offset); + int256.x[2] = (uint64_t)data.GetU64 (&offset + 1); + int256.x[1] = (uint64_t)data.GetU64 (&offset + 1); + int256.x[0] = (uint64_t)data.GetU64 (&offset + 1); } else { int256.x[0] = (uint64_t)data.GetU64 (&offset); - int256.x[1] = (uint64_t)data.GetU64 (&offset); - int256.x[2] = (uint64_t)data.GetU64 (&offset); - int256.x[3] = (uint64_t)data.GetU64 (&offset); + int256.x[1] = (uint64_t)data.GetU64 (&offset + 1); + int256.x[2] = (uint64_t)data.GetU64 (&offset + 1); + int256.x[3] = (uint64_t)data.GetU64 (&offset + 1); } operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x)); break; @@ -2700,12 +2698,12 @@ Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t b if (data.GetByteOrder() == eByteOrderBig) { int128.x[1] = (uint64_t)data.GetU64 (&offset); - int128.x[0] = (uint64_t)data.GetU64 (&offset); + int128.x[0] = (uint64_t)data.GetU64 (&offset + 1); } else { int128.x[0] = (uint64_t)data.GetU64 (&offset); - int128.x[1] = (uint64_t)data.GetU64 (&offset); + int128.x[1] = (uint64_t)data.GetU64 (&offset + 1); } operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x)); break; @@ -2713,16 +2711,16 @@ Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t b if (data.GetByteOrder() == eByteOrderBig) { int256.x[3] = (uint64_t)data.GetU64 (&offset); - int256.x[2] = (uint64_t)data.GetU64 (&offset); - int256.x[1] = (uint64_t)data.GetU64 (&offset); - int256.x[0] = (uint64_t)data.GetU64 (&offset); + int256.x[2] = (uint64_t)data.GetU64 (&offset + 1); + int256.x[1] = (uint64_t)data.GetU64 (&offset + 1); + int256.x[0] = (uint64_t)data.GetU64 (&offset + 1); } else { int256.x[0] = (uint64_t)data.GetU64 (&offset); - int256.x[1] = (uint64_t)data.GetU64 (&offset); - int256.x[2] = (uint64_t)data.GetU64 (&offset); - int256.x[3] = (uint64_t)data.GetU64 (&offset); + int256.x[1] = (uint64_t)data.GetU64 (&offset + 1); + int256.x[2] = (uint64_t)data.GetU64 (&offset + 1); + int256.x[3] = (uint64_t)data.GetU64 (&offset + 1); } operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x)); break; @@ -2830,20 +2828,37 @@ Scalar::ExtractBitfield (uint32_t bit_size, if (bit_size == 0) return true; + uint32_t msbit = bit_offset + bit_size - 1; + uint32_t lsbit = bit_offset; + uint64_t result; switch (m_type) { case Scalar::e_void: - case Scalar::e_float: - case Scalar::e_double: - case Scalar::e_long_double: break; + case e_float: + result = SignedBits ((uint64_t )m_float.convertToFloat(), msbit, lsbit); + m_float = llvm::APFloat((float_t)result); + return true; + case e_double: + result = SignedBits ((uint64_t )m_float.convertToDouble(), msbit, lsbit); + m_float = llvm::APFloat((double_t)result); + return true; + case e_long_double: + m_integer = m_float.bitcastToAPInt(); + result = SignedBits (*m_integer.getRawData(), msbit, lsbit); + if(m_ieee_quad) + m_float = llvm::APFloat(llvm::APFloat::IEEEquad, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&result)->x)); + else + m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&result)->x)); + return true; + case Scalar::e_sint: case Scalar::e_slong: case Scalar::e_slonglong: case Scalar::e_sint128: case Scalar::e_sint256: - m_integer = m_integer.ashr(bit_offset).trunc(bit_size).sext(8 * GetByteSize()); + m_integer = SignedBits (*m_integer.getRawData(), msbit, lsbit); return true; case Scalar::e_uint: @@ -2851,7 +2866,7 @@ Scalar::ExtractBitfield (uint32_t bit_size, case Scalar::e_ulonglong: case Scalar::e_uint128: case Scalar::e_uint256: - m_integer = m_integer.lshr(bit_offset).trunc(bit_size).zext(8 * GetByteSize()); + m_integer = UnsignedBits (*m_integer.getRawData(), msbit, lsbit); return true; } return false; diff --git a/lldb/source/Expression/IRInterpreter.cpp b/lldb/source/Expression/IRInterpreter.cpp index 2871a066013a..a0d7a163a92b 100644 --- a/lldb/source/Expression/IRInterpreter.cpp +++ b/lldb/source/Expression/IRInterpreter.cpp @@ -231,7 +231,7 @@ public: lldb_private::Scalar cast_scalar; - if (!AssignToMatchType(cast_scalar, scalar.ULongLong(), value->getType())) + if (!AssignToMatchType(cast_scalar, scalar.GetRawBits64(0), value->getType())) return false; size_t value_byte_size = m_target_data.getTypeStoreSize(value->getType()); @@ -373,18 +373,19 @@ public: if (!ResolveConstantValue(resolved_value, constant)) return false; + lldb_private::StreamString buffer (lldb_private::Stream::eBinary, + m_execution_unit.GetAddressByteSize(), + m_execution_unit.GetByteOrder()); + size_t constant_size = m_target_data.getTypeStoreSize(constant->getType()); - lldb_private::DataBufferHeap buf(constant_size, 0); - lldb_private::Error get_data_error; + const uint64_t *raw_data = resolved_value.getRawData(); - lldb_private::Scalar resolved_scalar(resolved_value.zextOrTrunc(llvm::NextPowerOf2(constant_size) * 8)); - if (!resolved_scalar.GetAsMemoryData(buf.GetBytes(), buf.GetByteSize(), m_byte_order, get_data_error)) - return false; + buffer.PutRawBytes(raw_data, constant_size, lldb_private::endian::InlHostByteOrder()); lldb_private::Error write_error; - m_execution_unit.WriteMemory(process_address, buf.GetBytes(), buf.GetByteSize(), write_error); + m_execution_unit.WriteMemory(process_address, (const uint8_t*)buffer.GetData(), constant_size, write_error); return write_error.Success(); } @@ -818,9 +819,7 @@ IRInterpreter::Interpret (llvm::Module &module, result = L / R; break; case Instruction::UDiv: - L.MakeUnsigned(); - R.MakeUnsigned(); - result = L / R; + result = L.GetRawBits64(0) / R.GetRawBits64(1); break; case Instruction::SRem: L.MakeSigned(); @@ -828,9 +827,7 @@ IRInterpreter::Interpret (llvm::Module &module, result = L % R; break; case Instruction::URem: - L.MakeUnsigned(); - R.MakeUnsigned(); - result = L % R; + result = L.GetRawBits64(0) % R.GetRawBits64(1); break; case Instruction::Shl: result = L << R; @@ -1033,7 +1030,7 @@ IRInterpreter::Interpret (llvm::Module &module, return false; } - if (!C.IsZero()) + if (C.GetRawBits64(0)) frame.Jump(br_inst->getSuccessor(0)); else frame.Jump(br_inst->getSuccessor(1)); @@ -1184,24 +1181,16 @@ IRInterpreter::Interpret (llvm::Module &module, result = (L != R); break; case CmpInst::ICMP_UGT: - L.MakeUnsigned(); - R.MakeUnsigned(); - result = (L > R); + result = (L.GetRawBits64(0) > R.GetRawBits64(0)); break; case CmpInst::ICMP_UGE: - L.MakeUnsigned(); - R.MakeUnsigned(); - result = (L >= R); + result = (L.GetRawBits64(0) >= R.GetRawBits64(0)); break; case CmpInst::ICMP_ULT: - L.MakeUnsigned(); - R.MakeUnsigned(); - result = (L < R); + result = (L.GetRawBits64(0) < R.GetRawBits64(0)); break; case CmpInst::ICMP_ULE: - L.MakeUnsigned(); - R.MakeUnsigned(); - result = (L <= R); + result = (L.GetRawBits64(0) <= R.GetRawBits64(0)); break; case CmpInst::ICMP_SGT: L.MakeSigned(); diff --git a/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp b/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp index 12ba7e3c2ac0..62aa5b7fb886 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp +++ b/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp @@ -1105,13 +1105,7 @@ IRForTarget::MaterializeInitializer (uint8_t *data, Constant *initializer) if (ConstantInt *int_initializer = dyn_cast(initializer)) { - size_t constant_size = m_target_data->getTypeStoreSize(initializer_type); - lldb_private::Scalar scalar = int_initializer->getValue().zextOrTrunc(llvm::NextPowerOf2(constant_size) * 8); - - lldb_private::Error get_data_error; - if (!scalar.GetAsMemoryData(data, constant_size, lldb_private::endian::InlHostByteOrder(), get_data_error)) - return false; - + memcpy (data, int_initializer->getValue().getRawData(), m_target_data->getTypeStoreSize(initializer_type)); return true; } else if (ConstantDataArray *array_initializer = dyn_cast(initializer)) diff --git a/lldb/source/Symbol/ClangASTContext.cpp b/lldb/source/Symbol/ClangASTContext.cpp index 603beb982153..7a62f82532be 100644 --- a/lldb/source/Symbol/ClangASTContext.cpp +++ b/lldb/source/Symbol/ClangASTContext.cpp @@ -72,7 +72,6 @@ #include "lldb/Core/Module.h" #include "lldb/Core/PluginManager.h" #include "lldb/Core/RegularExpression.h" -#include "lldb/Core/Scalar.h" #include "lldb/Core/StreamFile.h" #include "lldb/Core/ThreadSafeDenseMap.h" #include "lldb/Core/UniqueCStringMap.h" @@ -8647,10 +8646,18 @@ ClangASTContext::ConvertStringToFloatValue (lldb::opaque_compiler_type_t type, c const uint64_t byte_size = bit_size / 8; if (dst_size >= byte_size) { - Scalar scalar = ap_float.bitcastToAPInt().zextOrTrunc(llvm::NextPowerOf2(byte_size) * 8); - lldb_private::Error get_data_error; - if (scalar.GetAsMemoryData(dst, byte_size, lldb_private::endian::InlHostByteOrder(), get_data_error)) + if (bit_size == sizeof(float)*8) + { + float float32 = ap_float.convertToFloat(); + ::memcpy (dst, &float32, byte_size); return byte_size; + } + else if (bit_size >= 64) + { + llvm::APInt ap_int(ap_float.bitcastToAPInt()); + ::memcpy (dst, ap_int.getRawData(), byte_size); + return byte_size; + } } } } diff --git a/lldb/unittests/Core/ScalarTest.cpp b/lldb/unittests/Core/ScalarTest.cpp index 2a5643fee1ab..63c0daa424e5 100644 --- a/lldb/unittests/Core/ScalarTest.cpp +++ b/lldb/unittests/Core/ScalarTest.cpp @@ -15,10 +15,7 @@ #include "gtest/gtest.h" -#include "lldb/Core/Error.h" #include "lldb/Core/Scalar.h" -#include "lldb/Core/DataExtractor.h" -#include "lldb/Host/Endian.h" using namespace lldb_private; @@ -33,49 +30,3 @@ TEST(ScalarTest, RightShiftOperator) ASSERT_EQ(a >> c, a_scalar >> c_scalar); ASSERT_EQ(b >> c, b_scalar >> c_scalar); } - -TEST(ScalarTest, GetBytes) -{ - int a = 0x01020304; - long long b = 0x0102030405060708LL; - float c = 1234567.89e42; - double d = 1234567.89e42; - char e[16] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; - char f[32] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32 }; - Scalar a_scalar(a); - Scalar b_scalar(b); - Scalar c_scalar(c); - Scalar d_scalar(d); - Scalar e_scalar; - Scalar f_scalar; - DataExtractor e_data(e, sizeof(e), endian::InlHostByteOrder(), sizeof(void *)); - Error e_error = e_scalar.SetValueFromData(e_data, lldb::eEncodingUint, sizeof(e)); - DataExtractor f_data(f, sizeof(f), endian::InlHostByteOrder(), sizeof(void *)); - Error f_error = f_scalar.SetValueFromData(f_data, lldb::eEncodingUint, sizeof(f)); - ASSERT_EQ(0, memcmp(&a, a_scalar.GetBytes(), sizeof(a))); - ASSERT_EQ(0, memcmp(&b, b_scalar.GetBytes(), sizeof(b))); - ASSERT_EQ(0, memcmp(&c, c_scalar.GetBytes(), sizeof(c))); - ASSERT_EQ(0, memcmp(&d, d_scalar.GetBytes(), sizeof(d))); - ASSERT_EQ(0, e_error.Fail()); - ASSERT_EQ(0, memcmp(e, e_scalar.GetBytes(), sizeof(e))); - ASSERT_EQ(0, f_error.Fail()); - ASSERT_EQ(0, memcmp(f, f_scalar.GetBytes(), sizeof(f))); -} - -TEST(ScalarTest, CastOperations) -{ - long long a = 0xf1f2f3f4f5f6f7f8LL; - Scalar a_scalar(a); - ASSERT_EQ((signed char)a, a_scalar.SChar()); - ASSERT_EQ((unsigned char)a, a_scalar.UChar()); - ASSERT_EQ((signed short)a, a_scalar.SShort()); - ASSERT_EQ((unsigned short)a, a_scalar.UShort()); - ASSERT_EQ((signed int)a, a_scalar.SInt()); - ASSERT_EQ((unsigned int)a, a_scalar.UInt()); - ASSERT_EQ((signed long)a, a_scalar.SLong()); - ASSERT_EQ((unsigned long)a, a_scalar.ULong()); - ASSERT_EQ((signed long long)a, a_scalar.SLongLong()); - ASSERT_EQ((unsigned long long)a, a_scalar.ULongLong()); -} -