From 9dcdd2ee0370dd8d43b0a668a11721038aeaf2d4 Mon Sep 17 00:00:00 2001 From: Oleksiy Vyalov Date: Mon, 10 Aug 2015 21:49:50 +0000 Subject: [PATCH] Revert r244308 since it's introducing test regressions on Linux: - TestLldbGdbServer.py both clang & gcc, i386 and x86_64 - TestConstVariables.py gcc, i386 and x86_64 - 112 failures clang, i386 llvm-svn: 244514 --- lldb/include/lldb/Core/RegisterValue.h | 103 +- lldb/include/lldb/Core/Scalar.h | 144 +- lldb/include/lldb/Core/Value.h | 7 +- lldb/include/lldb/lldb-private-types.h | 2 - lldb/source/Core/RegisterValue.cpp | 578 ++-- lldb/source/Core/Scalar.cpp | 3270 ++++++-------------- lldb/source/Core/ValueObject.cpp | 2 +- .../Instruction/MIPS/EmulateInstructionMIPS.cpp | 66 +- .../MIPS64/EmulateInstructionMIPS64.cpp | 66 +- .../Process/Linux/NativeRegisterContextLinux.cpp | 4 +- .../Linux/NativeRegisterContextLinux_mips64.cpp | 366 +-- .../Linux/NativeRegisterContextLinux_mips64.h | 31 +- .../Utility/RegisterContextFreeBSD_mips64.cpp | 4 +- .../Process/Utility/RegisterContextLinux_mips.cpp | 58 +- .../Process/Utility/RegisterContextLinux_mips.h | 3 - .../Utility/RegisterContextLinux_mips64.cpp | 84 +- .../Process/Utility/RegisterContextLinux_mips64.h | 4 - .../Process/Utility/RegisterContextPOSIX_mips64.h | 4 +- ...sterContext_mips.h => RegisterContext_mips64.h} | 302 +- .../Plugins/Process/Utility/RegisterInfos_mips.h | 141 +- .../Plugins/Process/Utility/RegisterInfos_mips64.h | 201 +- .../Utility/lldb-mips-freebsd-register-enums.h | 70 - ...gister-enums.h => lldb-mips64-register-enums.h} | 118 +- 23 files changed, 1779 insertions(+), 3849 deletions(-) rename lldb/source/Plugins/Process/Utility/{RegisterContext_mips.h => RegisterContext_mips64.h} (54%) delete mode 100644 lldb/source/Plugins/Process/Utility/lldb-mips-freebsd-register-enums.h rename lldb/source/Plugins/Process/Utility/{lldb-mips-linux-register-enums.h => lldb-mips64-register-enums.h} (63%) diff --git a/lldb/include/lldb/Core/RegisterValue.h b/lldb/include/lldb/Core/RegisterValue.h index 1ce4e42..1b1a71a 100644 --- a/lldb/include/lldb/Core/RegisterValue.h +++ b/lldb/include/lldb/Core/RegisterValue.h @@ -19,9 +19,8 @@ #include "lldb/lldb-public.h" #include "lldb/lldb-private.h" #include "lldb/Host/Endian.h" -#include "llvm/ADT/APInt.h" -#include "lldb/Core/Scalar.h" +//#define ENABLE_128_BIT_SUPPORT 1 namespace lldb_private { class RegisterValue @@ -38,7 +37,9 @@ namespace lldb_private { eTypeUInt16, eTypeUInt32, eTypeUInt64, +#if defined (ENABLE_128_BIT_SUPPORT) eTypeUInt128, +#endif eTypeFloat, eTypeDouble, eTypeLongDouble, @@ -48,62 +49,63 @@ namespace lldb_private { RegisterValue () : m_type (eTypeInvalid) { - m_scalar = (unsigned long)0; } explicit RegisterValue (uint8_t inst) : m_type (eTypeUInt8) { - m_scalar = inst; + m_data.uint8 = inst; } explicit RegisterValue (uint16_t inst) : m_type (eTypeUInt16) { - m_scalar = inst; + m_data.uint16 = inst; } explicit RegisterValue (uint32_t inst) : m_type (eTypeUInt32) { - m_scalar = inst; + m_data.uint32 = inst; } explicit RegisterValue (uint64_t inst) : m_type (eTypeUInt64) { - m_scalar = inst; + m_data.uint64 = inst; } +#if defined (ENABLE_128_BIT_SUPPORT) explicit - RegisterValue (llvm::APInt inst) : + RegisterValue (__uint128_t inst) : m_type (eTypeUInt128) { - m_scalar = llvm::APInt(inst); + m_data.uint128 = inst; } +#endif explicit RegisterValue (float value) : m_type (eTypeFloat) { - m_scalar = value; + m_data.ieee_float = value; } explicit RegisterValue (double value) : m_type (eTypeDouble) { - m_scalar = value; + m_data.ieee_double = value; } explicit RegisterValue (long double value) : m_type (eTypeLongDouble) { - m_scalar = value; + m_data.ieee_long_double = value; } explicit @@ -165,7 +167,7 @@ namespace lldb_private { { if (success_ptr) *success_ptr = true; - return m_scalar.UChar(fail_value); + return m_data.uint8; } if (success_ptr) *success_ptr = true; @@ -181,8 +183,10 @@ namespace lldb_private { uint64_t GetAsUInt64 (uint64_t fail_value = UINT64_MAX, bool *success_ptr = NULL) const; - llvm::APInt - GetAsUInt128 (llvm::APInt& fail_value, bool *success_ptr = NULL) const; +#if defined (ENABLE_128_BIT_SUPPORT) + __uint128_t + GetAsUInt128 (__uint128_t fail_value = ~((__uint128_t)0), bool *success_ptr = NULL) const; +#endif float GetAsFloat (float fail_value = 0.0f, bool *success_ptr = NULL) const; @@ -215,92 +219,95 @@ namespace lldb_private { operator = (uint8_t uint) { m_type = eTypeUInt8; - m_scalar = uint; + m_data.uint8 = uint; } void operator = (uint16_t uint) { m_type = eTypeUInt16; - m_scalar = uint; + m_data.uint16 = uint; } void operator = (uint32_t uint) { m_type = eTypeUInt32; - m_scalar = uint; + m_data.uint32 = uint; } void operator = (uint64_t uint) { m_type = eTypeUInt64; - m_scalar = uint; + m_data.uint64 = uint; } +#if defined (ENABLE_128_BIT_SUPPORT) void - operator = (llvm::APInt uint) + operator = (__uint128_t uint) { m_type = eTypeUInt128; - m_scalar = llvm::APInt(uint); + m_data.uint128 = uint; } - +#endif void operator = (float f) { m_type = eTypeFloat; - m_scalar = f; + m_data.ieee_float = f; } void operator = (double f) { m_type = eTypeDouble; - m_scalar = f; + m_data.ieee_double = f; } void operator = (long double f) { m_type = eTypeLongDouble; - m_scalar = f; + m_data.ieee_long_double = f; } void SetUInt8 (uint8_t uint) { m_type = eTypeUInt8; - m_scalar = uint; + m_data.uint8 = uint; } void SetUInt16 (uint16_t uint) { m_type = eTypeUInt16; - m_scalar = uint; + m_data.uint16 = uint; } void SetUInt32 (uint32_t uint, Type t = eTypeUInt32) { m_type = t; - m_scalar = uint; + m_data.uint32 = uint; } void SetUInt64 (uint64_t uint, Type t = eTypeUInt64) { m_type = t; - m_scalar = uint; + m_data.uint64 = uint; } +#if defined (ENABLE_128_BIT_SUPPORT) void - SetUInt128 (llvm::APInt uint) + SetUInt128 (__uint128_t uint) { m_type = eTypeUInt128; - m_scalar = llvm::APInt(uint); + m_data.uint128 = uint; } +#endif bool SetUInt (uint64_t uint, uint32_t byte_size); @@ -308,21 +315,21 @@ namespace lldb_private { SetFloat (float f) { m_type = eTypeFloat; - m_scalar = f; + m_data.ieee_float = f; } void SetDouble (double f) { m_type = eTypeDouble; - m_scalar = f; + m_data.ieee_double = f; } void SetLongDouble (long double f) { m_type = eTypeLongDouble; - m_scalar = f; + m_data.ieee_long_double = f; } void @@ -360,7 +367,7 @@ namespace lldb_private { GetByteOrder () const { if (m_type == eTypeBytes) - return buffer.byte_order; + return m_data.buffer.byte_order; return lldb::endian::InlHostByteOrder(); } @@ -379,13 +386,25 @@ namespace lldb_private { protected: RegisterValue::Type m_type; - Scalar m_scalar; - struct - { - uint8_t bytes[kMaxRegisterByteSize]; // This must be big enough to hold any register for any supported target. - uint8_t length; - lldb::ByteOrder byte_order; - } buffer; + union + { + uint8_t uint8; + uint16_t uint16; + uint32_t uint32; + uint64_t uint64; +#if defined (ENABLE_128_BIT_SUPPORT) + __uint128_t uint128; +#endif + float ieee_float; + double ieee_double; + long double ieee_long_double; + struct + { + uint8_t bytes[kMaxRegisterByteSize]; // This must be big enough to hold any register for any supported target. + uint8_t length; + lldb::ByteOrder byte_order; + } buffer; + } m_data; }; } // namespace lldb_private diff --git a/lldb/include/lldb/Core/Scalar.h b/lldb/include/lldb/Core/Scalar.h index 9b340ea..821a0fb 100644 --- a/lldb/include/lldb/Core/Scalar.h +++ b/lldb/include/lldb/Core/Scalar.h @@ -11,11 +11,6 @@ #define liblldb_Scalar_h_ #include "lldb/lldb-private.h" -#include "llvm/ADT/APInt.h" -#include "llvm/ADT/APFloat.h" - -#define NUM_OF_WORDS_INT128 2 -#define BITWIDTH_INT128 128 namespace lldb_private { @@ -31,10 +26,6 @@ public: enum Type { e_void = 0, - e_schar, - e_uchar, - e_sshort, - e_ushort, e_sint, e_uint, e_slong, @@ -43,74 +34,22 @@ public: e_ulonglong, e_float, e_double, - e_long_double, - e_uint128, - e_sint128 + e_long_double }; //------------------------------------------------------------------ // Constructors and Destructors //------------------------------------------------------------------ Scalar(); - Scalar(char v) : m_type(e_schar), m_float((float)0) { m_integer = llvm::APInt(sizeof(char) * 8, v, true);} - Scalar(unsigned char v) : m_type(e_uchar), m_float((float)0) { m_integer = llvm::APInt(sizeof(char) * 8, v);} - Scalar(short v) : m_type(e_sshort), m_float((float)0) { m_integer = llvm::APInt(sizeof(short) * 8, v, true);} - Scalar(unsigned short v) : m_type(e_ushort), m_float((float)0) { m_integer = llvm::APInt(sizeof(short) * 8, v);} - Scalar(int v) : m_type(e_sint), m_float((float)0) { m_integer = llvm::APInt(sizeof(int) * 8, v, true);} - Scalar(unsigned int v) : m_type(e_uint), m_float((float)0) { m_integer = llvm::APInt(sizeof(int) * 8, v);} - Scalar(long v) : m_type(e_slong), m_float((float)0) { m_integer = llvm::APInt(sizeof(long) * 8, v, true);} - Scalar(unsigned long v) : m_type(e_ulong), m_float((float)0) { m_integer = llvm::APInt(sizeof(long) * 8, v);} - Scalar(long long v) : m_type(e_slonglong), m_float((float)0) { m_integer = llvm::APInt(sizeof(long long) * 8, v, true);} - Scalar(unsigned long long v): m_type(e_ulonglong), m_float((float)0) { m_integer = llvm::APInt(sizeof(long long) * 8, v);} - Scalar(float v) : m_type(e_float), m_float(v) { m_float = llvm::APFloat(v); } - Scalar(double v) : m_type(e_double), m_float(v) { m_float = llvm::APFloat(v); } - Scalar(long double v, bool ieee_quad) - : m_type(e_long_double), m_float((float)0), m_ieee_quad(ieee_quad) - { - if(ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x)); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x)); - } - Scalar(llvm::APInt v) : - m_type(), - m_float((float)0) - { - m_integer = llvm::APInt(v); - switch(m_integer.getBitWidth()) - { - case 8: - if(m_integer.isSignedIntN(sizeof(schar_t) * 8)) - m_type = e_schar; - else - m_type = e_uchar; - break; - case 16: - if(m_integer.isSignedIntN(sizeof(sshort_t) * 8)) - m_type = e_sshort; - else - m_type = e_ushort; - break; - case 32: - if(m_integer.isSignedIntN(sizeof(sint_t) * 8)) - m_type = e_sint; - else - m_type = e_uint; - break; - case 64: - if(m_integer.isSignedIntN(sizeof(slonglong_t) * 8)) - m_type = e_slonglong; - else - m_type = e_ulonglong; - break; - case 128: - if(m_integer.isSignedIntN(BITWIDTH_INT128)) - m_type = e_sint128; - else - m_type = e_uint128; - break; - } - } + Scalar(int v) : m_type(e_sint), m_data() { m_data.sint = v; } + Scalar(unsigned int v) : m_type(e_uint), m_data() { m_data.uint = v; } + Scalar(long v) : m_type(e_slong), m_data() { m_data.slong = v; } + Scalar(unsigned long v) : m_type(e_ulong), m_data() { m_data.ulong = v; } + Scalar(long long v) : m_type(e_slonglong), m_data() { m_data.slonglong = v; } + Scalar(unsigned long long v): m_type(e_ulonglong), m_data() { m_data.ulonglong = v; } + Scalar(float v) : m_type(e_float), m_data() { m_data.flt = v; } + Scalar(double v) : m_type(e_double), m_data() { m_data.dbl = v; } + Scalar(long double v) : m_type(e_long_double), m_data() { m_data.ldbl = v; } Scalar(const Scalar& rhs); //Scalar(const RegisterValue& reg_value); virtual ~Scalar(); @@ -122,18 +61,15 @@ public: ExtractBitfield (uint32_t bit_size, uint32_t bit_offset); - bool - SetBit(uint32_t bit); - - bool - ClearBit(uint32_t bit); - - void * - GetBytes() const; - size_t GetByteSize() const; + static size_t + GetMaxByteSize() + { + return sizeof(ValueData); + } + bool GetData (DataExtractor &data, size_t limit_byte_size = UINT32_MAX) const; @@ -147,7 +83,7 @@ public: IsZero() const; void - Clear() { m_type = e_void; m_integer.clearAllBits(); } + Clear() { m_type = e_void; m_data.ulonglong = 0; } const char * GetTypeAsCString() const; @@ -158,7 +94,7 @@ public: bool IsValid() const { - return (m_type >= e_schar) && (m_type <= e_long_double); + return (m_type >= e_sint) && (m_type <= e_long_double); } bool @@ -188,10 +124,6 @@ public: // need to be created. As a result, we currently don't need a variety of // overloaded set value accessors. //---------------------------------------------------------------------- - Scalar& operator= (char v); - Scalar& operator= (unsigned char v); - Scalar& operator= (short v); - Scalar& operator= (unsigned short v); Scalar& operator= (const int i); Scalar& operator= (unsigned int v); Scalar& operator= (long v); @@ -201,7 +133,6 @@ public: Scalar& operator= (float v); Scalar& operator= (double v); Scalar& operator= (long double v); - Scalar& operator= (llvm::APInt v); Scalar& operator= (const Scalar& rhs); // Assignment operator Scalar& operator+= (const Scalar& rhs); Scalar& operator<<= (const Scalar& rhs); // Shift left @@ -263,18 +194,6 @@ public: unsigned long long RawULongLong () const; - unsigned char - UChar(unsigned char fail_value = 0) const; - - char - SChar(char fail_value = 0) const; - - unsigned short - UShort(unsigned short fail_value = 0) const; - - short - SShort(short fail_value = 0) const; - unsigned int UInt(unsigned int fail_value = 0) const; @@ -290,12 +209,6 @@ public: unsigned long long ULongLong(unsigned long long fail_value = 0) const; - llvm::APInt - SInt128(llvm::APInt& fail_value) const; - - llvm::APInt - UInt128(llvm::APInt& fail_value) const; - float Float(float fail_value = 0.0f) const; @@ -342,10 +255,6 @@ public: } protected: - typedef char schar_t; - typedef unsigned char uchar_t; - typedef short sshort_t; - typedef unsigned short ushort_t; typedef int sint_t; typedef unsigned int uint_t; typedef long slong_t; @@ -356,13 +265,24 @@ protected: typedef double double_t; typedef long double long_double_t; + union ValueData + { + int sint; + unsigned int uint; + long slong; + unsigned long ulong; + long long slonglong; + unsigned long long ulonglong; + float flt; + double dbl; + long double ldbl; + }; + //------------------------------------------------------------------ // Classes that inherit from Scalar can see and modify these //------------------------------------------------------------------ Scalar::Type m_type; - llvm::APInt m_integer; - llvm::APFloat m_float; - bool m_ieee_quad = false; + ValueData m_data; private: friend const Scalar operator+ (const Scalar& lhs, const Scalar& rhs); diff --git a/lldb/include/lldb/Core/Value.h b/lldb/include/lldb/Core/Value.h index bdaad08..957cede 100644 --- a/lldb/include/lldb/Core/Value.h +++ b/lldb/include/lldb/Core/Value.h @@ -101,7 +101,6 @@ public: // Casts a vector, if valid, to an unsigned int of matching or largest supported size. // Truncates to the beginning of the vector if required. // Returns a default constructed Scalar if the Vector data is internally inconsistent. - llvm::APInt rhs = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)bytes)->x); Scalar GetAsScalar() const { @@ -112,7 +111,11 @@ public: else if (length == 2) scalar = *(const uint16_t *)bytes; else if (length == 4) scalar = *(const uint32_t *)bytes; else if (length == 8) scalar = *(const uint64_t *)bytes; - else if (length >= 16) scalar = rhs; +#if defined (ENABLE_128_BIT_SUPPORT) + else if (length >= 16) scalar = *(const __uint128_t *)bytes; +#else + else if (length >= 16) scalar = *(const uint64_t *)bytes; +#endif } return scalar; } diff --git a/lldb/include/lldb/lldb-private-types.h b/lldb/include/lldb/lldb-private-types.h index 21811c3..cce637f 100644 --- a/lldb/include/lldb/lldb-private-types.h +++ b/lldb/include/lldb/lldb-private-types.h @@ -102,8 +102,6 @@ namespace lldb_private // pass it. }; - typedef struct type128 { uint64_t x[2]; } type128; - } // namespace lldb_private #endif // #if defined(__cplusplus) diff --git a/lldb/source/Core/RegisterValue.cpp b/lldb/source/Core/RegisterValue.cpp index 475c20c..a1e9e4e 100644 --- a/lldb/source/Core/RegisterValue.cpp +++ b/lldb/source/Core/RegisterValue.cpp @@ -215,10 +215,10 @@ RegisterValue::SetFromMemoryData (const RegisterInfo *reg_info, } else if (value_type == eTypeBytes) { - buffer.byte_order = src_byte_order; + 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. - buffer.length = src_len; + // problems due to uninitialized variables. + m_data.buffer.length = src_len; } const uint32_t bytes_copied = src_data.CopyByteOrderedData (0, // src offset @@ -240,23 +240,25 @@ RegisterValue::GetScalarValue (Scalar &scalar) const case eTypeInvalid: break; case eTypeBytes: { - switch (buffer.length) + switch (m_data.buffer.length) { default: break; - case 1: scalar = *(uint8_t *)buffer.bytes; return true; - case 2: scalar = *(uint16_t *)buffer.bytes; return true; - case 4: scalar = *(uint32_t *)buffer.bytes; return true; - case 8: scalar = *(uint64_t *)buffer.bytes; return true; + 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: - case eTypeUInt16: - case eTypeUInt32: - case eTypeUInt64: - case eTypeUInt128: - case eTypeFloat: - case eTypeDouble: - case eTypeLongDouble: scalar = m_scalar; 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; } @@ -287,8 +289,10 @@ RegisterValue::SetType (const RegisterInfo *reg_info) 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: @@ -338,9 +342,8 @@ RegisterValue::SetValueFromData (const RegisterInfo *reg_info, DataExtractor &sr src_len = reg_info->byte_size; // Zero out the value in case we get partial data... - memset (buffer.bytes, 0, sizeof (buffer.bytes)); - - type128 int128; + memset (m_data.buffer.bytes, 0, sizeof (m_data.buffer.bytes)); + switch (SetType (reg_info)) { case eTypeInvalid: @@ -350,36 +353,33 @@ RegisterValue::SetValueFromData (const RegisterInfo *reg_info, DataExtractor &sr 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) - { - int128.x[1] = src.GetU64 (&src_offset + 1); - int128.x[0] = src.GetU64 (&src_offset); - } + SetUInt128 (data1 << 64 + data2); else - { - int128.x[0] = src.GetU64 (&src_offset); - int128.x[1] = src.GetU64 (&src_offset + 1); - } - SetUInt128 (llvm::APInt(128, 2, int128.x)); + 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: { - buffer.length = reg_info->byte_size; - buffer.byte_order = src.GetByteOrder(); - assert (buffer.length <= kMaxRegisterByteSize); - if (buffer.length > kMaxRegisterByteSize) - buffer.length = kMaxRegisterByteSize; + 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 - buffer.bytes, // dst buffer - buffer.length, // dst length - buffer.byte_order) == 0)// dst byte order + 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; @@ -459,9 +459,6 @@ RegisterValue::SetValueFromCString (const RegisterInfo *reg_info, const char *va } bool success = false; const uint32_t byte_size = reg_info->byte_size; - static float flt_val; - static double dbl_val; - static long double ldbl_val; switch (reg_info->encoding) { case eEncodingInvalid: @@ -513,31 +510,22 @@ RegisterValue::SetValueFromCString (const RegisterInfo *reg_info, const char *va case eEncodingIEEE754: if (byte_size == sizeof (float)) { - if (::sscanf (value_str, "%f", &flt_val) == 1) - { - m_scalar = flt_val; + 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", &dbl_val) == 1) - { - m_scalar = dbl_val; + 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", &ldbl_val) == 1) - { - m_scalar = ldbl_val; + 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); } @@ -569,11 +557,81 @@ RegisterValue::SignExtend (uint32_t sign_bitpos) 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: - return m_scalar.SignExtend(sign_bitpos); + 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: @@ -591,19 +649,21 @@ RegisterValue::CopyValue (const RegisterValue &rhs) { case eTypeInvalid: return false; - case eTypeUInt8: - case eTypeUInt16: - case eTypeUInt32: - case eTypeUInt64: - case eTypeUInt128: - case eTypeFloat: - case eTypeDouble: - case eTypeLongDouble: m_scalar = rhs.m_scalar; break; + 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.buffer.length <= kMaxRegisterByteSize); - ::memcpy (buffer.bytes, rhs.buffer.bytes, kMaxRegisterByteSize); - buffer.length = rhs.buffer.length; - buffer.byte_order = rhs.buffer.byte_order; + 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; @@ -618,15 +678,15 @@ RegisterValue::GetAsUInt16 (uint16_t fail_value, bool *success_ptr) const switch (m_type) { default: break; - case eTypeUInt8: - case eTypeUInt16: return m_scalar.UShort(fail_value); + case eTypeUInt8: return m_data.uint8; + case eTypeUInt16: return m_data.uint16; case eTypeBytes: { - switch (buffer.length) + switch (m_data.buffer.length) { default: break; - case 1: - case 2: return *(uint16_t *)buffer.bytes; + case 1: return m_data.uint8; + case 2: return m_data.uint16; } } break; @@ -644,20 +704,29 @@ RegisterValue::GetAsUInt32 (uint32_t fail_value, bool *success_ptr) const switch (m_type) { default: break; - case eTypeUInt8: - case eTypeUInt16: - case eTypeUInt32: + 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: - case eTypeLongDouble: return m_scalar.UInt(fail_value); + 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 (buffer.length) + switch (m_data.buffer.length) { default: break; - case 1: - case 2: - case 4: return *(uint32_t *)buffer.bytes; + case 1: return m_data.uint8; + case 2: return m_data.uint16; + case 4: return m_data.uint32; } } break; @@ -675,22 +744,31 @@ RegisterValue::GetAsUInt64 (uint64_t fail_value, bool *success_ptr) const switch (m_type) { default: break; - case eTypeUInt8: - case eTypeUInt16: - case eTypeUInt32: - case eTypeUInt64: + 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: - case eTypeLongDouble: return m_scalar.ULongLong(fail_value); + 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 (buffer.length) + switch (m_data.buffer.length) { default: break; - case 1: - case 2: - case 4: - case 8: return *(uint64_t *)buffer.bytes; + 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; @@ -700,36 +778,43 @@ RegisterValue::GetAsUInt64 (uint64_t fail_value, bool *success_ptr) const return fail_value; } -llvm::APInt -RegisterValue::GetAsUInt128 (llvm::APInt& fail_value, bool *success_ptr) const +#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: - case eTypeUInt16: - case eTypeUInt32: - case eTypeUInt64: - case eTypeUInt128: + 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: - case eTypeLongDouble: return m_scalar.UInt128(fail_value); + 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 (buffer.length) + switch (m_data.buffer.length) { - default: - break; - case 1: - case 2: - case 4: - case 8: - case 16: - { - return llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)buffer.bytes)->x); - } + 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; @@ -738,7 +823,7 @@ RegisterValue::GetAsUInt128 (llvm::APInt& fail_value, bool *success_ptr) const *success_ptr = false; return fail_value; } - +#endif float RegisterValue::GetAsFloat (float fail_value, bool *success_ptr) const { @@ -748,12 +833,28 @@ RegisterValue::GetAsFloat (float fail_value, bool *success_ptr) const { 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: - case eTypeFloat: + 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: - return m_scalar.Float(fail_value); + if (sizeof(float) == sizeof(long double)) + return m_data.ieee_float; + break; } if (success_ptr) *success_ptr = false; @@ -771,12 +872,27 @@ RegisterValue::GetAsDouble (double fail_value, bool *success_ptr) const 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: - case eTypeFloat: - case eTypeDouble: + 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: - return m_scalar.Double(fail_value); + if (sizeof(double) == sizeof(long double)) + return m_data.ieee_double; + break; } if (success_ptr) *success_ptr = false; @@ -794,12 +910,24 @@ RegisterValue::GetAsLongDouble (long double fail_value, bool *success_ptr) const 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: - case eTypeFloat: - case eTypeDouble: - case eTypeLongDouble: - return m_scalar.LongDouble(); + 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; @@ -812,15 +940,17 @@ RegisterValue::GetBytes () const switch (m_type) { case eTypeInvalid: break; - case eTypeUInt8: - case eTypeUInt16: - case eTypeUInt32: - case eTypeUInt64: - case eTypeUInt128: - case eTypeFloat: - case eTypeDouble: - case eTypeLongDouble: return m_scalar.GetBytes(); - case eTypeBytes: return buffer.bytes; + 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; } @@ -831,15 +961,17 @@ RegisterValue::GetBytes () switch (m_type) { case eTypeInvalid: break; - case eTypeUInt8: - case eTypeUInt16: - case eTypeUInt32: - case eTypeUInt64: - case eTypeUInt128: - case eTypeFloat: - case eTypeDouble: - case eTypeLongDouble: return m_scalar.GetBytes(); - case eTypeBytes: return buffer.bytes; + 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; } @@ -850,15 +982,17 @@ RegisterValue::GetByteSize () const switch (m_type) { case eTypeInvalid: break; - case eTypeUInt8: - case eTypeUInt16: - case eTypeUInt32: - case eTypeUInt64: - case eTypeUInt128: - case eTypeFloat: - case eTypeDouble: - case eTypeLongDouble: return m_scalar.GetByteSize(); - case eTypeBytes: return buffer.length; + 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; } @@ -887,10 +1021,12 @@ RegisterValue::SetUInt (uint64_t uint, uint32_t byte_size) { SetUInt64 (uint); } +#if defined (ENABLE_128_BIT_SUPPORT) else if (byte_size <= 16) { - SetUInt128 (llvm::APInt(64, uint)); + SetUInt128 (uint); } +#endif else return false; return true; @@ -900,21 +1036,21 @@ 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 - // buffer.bytes, or make it something that is allocated on + // 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 (buffer.bytes) && "Storing too many bytes in a RegisterValue."); + assert (length <= sizeof (m_data.buffer.bytes) && "Storing too many bytes in a RegisterValue."); m_type = eTypeBytes; - buffer.length = length; - memcpy (buffer.bytes, bytes, length); - buffer.byte_order = byte_order; + m_data.buffer.length = length; + memcpy (m_data.buffer.bytes, bytes, length); + m_data.buffer.byte_order = byte_order; } else { m_type = eTypeInvalid; - buffer.length = 0; + m_data.buffer.length = 0; } } @@ -927,23 +1063,25 @@ RegisterValue::operator == (const RegisterValue &rhs) const switch (m_type) { case eTypeInvalid: return true; - case eTypeUInt8: - case eTypeUInt16: - case eTypeUInt32: - case eTypeUInt64: - case eTypeUInt128: - case eTypeFloat: - case eTypeDouble: - case eTypeLongDouble: return m_scalar == rhs.m_scalar; + 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 (buffer.length != rhs.buffer.length) + if (m_data.buffer.length != rhs.m_data.buffer.length) return false; else { - uint8_t length = buffer.length; + uint8_t length = m_data.buffer.length; if (length > kMaxRegisterByteSize) length = kMaxRegisterByteSize; - return memcmp (buffer.bytes, rhs.buffer.bytes, length) == 0; + return memcmp (m_data.buffer.bytes, rhs.m_data.buffer.bytes, length) == 0; } break; } @@ -959,25 +1097,27 @@ RegisterValue::operator != (const RegisterValue &rhs) const switch (m_type) { case eTypeInvalid: return false; - case eTypeUInt8: - case eTypeUInt16: - case eTypeUInt32: - case eTypeUInt64: - case eTypeUInt128: - case eTypeFloat: - case eTypeDouble: - case eTypeLongDouble: return m_scalar != rhs.m_scalar; + 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 (buffer.length != rhs.buffer.length) + if (m_data.buffer.length != rhs.m_data.buffer.length) { return true; } else { - uint8_t length = buffer.length; + uint8_t length = m_data.buffer.length; if (length > kMaxRegisterByteSize) length = kMaxRegisterByteSize; - return memcmp (buffer.bytes, rhs.buffer.bytes, length) != 0; + return memcmp (m_data.buffer.bytes, rhs.m_data.buffer.bytes, length) != 0; } break; } @@ -992,35 +1132,63 @@ RegisterValue::ClearBit (uint32_t bit) case eTypeInvalid: break; - case eTypeUInt8: + 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: - case eTypeUInt128: - if (bit < (GetByteSize() * 8)) + if (bit < 64) { - return m_scalar.ClearBit(bit); + 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 (buffer.byte_order == eByteOrderBig || buffer.byte_order == eByteOrderLittle) + if (m_data.buffer.byte_order == eByteOrderBig || m_data.buffer.byte_order == eByteOrderLittle) { uint32_t byte_idx; - if (buffer.byte_order == eByteOrderBig) - byte_idx = buffer.length - (bit / 8) - 1; + 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 < buffer.length) + if (byte_idx < m_data.buffer.length) { - buffer.bytes[byte_idx] &= ~(1u << byte_bit); + m_data.buffer.bytes[byte_idx] &= ~(1u << byte_bit); return true; } } @@ -1039,34 +1207,62 @@ RegisterValue::SetBit (uint32_t bit) 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: - case eTypeUInt128: - if (bit < (GetByteSize() * 8)) + if (bit < 64) { - return m_scalar.SetBit(bit); + 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 (buffer.byte_order == eByteOrderBig || buffer.byte_order == eByteOrderLittle) + if (m_data.buffer.byte_order == eByteOrderBig || m_data.buffer.byte_order == eByteOrderLittle) { uint32_t byte_idx; - if (buffer.byte_order == eByteOrderBig) - byte_idx = buffer.length - (bit / 8) - 1; + 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 < buffer.length) + if (byte_idx < m_data.buffer.length) { - buffer.bytes[byte_idx] |= (1u << byte_bit); + m_data.buffer.bytes[byte_idx] |= (1u << byte_bit); return true; } } diff --git a/lldb/source/Core/Scalar.cpp b/lldb/source/Core/Scalar.cpp index be8d818..0022c34 100644 --- a/lldb/source/Core/Scalar.cpp +++ b/lldb/source/Core/Scalar.cpp @@ -11,7 +11,6 @@ #include #include -#include #include "lldb/Interpreter/Args.h" #include "lldb/Core/Error.h" @@ -78,7 +77,7 @@ PromoteToMaxType //---------------------------------------------------------------------- Scalar::Scalar() : m_type(e_void), - m_float((float)0) + m_data() { } @@ -87,8 +86,7 @@ Scalar::Scalar() : //---------------------------------------------------------------------- Scalar::Scalar(const Scalar& rhs) : m_type(rhs.m_type), - m_integer(rhs.m_integer), - m_float(rhs.m_float) + m_data(rhs.m_data) // TODO: verify that for C++ this will correctly copy the union?? { } @@ -137,8 +135,6 @@ 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) { if (limit_byte_size < byte_size) @@ -148,104 +144,20 @@ 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... - switch(m_type) - { - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - data.SetData((const uint8_t *)m_integer.getRawData(), limit_byte_size, lldb::endian::InlHostByteOrder()); - return true; - case e_float: - f_val = m_float.convertToFloat(); - data.SetData((uint8_t *)&f_val, limit_byte_size, lldb::endian::InlHostByteOrder()); - return true; - case e_double: - d_val = m_float.convertToDouble(); - data.SetData((uint8_t *)&d_val, limit_byte_size, lldb::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, lldb::endian::InlHostByteOrder()); - return true; - } + data.SetData((uint8_t*)&m_data, limit_byte_size, lldb::endian::InlHostByteOrder()); } else if (lldb::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 - switch(m_type) - { - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - data.SetData((const uint8_t *)m_integer.getRawData() + byte_size - limit_byte_size, limit_byte_size, lldb::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, lldb::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, lldb::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, lldb::endian::InlHostByteOrder()); - return true; - } + data.SetData(((uint8_t*)&m_data) + byte_size - limit_byte_size, limit_byte_size, lldb::endian::InlHostByteOrder()); } } else { // We want all of the data - switch(m_type) - { - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - data.SetData((const uint8_t *)m_integer.getRawData(), byte_size, lldb::endian::InlHostByteOrder()); - return true; - case e_float: - f_val = m_float.convertToFloat(); - data.SetData((uint8_t *)&f_val, byte_size, lldb::endian::InlHostByteOrder()); - return true; - case e_double: - d_val = m_float.convertToDouble(); - data.SetData((uint8_t *)&d_val, byte_size, lldb::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, lldb::endian::InlHostByteOrder()); - return true; - } + data.SetData((uint8_t*)&m_data, byte_size, lldb::endian::InlHostByteOrder()); } return true; } @@ -253,41 +165,6 @@ Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const return false; } -void * -Scalar::GetBytes() const -{ - static float_t flt_val; - static double_t dbl_val; - switch (m_type) - { - case e_void: - break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - return (void *)m_integer.getRawData(); - case e_float: - flt_val = m_float.convertToFloat(); - return (void *)&flt_val; - case e_double: - dbl_val = m_float.convertToDouble(); - return (void *)&dbl_val; - case e_long_double: - llvm::APInt ldbl_val = m_float.bitcastToAPInt(); - return (void *)ldbl_val.getRawData(); - } - return NULL; -} - size_t Scalar::GetByteSize() const { @@ -295,21 +172,15 @@ Scalar::GetByteSize() const { case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: return (m_integer.getBitWidth() / 8); - case e_float: return sizeof(float_t); - case e_double: return sizeof(double_t); - case e_long_double: return sizeof(long_double_t); + case e_sint: return sizeof(m_data.sint); + case e_uint: return sizeof(m_data.uint); + case e_slong: return sizeof(m_data.slong); + case e_ulong: return sizeof(m_data.ulong); + case e_slonglong: return sizeof(m_data.slonglong); + case e_ulonglong: return sizeof(m_data.ulonglong); + case e_float: return sizeof(m_data.flt); + case e_double: return sizeof(m_data.dbl); + case e_long_double: return sizeof(m_data.ldbl); } return 0; } @@ -317,28 +188,19 @@ Scalar::GetByteSize() const bool Scalar::IsZero() const { - llvm::APInt zero_int = llvm::APInt::getAllOnesValue(m_integer.getBitWidth() / 8); switch (m_type) { case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - return llvm::APInt::isSameValue(zero_int, m_integer); - case e_float: - case e_double: - case e_long_double: - return m_float.isZero(); + case e_sint: return m_data.sint == 0; + case e_uint: return m_data.uint == 0; + case e_slong: return m_data.slong == 0; + case e_ulong: return m_data.ulong == 0; + case e_slonglong: return m_data.slonglong == 0; + case e_ulonglong: return m_data.ulonglong == 0; + case e_float: return m_data.flt == 0.0f; + case e_double: return m_data.dbl == 0.0; + case e_long_double: return m_data.ldbl == 0.0; } return false; } @@ -346,7 +208,6 @@ Scalar::IsZero() const void Scalar::GetValue (Stream *s, bool show_type) const { - const uint64_t *src; if (show_type) s->Printf("(%s) ", GetTypeAsCString()); @@ -354,30 +215,15 @@ Scalar::GetValue (Stream *s, bool show_type) const { case e_void: break; - case e_schar: s->Printf("%i", *(const schar_t *) m_integer.getRawData()); break; - case e_uchar: s->Printf("0x%8.8x", *(const uchar_t *) m_integer.getRawData()); break; - case e_sshort: s->Printf("%i", *(const sint_t *) m_integer.getRawData()); break; - case e_ushort: s->Printf("0x%8.8x", *(const uint_t *) m_integer.getRawData()); break; - 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: - src = m_integer.getRawData(); - s->Printf("%lli%lli", *(const slonglong_t *)src, *(const slonglong_t *)(src + 1)); - break; - 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_float: s->Printf("%f", m_float.convertToFloat()); break; - case e_double: s->Printf("%g", m_float.convertToDouble()); break; - case e_long_double: - llvm::APInt ldbl_val = m_float.bitcastToAPInt(); - s->Printf("%Lg", *(const long_double_t *)ldbl_val.getRawData()); - break; + case e_sint: s->Printf("%i", m_data.sint); break; + case e_uint: s->Printf("0x%8.8x", m_data.uint); break; + case e_slong: s->Printf("%li", m_data.slong); break; + case e_ulong: s->Printf("0x%8.8lx", m_data.ulong); break; + case e_slonglong: s->Printf("%lli", m_data.slonglong); break; + case e_ulonglong: s->Printf("0x%16.16llx", m_data.ulonglong); break; + case e_float: s->Printf("%f", m_data.flt); break; + case e_double: s->Printf("%g", m_data.dbl); break; + case e_long_double: s->Printf("%Lg", m_data.ldbl); break; } } @@ -387,18 +233,12 @@ Scalar::GetTypeAsCString() const switch (m_type) { case e_void: return "void"; - case e_schar: return "char"; - case e_uchar: return "unsigned char"; - case e_sshort: return "short"; - case e_ushort: return "unsigned short"; case e_sint: return "int"; case e_uint: return "unsigned int"; case e_slong: return "long"; case e_ulong: return "unsigned long"; case e_slonglong: return "long long"; case e_ulonglong: return "unsigned long long"; - case e_sint128: return "int128_t"; - case e_uint128: return "unsigned int128_t"; case e_float: return "float"; case e_double: return "double"; case e_long_double: return "long double"; @@ -417,51 +257,16 @@ Scalar::operator=(const Scalar& rhs) if (this != &rhs) { m_type = rhs.m_type; - m_integer = llvm::APInt(rhs.m_integer); - m_float = rhs.m_float; + ::memcpy (&m_data, &rhs.m_data, sizeof(m_data)); } return *this; } Scalar& -Scalar::operator= (const char v) -{ - m_type = e_schar; - m_integer = llvm::APInt(sizeof(char) * 8, v, true); - return *this; -} - - -Scalar& -Scalar::operator= (unsigned char v) -{ - m_type = e_uchar; - m_integer = llvm::APInt(sizeof(char) * 8, v); - return *this; -} - -Scalar& -Scalar::operator= (const short v) -{ - m_type = e_sshort; - m_integer = llvm::APInt(sizeof(short) * 8, v, true); - return *this; -} - - -Scalar& -Scalar::operator= (unsigned short v) -{ - m_type = e_ushort; - m_integer = llvm::APInt(sizeof(short) * 8, v); - return *this; -} - -Scalar& Scalar::operator= (const int v) { m_type = e_sint; - m_integer = llvm::APInt(sizeof(int) * 8, v, true); + m_data.sint = v; return *this; } @@ -470,7 +275,7 @@ Scalar& Scalar::operator= (unsigned int v) { m_type = e_uint; - m_integer = llvm::APInt(sizeof(int) * 8, v); + m_data.uint = v; return *this; } @@ -478,7 +283,7 @@ Scalar& Scalar::operator= (long v) { m_type = e_slong; - m_integer = llvm::APInt(sizeof(long) * 8, v, true); + m_data.slong = v; return *this; } @@ -486,7 +291,7 @@ Scalar& Scalar::operator= (unsigned long v) { m_type = e_ulong; - m_integer = llvm::APInt(sizeof(long) * 8, v); + m_data.ulong = v; return *this; } @@ -494,7 +299,7 @@ Scalar& Scalar::operator= (long long v) { m_type = e_slonglong; - m_integer = llvm::APInt(sizeof(long) * 8, v, true); + m_data.slonglong = v; return *this; } @@ -502,7 +307,7 @@ Scalar& Scalar::operator= (unsigned long long v) { m_type = e_ulonglong; - m_integer = llvm::APInt(sizeof(long long) * 8, v); + m_data.ulonglong = v; return *this; } @@ -510,7 +315,7 @@ Scalar& Scalar::operator= (float v) { m_type = e_float; - m_float = llvm::APFloat(v); + m_data.flt = v; return *this; } @@ -518,7 +323,7 @@ Scalar& Scalar::operator= (double v) { m_type = e_double; - m_float = llvm::APFloat(v); + m_data.dbl = v; return *this; } @@ -526,50 +331,7 @@ Scalar& Scalar::operator= (long double v) { m_type = e_long_double; - if(m_ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x)); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x)); - return *this; -} - -Scalar& -Scalar::operator= (llvm::APInt rhs) -{ - m_integer = llvm::APInt(rhs); - switch(m_integer.getBitWidth()) - { - case 8: - if(m_integer.isSignedIntN(sizeof(schar_t) * 8)) - m_type = e_schar; - else - m_type = e_uchar; - break; - case 16: - if(m_integer.isSignedIntN(sizeof(sshort_t) * 8)) - m_type = e_sshort; - else - m_type = e_ushort; - break; - case 32: - if(m_integer.isSignedIntN(sizeof(sint_t) * 8)) - m_type = e_sint; - else - m_type = e_uint; - break; - case 64: - if(m_integer.isSignedIntN(sizeof(slonglong_t) * 8)) - m_type = e_slonglong; - else - m_type = e_ulonglong; - break; - case 128: - if(m_integer.isSignedIntN(BITWIDTH_INT128)) - m_type = e_sint128; - else - m_type = e_uint128; - break; - } + m_data.ldbl = v; return *this; } @@ -589,878 +351,131 @@ Scalar::Promote(Scalar::Type type) case e_void: break; - case e_schar: - switch (type) - { - case e_void: break; - case e_schar: success = true; break; - case e_uchar: - { - m_integer = llvm::APInt(sizeof(uchar_t) * 8, *(const uint64_t *)m_integer.getRawData(), false); - success = true; - break; - } - case e_sshort: - { - m_integer = m_integer.sext(sizeof(sshort_t) * 8); - success = true; - break; - } - case e_ushort: - { - m_integer = m_integer.zext(sizeof(sshort_t) * 8); - success = true; - break; - } - case e_sint: - { - m_integer = m_integer.sext(sizeof(sint_t) * 8); - success = true; - break; - } - case e_uint: - { - m_integer = m_integer.zext(sizeof(sint_t) * 8); - success = true; - break; - } - case e_slong: - { - m_integer = m_integer.sext(sizeof(slong_t) * 8); - success = true; - break; - } - case e_ulong: - { - m_integer = m_integer.zext(sizeof(slong_t) * 8); - success = true; - break; - } - case e_slonglong: - { - m_integer = m_integer.sext(sizeof(slonglong_t) * 8); - success = true; - break; - } - case e_ulonglong: - { - m_integer = m_integer.zext(sizeof(slonglong_t) * 8); - success = true; - break; - } - case e_sint128: - { - m_integer = m_integer.sext(BITWIDTH_INT128); - success = true; - break; - } - case e_uint128: - { - m_integer = m_integer.zext(BITWIDTH_INT128); - success = true; - break; - } - case e_float: - { - m_float = llvm::APFloat(m_integer.bitsToFloat()); - success = true; - break; - } - case e_double: - { - m_float = llvm::APFloat(m_integer.bitsToDouble()); - success = true; - break; - } - case e_long_double: - { - if(m_ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer); - success = true; - break; - } - } - break; - - case e_uchar: - switch (type) - { - case e_void: - case e_schar: break; - case e_uchar: success = true; break; - case e_sshort: - { - m_integer = m_integer.sext(sizeof(sshort_t) * 8); - success = true; - break; - } - case e_ushort: - { - m_integer = m_integer.sext(sizeof(sshort_t) * 8); - success = true; - break; - } - case e_sint: - { - m_integer = m_integer.sext(sizeof(sint_t) * 8); - success = true; - break; - } - case e_uint: - { - m_integer = m_integer.zext(sizeof(sint_t) * 8); - success = true; - break; - } - case e_slong: - { - m_integer = m_integer.sext(sizeof(slong_t) * 8); - success = true; - break; - } - case e_ulong: - { - m_integer = m_integer.zext(sizeof(slong_t) * 8); - success = true; - break; - } - case e_slonglong: - { - m_integer = m_integer.sext(sizeof(slonglong_t) * 8); - success = true; - break; - } - case e_ulonglong: - { - m_integer = m_integer.zext(sizeof(slonglong_t) * 8); - success = true; - break; - } - case e_sint128: - { - m_integer = m_integer.sext(BITWIDTH_INT128); - success = true; - break; - } - case e_uint128: - { - m_integer = m_integer.zext(BITWIDTH_INT128); - success = true; - break; - } - case e_float: - { - m_float = llvm::APFloat(m_integer.bitsToFloat()); - success = true; - break; - } - case e_double: - { - m_float = llvm::APFloat(m_integer.bitsToDouble()); - success = true; - break; - } - case e_long_double: - { - if(m_ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer); - success = true; - break; - } - } - break; - - case e_sshort: + case e_sint: switch (type) { - case e_void: - case e_schar: - case e_uchar: break; - case e_sshort: success = true; break; - case e_ushort: - { - m_integer = llvm::APInt(sizeof(ushort_t) * 8, *(const uint64_t *)m_integer.getRawData(), false); - success = true; - break; - } - case e_sint: - { - m_integer = m_integer.sext(sizeof(sint_t) * 8); - success = true; - break; - } - case e_uint: - { - m_integer = m_integer.zext(sizeof(sint_t) * 8); - success = true; - break; - } - case e_slong: - { - m_integer = m_integer.sext(sizeof(slong_t) * 8); - success = true; - break; - } - case e_ulong: - { - m_integer = m_integer.zext(sizeof(slong_t) * 8); - success = true; - break; - } - case e_slonglong: - { - m_integer = m_integer.sext(sizeof(slonglong_t) * 8); - success = true; - break; - } - case e_ulonglong: - { - m_integer = m_integer.zext(sizeof(slonglong_t) * 8); - success = true; - break; - } - case e_sint128: - { - m_integer = m_integer.sext(BITWIDTH_INT128); - success = true; - break; - } - case e_uint128: - { - m_integer = m_integer.zext(BITWIDTH_INT128); - success = true; - break; - } - case e_float: - { - m_float = llvm::APFloat(m_integer.bitsToFloat()); - success = true; - break; - } - case e_double: - { - m_float = llvm::APFloat(m_integer.bitsToDouble()); - success = true; - break; - } - case e_long_double: - { - if(m_ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer); - success = true; - break; - } - } - break; - - case e_ushort: - switch (type) - { - case e_void: - case e_schar: - case e_uchar: - case e_sshort: break; - case e_ushort: success = true; break; - case e_sint: - { - m_integer = m_integer.sext(sizeof(sint_t) * 8); - success = true; - break; - } - case e_uint: - { - m_integer = m_integer.zext(sizeof(sint_t) * 8); - success = true; - break; - } - case e_slong: - { - m_integer = m_integer.sext(sizeof(slong_t) * 8); - success = true; - break; - } - case e_ulong: - { - m_integer = m_integer.zext(sizeof(slong_t) * 8); - success = true; - break; - } - case e_slonglong: - { - m_integer = m_integer.sext(sizeof(slonglong_t) * 8); - success = true; - break; - } - case e_ulonglong: - { - m_integer = m_integer.zext(sizeof(slonglong_t) * 8); - success = true; - break; - } - case e_sint128: - { - m_integer = m_integer.sext(BITWIDTH_INT128); - success = true; - break; - } - case e_uint128: - { - m_integer = m_integer.zext(BITWIDTH_INT128); - success = true; - break; - } - case e_float: - { - m_float = llvm::APFloat(m_integer.bitsToFloat()); - success = true; - break; - } - case e_double: - { - m_float = llvm::APFloat(m_integer.bitsToDouble()); - success = true; - break; - } - case e_long_double: - { - if(m_ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer); - success = true; - break; - } - } - break; - - case e_sint: - switch (type) - { - case e_void: - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: break; - case e_sint: success = true; break; - case e_uint: - { - 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.sext(sizeof(slong_t) * 8); - success = true; - break; - } - case e_ulong: - { - m_integer = m_integer.zext(sizeof(slong_t) * 8); - success = true; - break; - } - case e_slonglong: - { - m_integer = m_integer.sext(sizeof(slonglong_t) * 8); - success = true; - break; - } - case e_ulonglong: - { - m_integer = m_integer.zext(sizeof(slonglong_t) * 8); - success = true; - break; - } - case e_sint128: - { - m_integer = m_integer.sext(BITWIDTH_INT128); - success = true; - break; - } - case e_uint128: - { - m_integer = m_integer.zext(BITWIDTH_INT128); - success = true; - break; - } - case e_float: - { - m_float = llvm::APFloat(m_integer.bitsToFloat()); - success = true; - break; - } - case e_double: - { - m_float = llvm::APFloat(m_integer.bitsToDouble()); - success = true; - break; - } - case e_long_double: - { - if(m_ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer); - success = true; - break; - } + case e_void: break; + case e_sint: success = true; break; + case e_uint: m_data.uint = m_data.sint; success = true; break; + case e_slong: m_data.slong = m_data.sint; success = true; break; + case e_ulong: m_data.ulong = m_data.sint; success = true; break; + case e_slonglong: m_data.slonglong = m_data.sint; success = true; break; + case e_ulonglong: m_data.ulonglong = m_data.sint; success = true; break; + case e_float: m_data.flt = m_data.sint; success = true; break; + case e_double: m_data.dbl = m_data.sint; success = true; break; + case e_long_double: m_data.ldbl = m_data.sint; success = true; break; } break; case e_uint: switch (type) { - case e_void: - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: break; - case e_uint: success = true; break; - case e_slong: - { - m_integer = m_integer.sext(sizeof(slong_t) * 8); - success = true; - break; - } - case e_ulong: - { - m_integer = m_integer.zext(sizeof(slong_t) * 8); - success = true; - break; - } - case e_slonglong: - { - m_integer = m_integer.sext(sizeof(slonglong_t) * 8); - success = true; - break; - } - case e_ulonglong: - { - m_integer = m_integer.zext(sizeof(slonglong_t) * 8); - success = true; - break; - } - case e_sint128: - { - m_integer = m_integer.sext(BITWIDTH_INT128); - success = true; - break; - } - case e_uint128: - { - m_integer = m_integer.zext(BITWIDTH_INT128); - success = true; - break; - } - case e_float: - { - m_float = llvm::APFloat(m_integer.bitsToFloat()); - success = true; - break; - } - case e_double: - { - m_float = llvm::APFloat(m_integer.bitsToDouble()); - success = true; - break; - } - case e_long_double: - { - if(m_ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer); - success = true; - break; - } + case e_void: + case e_sint: break; + case e_uint: success = true; break; + case e_slong: m_data.slong = m_data.uint; success = true; break; + case e_ulong: m_data.ulong = m_data.uint; success = true; break; + case e_slonglong: m_data.slonglong = m_data.uint; success = true; break; + case e_ulonglong: m_data.ulonglong = m_data.uint; success = true; break; + case e_float: m_data.flt = m_data.uint; success = true; break; + case e_double: m_data.dbl = m_data.uint; success = true; break; + case e_long_double: m_data.ldbl = m_data.uint; success = true; break; } break; case e_slong: switch (type) { - case e_void: - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: break; - case e_slong: success = true; break; - case e_ulong: - { - 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.sext(sizeof(slonglong_t) * 8); - success = true; - break; - } - case e_ulonglong: - { - m_integer = m_integer.zext(sizeof(slonglong_t) * 8); - success = true; - break; - } - case e_sint128: - { - m_integer = m_integer.sext(BITWIDTH_INT128); - success = true; - break; - } - case e_uint128: - { - m_integer = m_integer.zext(BITWIDTH_INT128); - success = true; - break; - } - case e_float: - { - m_float = llvm::APFloat(m_integer.bitsToFloat()); - success = true; - break; - } - case e_double: - { - m_float = llvm::APFloat(m_integer.bitsToDouble()); - success = true; - break; - } - case e_long_double: - { - if(m_ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer); - success = true; - break; - } + case e_void: + case e_sint: + case e_uint: break; + case e_slong: success = true; break; + case e_ulong: m_data.ulong = m_data.slong; success = true; break; + case e_slonglong: m_data.slonglong = m_data.slong; success = true; break; + case e_ulonglong: m_data.ulonglong = m_data.slong; success = true; break; + case e_float: m_data.flt = m_data.slong; success = true; break; + case e_double: m_data.dbl = m_data.slong; success = true; break; + case e_long_double: m_data.ldbl = m_data.slong; success = true; break; } break; case e_ulong: switch (type) { - case e_void: - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: break; - case e_ulong: success = true; break; - case e_slonglong: - { - m_integer = m_integer.sext(sizeof(slonglong_t) * 8); - success = true; - break; - } - case e_ulonglong: - { - m_integer = m_integer.zext(sizeof(slonglong_t) * 8); - success = true; - break; - } - case e_sint128: - { - m_integer = m_integer.sext(BITWIDTH_INT128); - success = true; - break; - } - case e_uint128: - { - m_integer = m_integer.zext(BITWIDTH_INT128); - success = true; - break; - } - case e_float: - { - m_float = llvm::APFloat(m_integer.bitsToFloat()); - success = true; - break; - } - case e_double: - { - m_float = llvm::APFloat(m_integer.bitsToDouble()); - success = true; - break; - } - case e_long_double: - { - if(m_ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer); - success = true; - break; - } + case e_void: + case e_sint: + case e_uint: + case e_slong: break; + case e_ulong: success = true; break; + case e_slonglong: m_data.slonglong = m_data.ulong; success = true; break; + case e_ulonglong: m_data.ulonglong = m_data.ulong; success = true; break; + case e_float: m_data.flt = m_data.ulong; success = true; break; + case e_double: m_data.dbl = m_data.ulong; success = true; break; + case e_long_double: m_data.ldbl = m_data.ulong; success = true; break; } break; case e_slonglong: switch (type) { - case e_void: - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: break; - case e_slonglong: success = true; break; - case e_ulonglong: - { - 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.sext(BITWIDTH_INT128); - success = true; - break; - } - case e_uint128: - { - m_integer = m_integer.zext(BITWIDTH_INT128); - success = true; - break; - } - case e_float: - { - m_float = llvm::APFloat(m_integer.bitsToFloat()); - success = true; - break; - } - case e_double: - { - m_float = llvm::APFloat(m_integer.bitsToDouble()); - success = true; - break; - } - case e_long_double: - { - if(m_ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer); - success = true; - break; - } + case e_void: + case e_sint: + case e_uint: + case e_slong: + case e_ulong: break; + case e_slonglong: success = true; break; + case e_ulonglong: m_data.ulonglong = m_data.slonglong; success = true; break; + case e_float: m_data.flt = m_data.slonglong; success = true; break; + case e_double: m_data.dbl = m_data.slonglong; success = true; break; + case e_long_double: m_data.ldbl = m_data.slonglong; success = true; break; } break; case e_ulonglong: switch (type) { - case e_void: - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: break; - case e_ulonglong: success = true; break; - case e_sint128: - { - m_integer = m_integer.sext(BITWIDTH_INT128); - success = true; - break; - } - case e_uint128: - { - m_integer = m_integer.zext(BITWIDTH_INT128); - success = true; - break; - } - case e_float: - { - m_float = llvm::APFloat(m_integer.bitsToFloat()); - success = true; - break; - } - case e_double: - { - m_float = llvm::APFloat(m_integer.bitsToDouble()); - success = true; - break; - } - case e_long_double: - { - if(m_ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer); - success = true; - break; - } - } - break; - - case e_sint128: - switch (type) - { - case e_void: - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: break; - case e_sint128: success = true; break; - case e_uint128: - { - m_integer = m_integer.zext(BITWIDTH_INT128); - success = true; - break; - } - case e_float: - { - m_float = llvm::APFloat(m_integer.bitsToFloat()); - success = true; - break; - } - case e_double: - { - m_float = llvm::APFloat(m_integer.bitsToDouble()); - success = true; - break; - } - case e_long_double: - { - if(m_ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer); - success = true; - break; - } - } - break; - - case e_uint128: - switch (type) - { - case e_void: - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: break; - case e_uint128: success = true; break; - case e_float: - { - m_float = llvm::APFloat(m_integer.bitsToFloat()); - success = true; - break; - } - case e_double: - { - m_float = llvm::APFloat(m_integer.bitsToDouble()); - success = true; - break; - } - case e_long_double: - { - if(m_ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer); - success = true; - break; - } + case e_void: + case e_sint: + case e_uint: + case e_slong: + case e_ulong: + case e_slonglong: break; + case e_ulonglong: success = true; break; + case e_float: m_data.flt = m_data.ulonglong; success = true; break; + case e_double: m_data.dbl = m_data.ulonglong; success = true; break; + case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break; } break; case e_float: switch (type) { - case e_void: - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: break; - case e_float: success = true; break; - case e_double: - { - m_float = llvm::APFloat((float_t)m_float.convertToFloat()); - success = true; - break; - } - case e_long_double: - { - if(m_ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_float.bitcastToAPInt()); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_float.bitcastToAPInt()); - success = true; - break; - } + case e_void: + case e_sint: + case e_uint: + case e_slong: + case e_ulong: + case e_slonglong: + case e_ulonglong: break; + case e_float: success = true; break; + case e_double: m_data.dbl = m_data.flt; success = true; break; + case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break; } break; case e_double: switch (type) { - case e_void: - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - 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_float: break; - case e_double: success = true; break; - case e_long_double: - { - if(m_ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_float.bitcastToAPInt()); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_float.bitcastToAPInt()); - success = true; - break; - } + case e_void: + case e_sint: + case e_uint: + case e_slong: + case e_ulong: + case e_slonglong: + case e_ulonglong: + case e_float: break; + case e_double: success = true; break; + case e_long_double: m_data.ldbl = m_data.dbl; success = true; break; } break; @@ -1468,18 +483,12 @@ Scalar::Promote(Scalar::Type type) switch (type) { case e_void: - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: 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_float: case e_double: break; case e_long_double: success = true; break; @@ -1498,10 +507,6 @@ Scalar::GetValueTypeAsCString (Scalar::Type type) switch (type) { case e_void: return "void"; - case e_schar: return "char"; - case e_uchar: return "unsigned char"; - case e_sshort: return "short"; - case e_ushort: return "unsigned short"; case e_sint: return "int"; case e_uint: return "unsigned int"; case e_slong: return "long"; @@ -1511,8 +516,6 @@ Scalar::GetValueTypeAsCString (Scalar::Type type) case e_float: return "float"; case e_double: return "double"; case e_long_double: return "long double"; - case e_sint128: return "int128_t"; - case e_uint128: return "uint128_t"; } return "???"; } @@ -1521,10 +524,6 @@ Scalar::GetValueTypeAsCString (Scalar::Type type) Scalar::Type Scalar::GetValueTypeForSignedIntegerWithByteSize (size_t byte_size) { - if (byte_size <= sizeof(schar_t)) - return e_schar; - if (byte_size <= sizeof(sshort_t)) - return e_sshort; if (byte_size <= sizeof(sint_t)) return e_sint; if (byte_size <= sizeof(slong_t)) @@ -1537,10 +536,6 @@ Scalar::GetValueTypeForSignedIntegerWithByteSize (size_t byte_size) Scalar::Type Scalar::GetValueTypeForUnsignedIntegerWithByteSize (size_t byte_size) { - if (byte_size <= sizeof(schar_t)) - return e_schar; - if (byte_size <= sizeof(sshort_t)) - return e_sshort; if (byte_size <= sizeof(uint_t)) return e_uint; if (byte_size <= sizeof(ulong_t)) @@ -1571,263 +566,146 @@ Scalar::Cast(Scalar::Type type) case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: switch (type) { - case e_void: break; - case e_schar: - { - m_integer = m_integer.sextOrTrunc(sizeof(schar_t) * 8); - success = true; - break; - } - case e_uchar: - { - m_integer = m_integer.zextOrTrunc(sizeof(schar_t) * 8); - success = true; - break; - } - case e_sshort: - { - m_integer = m_integer.sextOrTrunc(sizeof(sshort_t) * 8); - success = true; - break; - } - case e_ushort: - { - m_integer = m_integer.zextOrTrunc(sizeof(sshort_t) * 8); - success = true; - break; - } - case e_sint: - { - m_integer = m_integer.sextOrTrunc(sizeof(sint_t) * 8); - success = true; - break; - } - case e_uint: - { - m_integer = m_integer.zextOrTrunc(sizeof(sint_t) * 8); - success = true; - break; - } - case e_slong: - { - m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8); - success = true; - break; - } - case e_ulong: - { - m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8); - success = true; - break; - } - case e_slonglong: - { - m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8); - success = true; - break; - } - case e_ulonglong: - { - m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8); - 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); - success = true; - break; - } - case e_float: - { - m_float = llvm::APFloat(m_integer.bitsToFloat()); - success = true; - break; - } - case e_double: - { - m_float = llvm::APFloat(m_integer.bitsToDouble()); - success = true; - break; - } - case e_long_double: - { - if(m_ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer); - success = true; - break; - } + case e_void: break; + case e_sint: success = true; break; + case e_uint: m_data.uint = m_data.sint; success = true; break; + case e_slong: m_data.slong = m_data.sint; success = true; break; + case e_ulong: m_data.ulong = m_data.sint; success = true; break; + case e_slonglong: m_data.slonglong = m_data.sint; success = true; break; + case e_ulonglong: m_data.ulonglong = m_data.sint; success = true; break; + case e_float: m_data.flt = m_data.sint; success = true; break; + case e_double: m_data.dbl = m_data.sint; success = true; break; + case e_long_double: m_data.ldbl = m_data.sint; success = true; break; } break; - case e_float: + case e_uint: switch (type) { - case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: m_integer = m_float.bitcastToAPInt(); success = true; break; - case e_float: m_float = llvm::APFloat(m_float.convertToFloat()); success = true; break; - case e_double: m_float = llvm::APFloat(m_float.convertToFloat()); success = true; break; - case e_long_double: - if(m_ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_float.bitcastToAPInt()); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_float.bitcastToAPInt()); - success = true; - break; + case e_void: + case e_sint: m_data.sint = m_data.uint; success = true; break; + case e_uint: success = true; break; + case e_slong: m_data.slong = m_data.uint; success = true; break; + case e_ulong: m_data.ulong = m_data.uint; success = true; break; + case e_slonglong: m_data.slonglong = m_data.uint; success = true; break; + case e_ulonglong: m_data.ulonglong = m_data.uint; success = true; break; + case e_float: m_data.flt = m_data.uint; success = true; break; + case e_double: m_data.dbl = m_data.uint; success = true; break; + case e_long_double: m_data.ldbl = m_data.uint; success = true; break; } break; - case e_double: + case e_slong: switch (type) { - case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: m_integer = m_float.bitcastToAPInt(); success = true; break; - case e_float: m_float = llvm::APFloat(m_float.convertToDouble()); success = true; break; - case e_double: m_float = llvm::APFloat(m_float.convertToDouble()); success = true; break; - case e_long_double: - if(m_ieee_quad) - m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_float.bitcastToAPInt()); - else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_float.bitcastToAPInt()); - success = true; - break; + case e_void: + case e_sint: m_data.sint = (sint_t)m_data.slong; success = true; break; + case e_uint: m_data.uint = (uint_t)m_data.slong; success = true; break; + case e_slong: success = true; break; + case e_ulong: m_data.ulong = m_data.slong; success = true; break; + case e_slonglong: m_data.slonglong = m_data.slong; success = true; break; + case e_ulonglong: m_data.ulonglong = m_data.slong; success = true; break; + case e_float: m_data.flt = m_data.slong; success = true; break; + case e_double: m_data.dbl = m_data.slong; success = true; break; + case e_long_double: m_data.ldbl = m_data.slong; success = true; break; } break; - case e_long_double: + case e_ulong: switch (type) { - case e_void: break; - case e_schar: - { - m_integer = m_float.bitcastToAPInt(); - m_integer = m_integer.sextOrTrunc(sizeof(schar_t) * 8); - success = true; - break; - } - case e_uchar: - { - m_integer = m_float.bitcastToAPInt(); - m_integer = m_integer.zextOrTrunc(sizeof(schar_t) * 8); - success = true; - break; - } - case e_sshort: - { - m_integer = m_float.bitcastToAPInt(); - m_integer = m_integer.sextOrTrunc(sizeof(sshort_t) * 8); - success = true; - break; - } - case e_ushort: - { - m_integer = m_float.bitcastToAPInt(); - m_integer = m_integer.zextOrTrunc(sizeof(sshort_t) * 8); - success = true; - break; - } - case e_sint: - { - m_integer = m_float.bitcastToAPInt(); - m_integer = m_integer.sextOrTrunc(sizeof(sint_t) * 8); - success = true; - break; - } - case e_uint: - { - m_integer = m_float.bitcastToAPInt(); - m_integer = m_integer.zextOrTrunc(sizeof(sint_t) * 8); - success = true; - break; - } - case e_slong: - { - m_integer = m_float.bitcastToAPInt(); - m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8); - success = true; - break; + case e_void: + case e_sint: m_data.sint = (sint_t)m_data.ulong; success = true; break; + case e_uint: m_data.uint = (uint_t)m_data.ulong; success = true; break; + case e_slong: m_data.slong = m_data.ulong; success = true; break; + case e_ulong: success = true; break; + case e_slonglong: m_data.slonglong = m_data.ulong; success = true; break; + case e_ulonglong: m_data.ulonglong = m_data.ulong; success = true; break; + case e_float: m_data.flt = m_data.ulong; success = true; break; + case e_double: m_data.dbl = m_data.ulong; success = true; break; + case e_long_double: m_data.ldbl = m_data.ulong; success = true; break; } - case e_ulong: + break; + + case e_slonglong: + switch (type) { - m_integer = m_float.bitcastToAPInt(); - m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8); - success = true; - break; + case e_void: + case e_sint: m_data.sint = (sint_t)m_data.slonglong; success = true; break; + case e_uint: m_data.uint = (uint_t)m_data.slonglong; success = true; break; + case e_slong: m_data.slong = m_data.slonglong; success = true; break; + case e_ulong: m_data.ulong = m_data.slonglong; success = true; break; + case e_slonglong: success = true; break; + case e_ulonglong: m_data.ulonglong = m_data.slonglong; success = true; break; + case e_float: m_data.flt = m_data.slonglong; success = true; break; + case e_double: m_data.dbl = m_data.slonglong; success = true; break; + case e_long_double: m_data.ldbl = m_data.slonglong; success = true; break; } - case e_slonglong: + break; + + case e_ulonglong: + switch (type) { - m_integer = m_float.bitcastToAPInt(); - m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8); - success = true; - break; + case e_void: + case e_sint: m_data.sint = (sint_t)m_data.ulonglong; success = true; break; + case e_uint: m_data.uint = (uint_t)m_data.ulonglong; success = true; break; + case e_slong: m_data.slong = m_data.ulonglong; success = true; break; + case e_ulong: m_data.ulong = m_data.ulonglong; success = true; break; + case e_slonglong: m_data.slonglong = m_data.ulonglong; success = true; break; + case e_ulonglong: success = true; break; + case e_float: m_data.flt = m_data.ulonglong; success = true; break; + case e_double: m_data.dbl = m_data.ulonglong; success = true; break; + case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break; } - case e_ulonglong: + break; + + case e_float: + switch (type) { - m_integer = m_float.bitcastToAPInt(); - m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8); - success = true; - break; + case e_void: + case e_sint: m_data.sint = (sint_t)m_data.flt; success = true; break; + case e_uint: m_data.uint = (uint_t)m_data.flt; success = true; break; + case e_slong: m_data.slong = (slong_t)m_data.flt; success = true; break; + case e_ulong: m_data.ulong = (ulong_t)m_data.flt; success = true; break; + case e_slonglong: m_data.slonglong = (slonglong_t)m_data.flt; success = true; break; + case e_ulonglong: m_data.ulonglong = (ulonglong_t)m_data.flt; success = true; break; + case e_float: success = true; break; + case e_double: m_data.dbl = m_data.flt; success = true; break; + case e_long_double: m_data.ldbl = m_data.flt; success = true; break; } - case e_sint128: + break; + + case e_double: + switch (type) { - m_integer = m_float.bitcastToAPInt(); - m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128); - success = true; - break; + case e_void: + case e_sint: m_data.sint = (sint_t)m_data.dbl; success = true; break; + case e_uint: m_data.uint = (uint_t)m_data.dbl; success = true; break; + case e_slong: m_data.slong = (slong_t)m_data.dbl; success = true; break; + case e_ulong: m_data.ulong = (ulong_t)m_data.dbl; success = true; break; + case e_slonglong: m_data.slonglong = (slonglong_t)m_data.dbl; success = true; break; + case e_ulonglong: m_data.ulonglong = (ulonglong_t)m_data.dbl; success = true; break; + case e_float: m_data.flt = (float_t)m_data.dbl; success = true; break; + case e_double: success = true; break; + case e_long_double: m_data.ldbl = m_data.dbl; success = true; break; } - case e_uint128: + break; + + case e_long_double: + switch (type) { - m_integer = m_float.bitcastToAPInt(); - m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128); - success = true; - break; - } - case e_float: m_float = llvm::APFloat(m_float.convertToFloat()); success = true; break; - case e_double: m_float = llvm::APFloat(m_float.convertToFloat()); success = true; break; + case e_void: + case e_sint: m_data.sint = (sint_t)m_data.ldbl; success = true; break; + case e_uint: m_data.uint = (uint_t)m_data.ldbl; success = true; break; + case e_slong: m_data.slong = (slong_t)m_data.ldbl; success = true; break; + case e_ulong: m_data.ulong = (ulong_t)m_data.ldbl; success = true; break; + case e_slonglong: m_data.slonglong = (slonglong_t)m_data.ldbl; success = true; break; + case e_ulonglong: m_data.ulonglong = (ulonglong_t)m_data.ldbl; success = true; break; + case e_float: m_data.flt = (float_t)m_data.ldbl; success = true; break; + case e_double: m_data.dbl = (double_t)m_data.ldbl; success = true; break; case e_long_double: success = true; break; } break; @@ -1846,18 +724,12 @@ Scalar::MakeSigned () switch (m_type) { case e_void: break; - case e_schar: success = true; break; - case e_uchar: m_type = e_schar; success = true; break; - case e_sshort: success = true; break; - case e_ushort: m_type = e_sshort; success = true; break; case e_sint: success = true; break; case e_uint: m_type = e_sint; success = true; break; case e_slong: success = true; break; case e_ulong: m_type = e_slong; success = true; break; 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_sint; success = true; break; case e_float: success = true; break; case e_double: success = true; break; case e_long_double: success = true; break; @@ -1866,213 +738,60 @@ Scalar::MakeSigned () return success; } -char -Scalar::SChar(char fail_value) const +int +Scalar::SInt(int fail_value) const { switch (m_type) { case e_void: break; - case e_sint: - case e_uint: - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - return *(const schar_t *)(m_integer.sext(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.getRawData(); + case e_sint: return m_data.sint; + case e_uint: return (int)m_data.uint; + case e_slong: return (int)m_data.slong; + case e_ulong: return (int)m_data.ulong; + case e_slonglong: return (int)m_data.slonglong; + case e_ulonglong: return (int)m_data.ulonglong; + case e_float: return (int)m_data.flt; + case e_double: return (int)m_data.dbl; + case e_long_double: return (int)m_data.ldbl; } return fail_value; } -unsigned char -Scalar::UChar(unsigned char fail_value) const +unsigned int +Scalar::UInt(unsigned int fail_value) const { switch (m_type) { case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - 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.getRawData(); + case e_sint: return (unsigned int)m_data.sint; + case e_uint: return (unsigned int)m_data.uint; + case e_slong: return (unsigned int)m_data.slong; + case e_ulong: return (unsigned int)m_data.ulong; + case e_slonglong: return (unsigned int)m_data.slonglong; + case e_ulonglong: return (unsigned int)m_data.ulonglong; + case e_float: return (unsigned int)m_data.flt; + case e_double: return (unsigned int)m_data.dbl; + case e_long_double: return (unsigned int)m_data.ldbl; } return fail_value; } -short -Scalar::SShort(short fail_value) const + +long +Scalar::SLong(long fail_value) const { switch (m_type) { case e_void: break; - case e_sint: - case e_uint: - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - return *(const sshort_t *)(m_integer.sext(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 *(const sshort_t *)ldbl_val.getRawData(); - } - return fail_value; -} - -unsigned short -Scalar::UShort(unsigned short fail_value) const -{ - switch (m_type) - { - case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - 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 *(const ushort_t *)ldbl_val.getRawData();; - } - return fail_value; -} - -int -Scalar::SInt(int fail_value) const -{ - switch (m_type) - { - case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - return *(const sint_t *)(m_integer.sext(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 *(const sint_t *)ldbl_val.getRawData(); - } - return fail_value; -} - -unsigned int -Scalar::UInt(unsigned int fail_value) const -{ - switch (m_type) - { - case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - 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 *(const uint_t *)ldbl_val.getRawData(); - } - return fail_value; -} - - -long -Scalar::SLong(long fail_value) const -{ - switch (m_type) - { - case e_void: break; - case e_sint: - case e_uint: - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - return *(const slong_t *)(m_integer.sext(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 *(const slong_t *)ldbl_val.getRawData(); + case e_sint: return (long)m_data.sint; + case e_uint: return (long)m_data.uint; + case e_slong: return (long)m_data.slong; + case e_ulong: return (long)m_data.ulong; + case e_slonglong: return (long)m_data.slonglong; + case e_ulonglong: return (long)m_data.ulonglong; + case e_float: return (long)m_data.flt; + case e_double: return (long)m_data.dbl; + case e_long_double: return (long)m_data.ldbl; } return fail_value; } @@ -2085,26 +804,15 @@ Scalar::ULong(unsigned long fail_value) const switch (m_type) { case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - 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 *(const ulong_t *)ldbl_val.getRawData(); + case e_sint: return (unsigned long)m_data.sint; + case e_uint: return (unsigned long)m_data.uint; + case e_slong: return (unsigned long)m_data.slong; + case e_ulong: return (unsigned long)m_data.ulong; + case e_slonglong: return (unsigned long)m_data.slonglong; + case e_ulonglong: return (unsigned long)m_data.ulonglong; + case e_float: return (unsigned long)m_data.flt; + case e_double: return (unsigned long)m_data.dbl; + case e_long_double: return (unsigned long)m_data.ldbl; } return fail_value; } @@ -2116,26 +824,45 @@ Scalar::GetRawBits64(uint64_t fail_value) const { case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: + case e_sint: case e_uint: + return m_data.uint; + case e_slong: case e_ulong: + return m_data.ulong; + case e_slonglong: case e_ulonglong: - case e_sint128: - case e_uint128: - return *m_integer.getRawData(); + return m_data.ulonglong; + case e_float: - return (uint64_t)m_float.convertToFloat(); + if (sizeof(m_data.flt) == sizeof(m_data.uint)) + return m_data.uint; + else if (sizeof(m_data.flt) == sizeof(m_data.ulong)) + return m_data.ulong; + else if (sizeof(m_data.flt) == sizeof(m_data.ulonglong)) + return m_data.ulonglong; + break; + case e_double: - return (uint64_t)m_float.convertToDouble(); + if (sizeof(m_data.dbl) == sizeof(m_data.uint)) + return m_data.uint; + else if (sizeof(m_data.dbl) == sizeof(m_data.ulong)) + return m_data.ulong; + else if (sizeof(m_data.dbl) == sizeof(m_data.ulonglong)) + return m_data.ulonglong; + break; + case e_long_double: - llvm::APInt ldbl_val = m_float.bitcastToAPInt(); - return *ldbl_val.getRawData(); + if (sizeof(m_data.ldbl) == sizeof(m_data.uint)) + return m_data.uint; + else if (sizeof(m_data.ldbl) == sizeof(m_data.ulong)) + return m_data.ulong; + else if (sizeof(m_data.ldbl) == sizeof(m_data.ulonglong)) + return m_data.ulonglong; + break; } return fail_value; } @@ -2148,26 +875,15 @@ Scalar::SLongLong(long long fail_value) const switch (m_type) { case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - return *(const slonglong_t *)(m_integer.sext(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 *(const slonglong_t *)ldbl_val.getRawData(); + case e_sint: return (long long)m_data.sint; + case e_uint: return (long long)m_data.uint; + case e_slong: return (long long)m_data.slong; + case e_ulong: return (long long)m_data.ulong; + case e_slonglong: return (long long)m_data.slonglong; + case e_ulonglong: return (long long)m_data.ulonglong; + case e_float: return (long long)m_data.flt; + case e_double: return (long long)m_data.dbl; + case e_long_double: return (long long)m_data.ldbl; } return fail_value; } @@ -2179,85 +895,19 @@ Scalar::ULongLong(unsigned long long fail_value) const switch (m_type) { case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - if(m_integer.isAllOnesValue()) - return *(const ulonglong_t *)(llvm::APInt::getAllOnesValue(128)).getRawData(); - 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 *(const ulonglong_t *)ldbl_val.getRawData(); + case e_sint: return (unsigned long long)m_data.sint; + case e_uint: return (unsigned long long)m_data.uint; + case e_slong: return (unsigned long long)m_data.slong; + case e_ulong: return (unsigned long long)m_data.ulong; + case e_slonglong: return (unsigned long long)m_data.slonglong; + case e_ulonglong: return (unsigned long long)m_data.ulonglong; + case e_float: return (unsigned long long)m_data.flt; + case e_double: return (unsigned long long)m_data.dbl; + case e_long_double: return (unsigned long long)m_data.ldbl; } return fail_value; } -llvm::APInt -Scalar::UInt128(llvm::APInt& fail_value) const -{ - switch (m_type) - { - case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - return m_integer; - case e_float: - case e_double: - case e_long_double: - return m_float.bitcastToAPInt(); - } - return fail_value; -} - -llvm::APInt -Scalar::SInt128(llvm::APInt& fail_value) const -{ - switch (m_type) - { - case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - return m_integer; - case e_float: - case e_double: - case e_long_double: - return m_float.bitcastToAPInt(); - } - return fail_value; -} float Scalar::Float(float fail_value) const @@ -2265,26 +915,15 @@ Scalar::Float(float fail_value) const switch (m_type) { case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - return m_integer.bitsToFloat(); - case e_float: - return m_float.convertToFloat(); - case e_double: - return (float_t)m_float.convertToDouble(); - case e_long_double: - llvm::APInt ldbl_val = m_float.bitcastToAPInt(); - return ldbl_val.bitsToFloat(); + case e_sint: return (float)m_data.sint; + case e_uint: return (float)m_data.uint; + case e_slong: return (float)m_data.slong; + case e_ulong: return (float)m_data.ulong; + case e_slonglong: return (float)m_data.slonglong; + case e_ulonglong: return (float)m_data.ulonglong; + case e_float: return (float)m_data.flt; + case e_double: return (float)m_data.dbl; + case e_long_double: return (float)m_data.ldbl; } return fail_value; } @@ -2296,26 +935,15 @@ Scalar::Double(double fail_value) const switch (m_type) { case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - return m_integer.bitsToDouble(); - case e_float: - return (double_t)m_float.convertToFloat(); - case e_double: - return m_float.convertToDouble(); - case e_long_double: - llvm::APInt ldbl_val = m_float.bitcastToAPInt(); - return ldbl_val.bitsToFloat(); + case e_sint: return (double)m_data.sint; + case e_uint: return (double)m_data.uint; + case e_slong: return (double)m_data.slong; + case e_ulong: return (double)m_data.ulong; + case e_slonglong: return (double)m_data.slonglong; + case e_ulonglong: return (double)m_data.ulonglong; + case e_float: return (double)m_data.flt; + case e_double: return (double)m_data.dbl; + case e_long_double: return (double)m_data.ldbl; } return fail_value; } @@ -2327,26 +955,15 @@ Scalar::LongDouble(long double fail_value) const switch (m_type) { case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - return (long_double_t)m_integer.bitsToDouble(); - case e_float: - return (long_double_t)m_float.convertToFloat(); - case e_double: - return (long_double_t)m_float.convertToDouble(); - case e_long_double: - llvm::APInt ldbl_val = m_float.bitcastToAPInt(); - return (long_double_t)ldbl_val.bitsToDouble(); + case e_sint: return (long double)m_data.sint; + case e_uint: return (long double)m_data.uint; + case e_slong: return (long double)m_data.slong; + case e_ulong: return (long double)m_data.ulong; + case e_slonglong: return (long double)m_data.slonglong; + case e_ulonglong: return (long double)m_data.ulonglong; + case e_float: return (long double)m_data.flt; + case e_double: return (long double)m_data.dbl; + case e_long_double: return (long double)m_data.ldbl; } return fail_value; } @@ -2361,31 +978,17 @@ Scalar::operator+= (const Scalar& rhs) if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) != Scalar::e_void) { switch (m_type) - { - case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - { - m_integer = a->m_integer + b->m_integer; - break; - } - case e_float: - case e_double: - case e_long_double: - { - m_float = a->m_float + b->m_float; - break; - } + { + case e_void: break; + case e_sint: m_data.sint = a->m_data.sint + b->m_data.sint; break; + case e_uint: m_data.uint = a->m_data.uint + b->m_data.uint; break; + case e_slong: m_data.slong = a->m_data.slong + b->m_data.slong; break; + case e_ulong: m_data.ulong = a->m_data.ulong + b->m_data.ulong; break; + case e_slonglong: m_data.slonglong = a->m_data.slonglong + b->m_data.slonglong; break; + case e_ulonglong: m_data.ulonglong = a->m_data.ulonglong + b->m_data.ulonglong; break; + case e_float: m_data.flt = a->m_data.flt + b->m_data.flt; break; + case e_double: m_data.dbl = a->m_data.dbl + b->m_data.dbl; break; + case e_long_double: m_data.ldbl = a->m_data.ldbl + b->m_data.ldbl; break; } } return *this; @@ -2402,42 +1005,111 @@ Scalar::operator<<= (const Scalar& rhs) case e_long_double: m_type = e_void; break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: + case e_sint: + switch (rhs.m_type) + { + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + case e_sint: m_data.sint <<= rhs.m_data.sint; break; + case e_uint: m_data.sint <<= rhs.m_data.uint; break; + case e_slong: m_data.sint <<= rhs.m_data.slong; break; + case e_ulong: m_data.sint <<= rhs.m_data.ulong; break; + case e_slonglong: m_data.sint <<= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.sint <<= rhs.m_data.ulonglong; break; + } + break; + case e_uint: + switch (rhs.m_type) + { + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + case e_sint: m_data.uint <<= rhs.m_data.sint; break; + case e_uint: m_data.uint <<= rhs.m_data.uint; break; + case e_slong: m_data.uint <<= rhs.m_data.slong; break; + case e_ulong: m_data.uint <<= rhs.m_data.ulong; break; + case e_slonglong: m_data.uint <<= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.uint <<= rhs.m_data.ulonglong; break; + } + break; + case e_slong: + switch (rhs.m_type) + { + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + case e_sint: m_data.slong <<= rhs.m_data.sint; break; + case e_uint: m_data.slong <<= rhs.m_data.uint; break; + case e_slong: m_data.slong <<= rhs.m_data.slong; break; + case e_ulong: m_data.slong <<= rhs.m_data.ulong; break; + case e_slonglong: m_data.slong <<= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.slong <<= rhs.m_data.ulonglong; break; + } + break; + case e_ulong: + switch (rhs.m_type) + { + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + case e_sint: m_data.ulong <<= rhs.m_data.sint; break; + case e_uint: m_data.ulong <<= rhs.m_data.uint; break; + case e_slong: m_data.ulong <<= rhs.m_data.slong; break; + case e_ulong: m_data.ulong <<= rhs.m_data.ulong; break; + case e_slonglong: m_data.ulong <<= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.ulong <<= rhs.m_data.ulonglong; break; + } + break; case e_slonglong: + switch (rhs.m_type) + { + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + case e_sint: m_data.slonglong <<= rhs.m_data.sint; break; + case e_uint: m_data.slonglong <<= rhs.m_data.uint; break; + case e_slong: m_data.slonglong <<= rhs.m_data.slong; break; + case e_ulong: m_data.slonglong <<= rhs.m_data.ulong; break; + case e_slonglong: m_data.slonglong <<= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.slonglong <<= rhs.m_data.ulonglong; break; + } + break; + case e_ulonglong: - case e_sint128: - case e_uint128: switch (rhs.m_type) { - case e_void: - case e_float: - case e_double: - case e_long_double: - m_type = e_void; - break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - { - m_integer <<= *rhs.m_integer.getRawData(); - break; - } + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + case e_sint: m_data.ulonglong <<= rhs.m_data.sint; break; + case e_uint: m_data.ulonglong <<= rhs.m_data.uint; break; + case e_slong: m_data.ulonglong <<= rhs.m_data.slong; break; + case e_ulong: m_data.ulonglong <<= rhs.m_data.ulong; break; + case e_slonglong: m_data.ulonglong <<= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.ulonglong <<= rhs.m_data.ulonglong; break; } break; } @@ -2455,18 +1127,47 @@ Scalar::ShiftRightLogical(const Scalar& rhs) case e_long_double: m_type = e_void; break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: + case e_sint: case e_uint: + switch (rhs.m_type) + { + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + case e_sint: m_data.uint >>= rhs.m_data.sint; break; + case e_uint: m_data.uint >>= rhs.m_data.uint; break; + case e_slong: m_data.uint >>= rhs.m_data.slong; break; + case e_ulong: m_data.uint >>= rhs.m_data.ulong; break; + case e_slonglong: m_data.uint >>= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.uint >>= rhs.m_data.ulonglong; break; + } + break; + case e_slong: case e_ulong: + switch (rhs.m_type) + { + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + case e_sint: m_data.ulong >>= rhs.m_data.sint; break; + case e_uint: m_data.ulong >>= rhs.m_data.uint; break; + case e_slong: m_data.ulong >>= rhs.m_data.slong; break; + case e_ulong: m_data.ulong >>= rhs.m_data.ulong; break; + case e_slonglong: m_data.ulong >>= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.ulong >>= rhs.m_data.ulonglong; break; + } + break; + case e_slonglong: case e_ulonglong: - case e_sint128: - case e_uint128: switch (rhs.m_type) { case e_void: @@ -2475,19 +1176,12 @@ Scalar::ShiftRightLogical(const Scalar& rhs) case e_long_double: m_type = e_void; break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - m_integer = m_integer.lshr(*(const uint_t *) rhs.m_integer.getRawData()); break; + case e_sint: m_data.ulonglong >>= rhs.m_data.sint; break; + case e_uint: m_data.ulonglong >>= rhs.m_data.uint; break; + case e_slong: m_data.ulonglong >>= rhs.m_data.slong; break; + case e_ulong: m_data.ulonglong >>= rhs.m_data.ulong; break; + case e_slonglong: m_data.ulonglong >>= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.ulonglong >>= rhs.m_data.ulonglong; break; } break; } @@ -2507,18 +1201,201 @@ Scalar::operator>>= (const Scalar& rhs) m_type = e_void; break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: + case e_sint: + switch (rhs.m_type) + { + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + case e_sint: m_data.sint >>= rhs.m_data.sint; break; + case e_uint: m_data.sint >>= rhs.m_data.uint; break; + case e_slong: m_data.sint >>= rhs.m_data.slong; break; + case e_ulong: m_data.sint >>= rhs.m_data.ulong; break; + case e_slonglong: m_data.sint >>= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.sint >>= rhs.m_data.ulonglong; break; + } + break; + + case e_uint: + switch (rhs.m_type) + { + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + case e_sint: m_data.uint >>= rhs.m_data.sint; break; + case e_uint: m_data.uint >>= rhs.m_data.uint; break; + case e_slong: m_data.uint >>= rhs.m_data.slong; break; + case e_ulong: m_data.uint >>= rhs.m_data.ulong; break; + case e_slonglong: m_data.uint >>= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.uint >>= rhs.m_data.ulonglong; break; + } + break; + + case e_slong: + switch (rhs.m_type) + { + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + case e_sint: m_data.slong >>= rhs.m_data.sint; break; + case e_uint: m_data.slong >>= rhs.m_data.uint; break; + case e_slong: m_data.slong >>= rhs.m_data.slong; break; + case e_ulong: m_data.slong >>= rhs.m_data.ulong; break; + case e_slonglong: m_data.slong >>= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.slong >>= rhs.m_data.ulonglong; break; + } + break; + + case e_ulong: + switch (rhs.m_type) + { + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + case e_sint: m_data.ulong >>= rhs.m_data.sint; break; + case e_uint: m_data.ulong >>= rhs.m_data.uint; break; + case e_slong: m_data.ulong >>= rhs.m_data.slong; break; + case e_ulong: m_data.ulong >>= rhs.m_data.ulong; break; + case e_slonglong: m_data.ulong >>= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.ulong >>= rhs.m_data.ulonglong; break; + } + break; + case e_slonglong: + switch (rhs.m_type) + { + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + case e_sint: m_data.slonglong >>= rhs.m_data.sint; break; + case e_uint: m_data.slonglong >>= rhs.m_data.uint; break; + case e_slong: m_data.slonglong >>= rhs.m_data.slong; break; + case e_ulong: m_data.slonglong >>= rhs.m_data.ulong; break; + case e_slonglong: m_data.slonglong >>= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.slonglong >>= rhs.m_data.ulonglong; break; + } + break; + + case e_ulonglong: + switch (rhs.m_type) + { + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + case e_sint: m_data.ulonglong >>= rhs.m_data.sint; break; + case e_uint: m_data.ulonglong >>= rhs.m_data.uint; break; + case e_slong: m_data.ulonglong >>= rhs.m_data.slong; break; + case e_ulong: m_data.ulonglong >>= rhs.m_data.ulong; break; + case e_slonglong: m_data.ulonglong >>= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.ulonglong >>= rhs.m_data.ulonglong; break; + } + break; + } + return *this; +} + + +Scalar& +Scalar::operator&= (const Scalar& rhs) +{ + switch (m_type) + { + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + + case e_sint: + switch (rhs.m_type) + { + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + case e_sint: m_data.sint &= rhs.m_data.sint; break; + case e_uint: m_data.sint &= rhs.m_data.uint; break; + case e_slong: m_data.sint &= rhs.m_data.slong; break; + case e_ulong: m_data.sint &= rhs.m_data.ulong; break; + case e_slonglong: m_data.sint &= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.sint &= rhs.m_data.ulonglong; break; + } + break; + + case e_uint: + switch (rhs.m_type) + { + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + case e_sint: m_data.uint &= rhs.m_data.sint; break; + case e_uint: m_data.uint &= rhs.m_data.uint; break; + case e_slong: m_data.uint &= rhs.m_data.slong; break; + case e_ulong: m_data.uint &= rhs.m_data.ulong; break; + case e_slonglong: m_data.uint &= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.uint &= rhs.m_data.ulonglong; break; + } + break; + + case e_slong: + switch (rhs.m_type) + { + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + case e_sint: m_data.slong &= rhs.m_data.sint; break; + case e_uint: m_data.slong &= rhs.m_data.uint; break; + case e_slong: m_data.slong &= rhs.m_data.slong; break; + case e_ulong: m_data.slong &= rhs.m_data.ulong; break; + case e_slonglong: m_data.slong &= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.slong &= rhs.m_data.ulonglong; break; + } + break; + case e_ulong: + switch (rhs.m_type) + { + case e_void: + case e_float: + case e_double: + case e_long_double: + m_type = e_void; + break; + case e_sint: m_data.ulong &= rhs.m_data.sint; break; + case e_uint: m_data.ulong &= rhs.m_data.uint; break; + case e_slong: m_data.ulong &= rhs.m_data.slong; break; + case e_ulong: m_data.ulong &= rhs.m_data.ulong; break; + case e_slonglong: m_data.ulong &= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.ulong &= rhs.m_data.ulonglong; break; + } + break; case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: switch (rhs.m_type) { case e_void: @@ -2527,52 +1404,16 @@ Scalar::operator>>= (const Scalar& rhs) case e_long_double: m_type = e_void; break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - { - m_integer >> *rhs.m_integer.getRawData(); - break; - } + case e_sint: m_data.slonglong &= rhs.m_data.sint; break; + case e_uint: m_data.slonglong &= rhs.m_data.uint; break; + case e_slong: m_data.slonglong &= rhs.m_data.slong; break; + case e_ulong: m_data.slonglong &= rhs.m_data.ulong; break; + case e_slonglong: m_data.slonglong &= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.slonglong &= rhs.m_data.ulonglong; break; } break; - } - return *this; -} - -Scalar& -Scalar::operator&= (const Scalar& rhs) -{ - switch (m_type) - { - case e_void: - case e_float: - case e_double: - case e_long_double: - m_type = e_void; - break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: case e_ulonglong: - case e_sint128: - case e_uint128: switch (rhs.m_type) { case e_void: @@ -2581,22 +1422,12 @@ Scalar::operator&= (const Scalar& rhs) case e_long_double: m_type = e_void; break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - { - m_integer &= rhs.m_integer; - break; - } + case e_sint: m_data.ulonglong &= rhs.m_data.sint; break; + case e_uint: m_data.ulonglong &= rhs.m_data.uint; break; + case e_slong: m_data.ulonglong &= rhs.m_data.slong; break; + case e_ulong: m_data.ulonglong &= rhs.m_data.ulong; break; + case e_slonglong: m_data.ulonglong &= rhs.m_data.slonglong; break; + case e_ulonglong: m_data.ulonglong &= rhs.m_data.ulonglong; break; } break; } @@ -2613,27 +1444,27 @@ Scalar::AbsoluteValue() case e_void: break; - case e_schar: - case e_sshort: case e_sint: + if (m_data.sint < 0) + m_data.sint = -m_data.sint; + return true; + case e_slong: + if (m_data.slong < 0) + m_data.slong = -m_data.slong; + return true; + case e_slonglong: - case e_sint128: - if (m_integer.isNegative()) - m_integer = -m_integer; + if (m_data.slonglong < 0) + m_data.slonglong = -m_data.slonglong; return true; - case e_uchar: - case e_ushort: case e_uint: case e_ulong: case e_ulonglong: return true; - case e_uint128: - case e_float: - case e_double: - case e_long_double: - m_float.clearSign(); - return true; + case e_float: m_data.flt = fabsf(m_data.flt); return true; + case e_double: m_data.dbl = fabs(m_data.dbl); return true; + case e_long_double: m_data.ldbl = fabsl(m_data.ldbl); return true; } return false; } @@ -2645,23 +1476,15 @@ Scalar::UnaryNegate() switch (m_type) { case e_void: break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - m_integer = -m_integer; return true; - case e_float: - case e_double: - case e_long_double: - m_float.changeSign(); return true; + case e_sint: m_data.sint = -m_data.sint; return true; + case e_uint: m_data.uint = -m_data.uint; return true; + case e_slong: m_data.slong = -m_data.slong; return true; + case e_ulong: m_data.ulong = -m_data.ulong; return true; + case e_slonglong: m_data.slonglong = -m_data.slonglong; return true; + case e_ulonglong: m_data.ulonglong = -m_data.ulonglong; return true; + case e_float: m_data.flt = -m_data.flt; return true; + case e_double: m_data.dbl = -m_data.dbl; return true; + case e_long_double: m_data.ldbl = -m_data.ldbl; return true; } return false; } @@ -2671,19 +1494,12 @@ Scalar::OnesComplement() { switch (m_type) { - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: - m_integer = ~m_integer; return true; + case e_sint: m_data.sint = ~m_data.sint; return true; + case e_uint: m_data.uint = ~m_data.uint; return true; + case e_slong: m_data.slong = ~m_data.slong; return true; + case e_ulong: m_data.ulong = ~m_data.ulong; return true; + case e_slonglong: m_data.slonglong = ~m_data.slonglong; return true; + case e_ulonglong: m_data.ulonglong = ~m_data.ulonglong; return true; case e_void: case e_float: @@ -2707,23 +1523,15 @@ lldb_private::operator+ (const Scalar& lhs, const Scalar& rhs) switch (result.m_type) { case Scalar::e_void: break; - case Scalar::e_schar: - case Scalar::e_uchar: - case Scalar::e_sshort: - case Scalar::e_ushort: - case Scalar::e_sint: - 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: - result.m_integer = a->m_integer + b->m_integer; break; - case Scalar::e_float: - case Scalar::e_double: - case Scalar::e_long_double: - result.m_float = a->m_float + b->m_float; break; + case Scalar::e_sint: result.m_data.sint = a->m_data.sint + b->m_data.sint; break; + case Scalar::e_uint: result.m_data.uint = a->m_data.uint + b->m_data.uint; break; + case Scalar::e_slong: result.m_data.slong = a->m_data.slong + b->m_data.slong; break; + case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong + b->m_data.ulong; break; + case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong + b->m_data.slonglong; break; + case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong + b->m_data.ulonglong; break; + case Scalar::e_float: result.m_data.flt = a->m_data.flt + b->m_data.flt; break; + case Scalar::e_double: result.m_data.dbl = a->m_data.dbl + b->m_data.dbl; break; + case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl + b->m_data.ldbl; break; } } return result; @@ -2742,23 +1550,15 @@ lldb_private::operator- (const Scalar& lhs, const Scalar& rhs) switch (result.m_type) { case Scalar::e_void: break; - case Scalar::e_schar: - case Scalar::e_uchar: - case Scalar::e_sshort: - case Scalar::e_ushort: - case Scalar::e_sint: - 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: - result.m_integer = a->m_integer - b->m_integer; break; - case Scalar::e_float: - case Scalar::e_double: - case Scalar::e_long_double: - result.m_float = a->m_float - b->m_float; break; + case Scalar::e_sint: result.m_data.sint = a->m_data.sint - b->m_data.sint; break; + case Scalar::e_uint: result.m_data.uint = a->m_data.uint - b->m_data.uint; break; + case Scalar::e_slong: result.m_data.slong = a->m_data.slong - b->m_data.slong; break; + case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong - b->m_data.ulong; break; + case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong - b->m_data.slonglong; break; + case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong - b->m_data.ulonglong; break; + case Scalar::e_float: result.m_data.flt = a->m_data.flt - b->m_data.flt; break; + case Scalar::e_double: result.m_data.dbl = a->m_data.dbl - b->m_data.dbl; break; + case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl - b->m_data.ldbl; break; } } return result; @@ -2776,35 +1576,16 @@ lldb_private::operator/ (const Scalar& lhs, const Scalar& rhs) switch (result.m_type) { case Scalar::e_void: break; - case Scalar::e_schar: - case Scalar::e_uchar: - case Scalar::e_sshort: - case Scalar::e_ushort: - case Scalar::e_sint: - 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: - { - if (b->m_integer != 0) - { - result.m_integer = *a->m_integer.getRawData() / *b->m_integer.getRawData(); - return result; - } - break; - } - case Scalar::e_float: - case Scalar::e_double: - case Scalar::e_long_double: - if (b->m_float.isZero()) - { - result.m_float = a->m_float / b->m_float; - return result; - } - break; + + case Scalar::e_sint: if (b->m_data.sint != 0) { result.m_data.sint = a->m_data.sint/ b->m_data.sint; return result; } break; + case Scalar::e_uint: if (b->m_data.uint != 0) { result.m_data.uint = a->m_data.uint / b->m_data.uint; return result; } break; + case Scalar::e_slong: if (b->m_data.slong != 0) { result.m_data.slong = a->m_data.slong / b->m_data.slong; return result; } break; + case Scalar::e_ulong: if (b->m_data.ulong != 0) { result.m_data.ulong = a->m_data.ulong / b->m_data.ulong; return result; } break; + case Scalar::e_slonglong: if (b->m_data.slonglong != 0) { result.m_data.slonglong = a->m_data.slonglong / b->m_data.slonglong; return result; } break; + case Scalar::e_ulonglong: if (b->m_data.ulonglong != 0) { result.m_data.ulonglong = a->m_data.ulonglong / b->m_data.ulonglong; return result; } break; + case Scalar::e_float: if (b->m_data.flt != 0.0f) { result.m_data.flt = a->m_data.flt / b->m_data.flt; return result; } break; + case Scalar::e_double: if (b->m_data.dbl != 0.0) { result.m_data.dbl = a->m_data.dbl / b->m_data.dbl; return result; } break; + case Scalar::e_long_double: if (b->m_data.ldbl != 0.0) { result.m_data.ldbl = a->m_data.ldbl / b->m_data.ldbl; return result; } break; } } // For division only, the only way it should make it here is if a promotion failed, @@ -2825,23 +1606,15 @@ lldb_private::operator* (const Scalar& lhs, const Scalar& rhs) switch (result.m_type) { case Scalar::e_void: break; - case Scalar::e_schar: - case Scalar::e_uchar: - case Scalar::e_sshort: - case Scalar::e_ushort: - case Scalar::e_sint: - 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: - result.m_integer = a->m_integer * b->m_integer; break; - case Scalar::e_float: - case Scalar::e_double: - case Scalar::e_long_double: - result.m_float = a->m_float * b->m_float; break; + case Scalar::e_sint: result.m_data.sint = a->m_data.sint * b->m_data.sint; break; + case Scalar::e_uint: result.m_data.uint = a->m_data.uint * b->m_data.uint; break; + case Scalar::e_slong: result.m_data.slong = a->m_data.slong * b->m_data.slong; break; + case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong * b->m_data.ulong; break; + case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong * b->m_data.slonglong; break; + case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong * b->m_data.ulonglong; break; + case Scalar::e_float: result.m_data.flt = a->m_data.flt * b->m_data.flt; break; + case Scalar::e_double: result.m_data.dbl = a->m_data.dbl * b->m_data.dbl; break; + case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl * b->m_data.ldbl; break; } } return result; @@ -2858,19 +1631,13 @@ lldb_private::operator& (const Scalar& lhs, const Scalar& rhs) { switch (result.m_type) { - case Scalar::e_schar: - case Scalar::e_uchar: - case Scalar::e_sshort: - case Scalar::e_ushort: - case Scalar::e_sint: - 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: - result.m_integer = a->m_integer & b->m_integer; break; + case Scalar::e_sint: result.m_data.sint = a->m_data.sint & b->m_data.sint; break; + case Scalar::e_uint: result.m_data.uint = a->m_data.uint & b->m_data.uint; break; + case Scalar::e_slong: result.m_data.slong = a->m_data.slong & b->m_data.slong; break; + case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong & b->m_data.ulong; break; + case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong & b->m_data.slonglong; break; + case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong & b->m_data.ulonglong; break; + case Scalar::e_void: case Scalar::e_float: case Scalar::e_double: @@ -2894,19 +1661,12 @@ lldb_private::operator| (const Scalar& lhs, const Scalar& rhs) { switch (result.m_type) { - case Scalar::e_schar: - case Scalar::e_uchar: - case Scalar::e_sshort: - case Scalar::e_ushort: - case Scalar::e_sint: - 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: - result.m_integer = a->m_integer | b->m_integer; break; + case Scalar::e_sint: result.m_data.sint = a->m_data.sint | b->m_data.sint; break; + case Scalar::e_uint: result.m_data.uint = a->m_data.uint | b->m_data.uint; break; + case Scalar::e_slong: result.m_data.slong = a->m_data.slong | b->m_data.slong; break; + case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong | b->m_data.ulong; break; + case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong | b->m_data.slonglong; break; + case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong | b->m_data.ulonglong; break; case Scalar::e_void: case Scalar::e_float: @@ -2932,27 +1692,12 @@ lldb_private::operator% (const Scalar& lhs, const Scalar& rhs) switch (result.m_type) { default: break; - case Scalar::e_void: break; - case Scalar::e_schar: - case Scalar::e_uchar: - case Scalar::e_sshort: - case Scalar::e_ushort: - case Scalar::e_sint: - 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: - { - if (b->m_integer != 0) - { - result.m_integer = *a->m_integer.getRawData() % *b->m_integer.getRawData(); - return result; - } - break; - } + case Scalar::e_sint: if (b->m_data.sint != 0) { result.m_data.sint = a->m_data.sint % b->m_data.sint; return result; } break; + case Scalar::e_uint: if (b->m_data.uint != 0) { result.m_data.uint = a->m_data.uint % b->m_data.uint; return result; } break; + case Scalar::e_slong: if (b->m_data.slong != 0) { result.m_data.slong = a->m_data.slong % b->m_data.slong; return result; } break; + case Scalar::e_ulong: if (b->m_data.ulong != 0) { result.m_data.ulong = a->m_data.ulong % b->m_data.ulong; return result; } break; + case Scalar::e_slonglong: if (b->m_data.slonglong != 0) { result.m_data.slonglong = a->m_data.slonglong % b->m_data.slonglong; return result; } break; + case Scalar::e_ulonglong: if (b->m_data.ulonglong != 0) { result.m_data.ulonglong = a->m_data.ulonglong % b->m_data.ulonglong; return result; } break; } } result.m_type = Scalar::e_void; @@ -2970,19 +1715,12 @@ lldb_private::operator^ (const Scalar& lhs, const Scalar& rhs) { switch (result.m_type) { - case Scalar::e_schar: - case Scalar::e_uchar: - case Scalar::e_sshort: - case Scalar::e_ushort: - case Scalar::e_sint: - 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: - result.m_integer = a->m_integer ^ b->m_integer; break; + case Scalar::e_sint: result.m_data.sint = a->m_data.sint ^ b->m_data.sint; break; + case Scalar::e_uint: result.m_data.uint = a->m_data.uint ^ b->m_data.uint; break; + case Scalar::e_slong: result.m_data.slong = a->m_data.slong ^ b->m_data.slong; break; + case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong ^ b->m_data.ulong; break; + case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong ^ b->m_data.slonglong; break; + case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong ^ b->m_data.ulonglong; break; case Scalar::e_void: case Scalar::e_float: @@ -3016,21 +1754,21 @@ lldb_private::operator>> (const Scalar& lhs, const Scalar &rhs) unsigned int Scalar::RawUInt () const { - return *(const uint_t *) m_integer.getRawData(); + return m_data.uint; } // Return the raw unsigned long without any casting or conversion unsigned long Scalar::RawULong () const { - return *(const ulong_t *) m_integer.getRawData(); + return m_data.ulong; } // Return the raw unsigned long long without any casting or conversion unsigned long long Scalar::RawULongLong () const { - return *(const ulonglong_t *) m_integer.getRawData(); + return m_data.ulonglong; } @@ -3063,11 +1801,9 @@ Scalar::SetValueFromCString (const char *value_str, Encoding encoding, size_t by m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize (byte_size); switch (m_type) { - case e_uchar: m_integer = llvm::APInt(sizeof(uchar_t) * 8, uval64, false); break; - case e_ushort: m_integer = llvm::APInt(sizeof(ushort_t) * 8, uval64, false); break; - case e_uint: m_integer = llvm::APInt(sizeof(uint_t) * 8, uval64, false); break; - case e_ulong: m_integer = llvm::APInt(sizeof(ulong_t) * 8, uval64, false); break; - case e_ulonglong: m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, uval64, false); break; + case e_uint: m_data.uint = (uint_t)uval64; break; + case e_ulong: m_data.ulong = (ulong_t)uval64; break; + case e_ulonglong: m_data.ulonglong = (ulonglong_t)uval64; break; default: error.SetErrorStringWithFormat("unsupported unsigned integer byte size: %" PRIu64 "", (uint64_t)byte_size); break; @@ -3094,11 +1830,9 @@ Scalar::SetValueFromCString (const char *value_str, Encoding encoding, size_t by m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize (byte_size); switch (m_type) { - case e_schar: m_integer = llvm::APInt(sizeof(schar_t) * 8, sval64, true); break; - case e_sshort: m_integer = llvm::APInt(sizeof(sshort_t) * 8, sval64, true); break; - case e_sint: m_integer = llvm::APInt(sizeof(sint_t) * 8, sval64, true); break; - case e_slong: m_integer = llvm::APInt(sizeof(slong_t) * 8, sval64, true); break; - case e_slonglong: m_integer = llvm::APInt(sizeof(slonglong_t) * 8, sval64, true); break; + case e_sint: m_data.sint = (sint_t)sval64; break; + case e_slong: m_data.slong = (slong_t)sval64; break; + case e_slonglong: m_data.slonglong = (slonglong_t)sval64; break; default: error.SetErrorStringWithFormat("unsupported signed integer byte size: %" PRIu64 "", (uint64_t)byte_size); break; @@ -3113,36 +1847,24 @@ Scalar::SetValueFromCString (const char *value_str, Encoding encoding, size_t by break; case eEncodingIEEE754: - static float f_val; - static double d_val; - static long double l_val; if (byte_size == sizeof (float)) { - if (::sscanf (value_str, "%f", &f_val) == 1) - { - m_float = llvm::APFloat(f_val); + if (::sscanf (value_str, "%f", &m_data.flt) == 1) m_type = e_float; - } else error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str); } else if (byte_size == sizeof (double)) { - if (::sscanf (value_str, "%lf", &d_val) == 1) - { - m_float = llvm::APFloat(d_val); + if (::sscanf (value_str, "%lf", &m_data.dbl) == 1) m_type = e_double; - } 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", &l_val) == 1) - { - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&l_val)->x)); + if (::sscanf (value_str, "%Lf", &m_data.ldbl) == 1) m_type = e_long_double; - } else error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str); } @@ -3168,7 +1890,6 @@ Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t b { Error error; - type128 int128; switch (encoding) { case lldb::eEncodingInvalid: @@ -3183,25 +1904,10 @@ Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t b switch (byte_size) { - case 1: operator=((uint8_t)data.GetU8(&offset)); break; - case 2: operator=((uint16_t)data.GetU16(&offset)); break; - case 4: operator=((uint32_t)data.GetU32(&offset)); break; - case 8: operator=((uint64_t)data.GetU64(&offset)); break; - case 16: - { - if (data.GetByteOrder() == eByteOrderBig) - { - int128.x[1] = (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 + 1); - } - operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x)); - break; - } + case 1: operator=((uint8_t)data.GetU8(&offset)); break; + case 2: operator=((uint16_t)data.GetU16(&offset)); break; + case 4: operator=((uint32_t)data.GetU32(&offset)); break; + case 8: operator=((uint64_t)data.GetU64(&offset)); break; default: error.SetErrorStringWithFormat("unsupported unsigned integer byte size: %" PRIu64 "", (uint64_t)byte_size); break; @@ -3218,21 +1924,6 @@ Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t b case 2: operator=((int16_t)data.GetU16(&offset)); break; case 4: operator=((int32_t)data.GetU32(&offset)); break; case 8: operator=((int64_t)data.GetU64(&offset)); break; - case 16: - { - if (data.GetByteOrder() == eByteOrderBig) - { - int128.x[1] = (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 + 1); - } - operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x)); - break; - } default: error.SetErrorStringWithFormat("unsupported signed integer byte size: %" PRIu64 "", (uint64_t)byte_size); break; @@ -3272,28 +1963,50 @@ Scalar::SignExtend (uint32_t sign_bit_pos) case Scalar::e_double: case Scalar::e_long_double: return false; - case Scalar::e_schar: - case Scalar::e_uchar: - case Scalar::e_sshort: - case Scalar::e_ushort: + case Scalar::e_sint: case Scalar::e_uint: + if (max_bit_pos == sign_bit_pos) + return true; + else if (sign_bit_pos < (max_bit_pos-1)) + { + unsigned int sign_bit = 1u << sign_bit_pos; + if (m_data.uint & sign_bit) + { + const unsigned int mask = ~(sign_bit) + 1u; + m_data.uint |= mask; + } + return true; + } + break; + case Scalar::e_slong: case Scalar::e_ulong: + if (max_bit_pos == sign_bit_pos) + return true; + else if (sign_bit_pos < (max_bit_pos-1)) + { + unsigned long sign_bit = 1ul << sign_bit_pos; + if (m_data.ulong & sign_bit) + { + const unsigned long mask = ~(sign_bit) + 1ul; + m_data.ulong |= mask; + } + return true; + } + break; + case Scalar::e_slonglong: case Scalar::e_ulonglong: - case Scalar::e_sint128: - case Scalar::e_uint128: if (max_bit_pos == sign_bit_pos) return true; else if (sign_bit_pos < (max_bit_pos-1)) { - llvm::APInt sign_bit = llvm::APInt::getSignBit(sign_bit_pos + 1); - llvm::APInt bitwize_and = m_integer & sign_bit; - if (bitwize_and.getBoolValue()) + unsigned long long sign_bit = 1ull << sign_bit_pos; + if (m_data.ulonglong & sign_bit) { - const llvm::APInt mask = ~(sign_bit) + llvm::APInt(m_integer.getBitWidth(), 1); - m_integer |= mask; + const unsigned long long mask = ~(sign_bit) + 1ull; + m_data.ulonglong |= mask; } return true; } @@ -3340,44 +2053,66 @@ Scalar::ExtractBitfield (uint32_t bit_size, uint32_t msbit = bit_offset + bit_size - 1; uint32_t lsbit = bit_offset; - uint64_t result; switch (m_type) { case Scalar::e_void: break; case e_float: - result = SignedBits ((uint64_t )m_float.convertToFloat(), msbit, lsbit); - m_float = llvm::APFloat((float_t)result); + if (sizeof(m_data.flt) == sizeof(sint_t)) + m_data.sint = (sint_t)SignedBits (m_data.sint, msbit, lsbit); + else if (sizeof(m_data.flt) == sizeof(ulong_t)) + m_data.slong = (slong_t)SignedBits (m_data.slong, msbit, lsbit); + else if (sizeof(m_data.flt) == sizeof(ulonglong_t)) + m_data.slonglong = (slonglong_t)SignedBits (m_data.slonglong, msbit, lsbit); + else + return false; return true; + case e_double: - result = SignedBits ((uint64_t )m_float.convertToDouble(), msbit, lsbit); - m_float = llvm::APFloat((double_t)result); + if (sizeof(m_data.dbl) == sizeof(sint_t)) + m_data.sint = SignedBits (m_data.sint, msbit, lsbit); + else if (sizeof(m_data.dbl) == sizeof(ulong_t)) + m_data.slong = SignedBits (m_data.slong, msbit, lsbit); + else if (sizeof(m_data.dbl) == sizeof(ulonglong_t)) + m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit); + else + return false; + 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)); + if (sizeof(m_data.ldbl) == sizeof(sint_t)) + m_data.sint = SignedBits (m_data.sint, msbit, lsbit); + else if (sizeof(m_data.ldbl) == sizeof(ulong_t)) + m_data.slong = SignedBits (m_data.slong, msbit, lsbit); + else if (sizeof(m_data.ldbl) == sizeof(ulonglong_t)) + m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit); else - m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&result)->x)); + return false; return true; - case Scalar::e_schar: - case Scalar::e_sshort: case Scalar::e_sint: - case Scalar::e_slong: - case Scalar::e_slonglong: - case Scalar::e_sint128: - m_integer = SignedBits (*m_integer.getRawData(), msbit, lsbit); + m_data.sint = (sint_t)SignedBits (m_data.sint, msbit, lsbit); return true; - case Scalar::e_uchar: - case Scalar::e_ushort: case Scalar::e_uint: + m_data.uint = (uint_t)UnsignedBits (m_data.uint, msbit, lsbit); + return true; + + case Scalar::e_slong: + m_data.slong = (slong_t)SignedBits (m_data.slong, msbit, lsbit); + return true; + case Scalar::e_ulong: + m_data.ulong = (ulong_t)UnsignedBits (m_data.ulong, msbit, lsbit); + return true; + + case Scalar::e_slonglong: + m_data.slonglong = (slonglong_t)SignedBits (m_data.slonglong, msbit, lsbit); + return true; + case Scalar::e_ulonglong: - case Scalar::e_uint128: - m_integer = UnsignedBits (*m_integer.getRawData(), msbit, lsbit); + m_data.ulonglong = (ulonglong_t)UnsignedBits (m_data.ulonglong, msbit, lsbit); return true; } return false; @@ -3397,29 +2132,18 @@ lldb_private::operator== (const Scalar& lhs, const Scalar& rhs) Scalar temp_value; const Scalar* a; const Scalar* b; - llvm::APFloat::cmpResult result; switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) { case Scalar::e_void: break; - case Scalar::e_schar: - case Scalar::e_uchar: - case Scalar::e_sshort: - case Scalar::e_ushort: - case Scalar::e_sint: - 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: - return a->m_integer == b->m_integer; - case Scalar::e_float: - case Scalar::e_double: - case Scalar::e_long_double: - result = a->m_float.compare(b->m_float); - if(result == llvm::APFloat::cmpEqual) - return true; + case Scalar::e_sint: return a->m_data.sint == b->m_data.sint; + case Scalar::e_uint: return a->m_data.uint == b->m_data.uint; + case Scalar::e_slong: return a->m_data.slong == b->m_data.slong; + case Scalar::e_ulong: return a->m_data.ulong == b->m_data.ulong; + case Scalar::e_slonglong: return a->m_data.slonglong == b->m_data.slonglong; + case Scalar::e_ulonglong: return a->m_data.ulonglong == b->m_data.ulonglong; + case Scalar::e_float: return a->m_data.flt == b->m_data.flt; + case Scalar::e_double: return a->m_data.dbl == b->m_data.dbl; + case Scalar::e_long_double: return a->m_data.ldbl == b->m_data.ldbl; } return false; } @@ -3434,29 +2158,18 @@ lldb_private::operator!= (const Scalar& lhs, const Scalar& rhs) Scalar temp_value; // A temp value that might get a copy of either promoted value const Scalar* a; const Scalar* b; - llvm::APFloat::cmpResult result; switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) { case Scalar::e_void: break; - case Scalar::e_schar: - case Scalar::e_uchar: - case Scalar::e_sshort: - case Scalar::e_ushort: - case Scalar::e_sint: - 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: - return a->m_integer != b->m_integer; - case Scalar::e_float: - case Scalar::e_double: - case Scalar::e_long_double: - result = a->m_float.compare(b->m_float); - if(result != llvm::APFloat::cmpEqual) - return true; + case Scalar::e_sint: return a->m_data.sint != b->m_data.sint; + case Scalar::e_uint: return a->m_data.uint != b->m_data.uint; + case Scalar::e_slong: return a->m_data.slong != b->m_data.slong; + case Scalar::e_ulong: return a->m_data.ulong != b->m_data.ulong; + case Scalar::e_slonglong: return a->m_data.slonglong != b->m_data.slonglong; + case Scalar::e_ulonglong: return a->m_data.ulonglong != b->m_data.ulonglong; + case Scalar::e_float: return a->m_data.flt != b->m_data.flt; + case Scalar::e_double: return a->m_data.dbl != b->m_data.dbl; + case Scalar::e_long_double: return a->m_data.ldbl != b->m_data.ldbl; } return true; } @@ -3470,29 +2183,18 @@ lldb_private::operator< (const Scalar& lhs, const Scalar& rhs) Scalar temp_value; const Scalar* a; const Scalar* b; - llvm::APFloat::cmpResult result; switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) { case Scalar::e_void: break; - case Scalar::e_schar: - case Scalar::e_uchar: - case Scalar::e_sshort: - case Scalar::e_ushort: - case Scalar::e_sint: - 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: - return a->m_integer < b->m_integer; - case Scalar::e_float: - case Scalar::e_double: - case Scalar::e_long_double: - result = a->m_float.compare(b->m_float); - if(result == llvm::APFloat::cmpLessThan) - return true; + case Scalar::e_sint: return a->m_data.sint < b->m_data.sint; + case Scalar::e_uint: return a->m_data.uint < b->m_data.uint; + case Scalar::e_slong: return a->m_data.slong < b->m_data.slong; + case Scalar::e_ulong: return a->m_data.ulong < b->m_data.ulong; + case Scalar::e_slonglong: return a->m_data.slonglong < b->m_data.slonglong; + case Scalar::e_ulonglong: return a->m_data.ulonglong < b->m_data.ulonglong; + case Scalar::e_float: return a->m_data.flt < b->m_data.flt; + case Scalar::e_double: return a->m_data.dbl < b->m_data.dbl; + case Scalar::e_long_double: return a->m_data.ldbl < b->m_data.ldbl; } return false; } @@ -3506,29 +2208,18 @@ lldb_private::operator<= (const Scalar& lhs, const Scalar& rhs) Scalar temp_value; const Scalar* a; const Scalar* b; - llvm::APFloat::cmpResult result; switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) { case Scalar::e_void: break; - case Scalar::e_schar: - case Scalar::e_uchar: - case Scalar::e_sshort: - case Scalar::e_ushort: - case Scalar::e_sint: - 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: - return a->m_integer <= b->m_integer; - case Scalar::e_float: - case Scalar::e_double: - case Scalar::e_long_double: - result = a->m_float.compare(b->m_float); - if(result == llvm::APFloat::cmpLessThan || result == llvm::APFloat::cmpEqual) - return true; + case Scalar::e_sint: return a->m_data.sint <= b->m_data.sint; + case Scalar::e_uint: return a->m_data.uint <= b->m_data.uint; + case Scalar::e_slong: return a->m_data.slong <= b->m_data.slong; + case Scalar::e_ulong: return a->m_data.ulong <= b->m_data.ulong; + case Scalar::e_slonglong: return a->m_data.slonglong <= b->m_data.slonglong; + case Scalar::e_ulonglong: return a->m_data.ulonglong <= b->m_data.ulonglong; + case Scalar::e_float: return a->m_data.flt <= b->m_data.flt; + case Scalar::e_double: return a->m_data.dbl <= b->m_data.dbl; + case Scalar::e_long_double: return a->m_data.ldbl <= b->m_data.ldbl; } return false; } @@ -3543,28 +2234,18 @@ lldb_private::operator> (const Scalar& lhs, const Scalar& rhs) Scalar temp_value; const Scalar* a; const Scalar* b; - llvm::APFloat::cmpResult result; switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) { - case Scalar::e_void: break; - case Scalar::e_schar: - case Scalar::e_uchar: - case Scalar::e_sshort: - case Scalar::e_ushort: - case Scalar::e_sint: - 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_float: - case Scalar::e_double: - case Scalar::e_long_double: - result = a->m_float.compare(b->m_float); - if(result == llvm::APFloat::cmpGreaterThan) - return true; + case Scalar::e_void: break; + case Scalar::e_sint: return a->m_data.sint > b->m_data.sint; + case Scalar::e_uint: return a->m_data.uint > b->m_data.uint; + case Scalar::e_slong: return a->m_data.slong > b->m_data.slong; + case Scalar::e_ulong: return a->m_data.ulong > b->m_data.ulong; + case Scalar::e_slonglong: return a->m_data.slonglong > b->m_data.slonglong; + case Scalar::e_ulonglong: return a->m_data.ulonglong > b->m_data.ulonglong; + case Scalar::e_float: return a->m_data.flt > b->m_data.flt; + case Scalar::e_double: return a->m_data.dbl > b->m_data.dbl; + case Scalar::e_long_double: return a->m_data.ldbl > b->m_data.ldbl; } return false; } @@ -3578,81 +2259,22 @@ lldb_private::operator>= (const Scalar& lhs, const Scalar& rhs) Scalar temp_value; const Scalar* a; const Scalar* b; - llvm::APFloat::cmpResult result; switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) { - case Scalar::e_void: break; - case Scalar::e_schar: - case Scalar::e_uchar: - case Scalar::e_sshort: - case Scalar::e_ushort: - case Scalar::e_sint: - 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: - return a->m_integer <= b->m_integer; - case Scalar::e_float: - case Scalar::e_double: - case Scalar::e_long_double: - result = a->m_float.compare(b->m_float); - if(result == llvm::APFloat::cmpGreaterThan || result == llvm::APFloat::cmpEqual) - return true; + case Scalar::e_void: break; + case Scalar::e_sint: return a->m_data.sint >= b->m_data.sint; + case Scalar::e_uint: return a->m_data.uint >= b->m_data.uint; + case Scalar::e_slong: return a->m_data.slong >= b->m_data.slong; + case Scalar::e_ulong: return a->m_data.ulong >= b->m_data.ulong; + case Scalar::e_slonglong: return a->m_data.slonglong >= b->m_data.slonglong; + case Scalar::e_ulonglong: return a->m_data.ulonglong >= b->m_data.ulonglong; + case Scalar::e_float: return a->m_data.flt >= b->m_data.flt; + case Scalar::e_double: return a->m_data.dbl >= b->m_data.dbl; + case Scalar::e_long_double: return a->m_data.ldbl >= b->m_data.ldbl; } return false; } -bool -Scalar::ClearBit (uint32_t bit) -{ - switch (m_type) - { - case e_void: - break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: m_integer.clearBit(bit); return true; - case e_float: - case e_double: - case e_long_double: break; - } - return false; -} -bool -Scalar::SetBit (uint32_t bit) -{ - switch (m_type) - { - case e_void: - break; - case e_schar: - case e_uchar: - case e_sshort: - case e_ushort: - case e_sint: - case e_uint: - case e_slong: - case e_ulong: - case e_slonglong: - case e_ulonglong: - case e_sint128: - case e_uint128: m_integer.setBit(bit); return true; - case e_float: - case e_double: - case e_long_double: break; - } - return false; -} + + diff --git a/lldb/source/Core/ValueObject.cpp b/lldb/source/Core/ValueObject.cpp index 6fb5f58..abdc4ec 100644 --- a/lldb/source/Core/ValueObject.cpp +++ b/lldb/source/Core/ValueObject.cpp @@ -1897,7 +1897,7 @@ ValueObject::SetValueFromCString (const char *value_str, Error& error) // If the value is already a scalar, then let the scalar change itself: m_value.GetScalar().SetValueFromCString (value_str, encoding, byte_size); } - else if (byte_size <= 16) + else if (byte_size <= Scalar::GetMaxByteSize()) { // If the value fits in a scalar, then make a new scalar and again let the // scalar code do the conversion, then figure out where to put the new value. diff --git a/lldb/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp b/lldb/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp index 66866c7..9b8ea34 100644 --- a/lldb/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp +++ b/lldb/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp @@ -33,7 +33,7 @@ #include "llvm/ADT/STLExtras.h" #include "Plugins/Process/Utility/InstructionUtils.h" -#include "Plugins/Process/Utility/RegisterContext_mips.h" //mips32 has same registers nos as mips64 +#include "Plugins/Process/Utility/RegisterContext_mips64.h" //mips32 has same registers nos as mips64 using namespace lldb; using namespace lldb_private; @@ -302,38 +302,38 @@ EmulateInstructionMIPS::GetRegisterName (unsigned reg_num, bool alternate_name) case gcc_dwarf_bad_mips: return "bad"; case gcc_dwarf_cause_mips: return "cause"; case gcc_dwarf_pc_mips: return "pc"; - case gcc_dwarf_f0_mips: return "f0"; - case gcc_dwarf_f1_mips: return "f1"; - case gcc_dwarf_f2_mips: return "f2"; - case gcc_dwarf_f3_mips: return "f3"; - case gcc_dwarf_f4_mips: return "f4"; - case gcc_dwarf_f5_mips: return "f5"; - case gcc_dwarf_f6_mips: return "f6"; - case gcc_dwarf_f7_mips: return "f7"; - case gcc_dwarf_f8_mips: return "f8"; - case gcc_dwarf_f9_mips: return "f9"; - case gcc_dwarf_f10_mips: return "f10"; - case gcc_dwarf_f11_mips: return "f11"; - case gcc_dwarf_f12_mips: return "f12"; - case gcc_dwarf_f13_mips: return "f13"; - case gcc_dwarf_f14_mips: return "f14"; - case gcc_dwarf_f15_mips: return "f15"; - case gcc_dwarf_f16_mips: return "f16"; - case gcc_dwarf_f17_mips: return "f17"; - case gcc_dwarf_f18_mips: return "f18"; - case gcc_dwarf_f19_mips: return "f19"; - case gcc_dwarf_f20_mips: return "f20"; - case gcc_dwarf_f21_mips: return "f21"; - case gcc_dwarf_f22_mips: return "f22"; - case gcc_dwarf_f23_mips: return "f23"; - case gcc_dwarf_f24_mips: return "f24"; - case gcc_dwarf_f25_mips: return "f25"; - case gcc_dwarf_f26_mips: return "f26"; - case gcc_dwarf_f27_mips: return "f27"; - case gcc_dwarf_f28_mips: return "f28"; - case gcc_dwarf_f29_mips: return "f29"; - case gcc_dwarf_f30_mips: return "f30"; - case gcc_dwarf_f31_mips: return "f31"; + case gcc_dwarf_f0_mips: return "fp_reg[0]"; + case gcc_dwarf_f1_mips: return "fp_reg[1]"; + case gcc_dwarf_f2_mips: return "fp_reg[2]"; + case gcc_dwarf_f3_mips: return "fp_reg[3]"; + case gcc_dwarf_f4_mips: return "fp_reg[4]"; + case gcc_dwarf_f5_mips: return "fp_reg[5]"; + case gcc_dwarf_f6_mips: return "fp_reg[6]"; + case gcc_dwarf_f7_mips: return "fp_reg[7]"; + case gcc_dwarf_f8_mips: return "fp_reg[8]"; + case gcc_dwarf_f9_mips: return "fp_reg[9]"; + case gcc_dwarf_f10_mips: return "fp_reg[10]"; + case gcc_dwarf_f11_mips: return "fp_reg[11]"; + case gcc_dwarf_f12_mips: return "fp_reg[12]"; + case gcc_dwarf_f13_mips: return "fp_reg[13]"; + case gcc_dwarf_f14_mips: return "fp_reg[14]"; + case gcc_dwarf_f15_mips: return "fp_reg[15]"; + case gcc_dwarf_f16_mips: return "fp_reg[16]"; + case gcc_dwarf_f17_mips: return "fp_reg[17]"; + case gcc_dwarf_f18_mips: return "fp_reg[18]"; + case gcc_dwarf_f19_mips: return "fp_reg[19]"; + case gcc_dwarf_f20_mips: return "fp_reg[20]"; + case gcc_dwarf_f21_mips: return "fp_reg[21]"; + case gcc_dwarf_f22_mips: return "fp_reg[22]"; + case gcc_dwarf_f23_mips: return "fp_reg[23]"; + case gcc_dwarf_f24_mips: return "fp_reg[24]"; + case gcc_dwarf_f25_mips: return "fp_reg[25]"; + case gcc_dwarf_f26_mips: return "fp_reg[26]"; + case gcc_dwarf_f27_mips: return "fp_reg[27]"; + case gcc_dwarf_f28_mips: return "fp_reg[28]"; + case gcc_dwarf_f29_mips: return "fp_reg[29]"; + case gcc_dwarf_f30_mips: return "fp_reg[30]"; + case gcc_dwarf_f31_mips: return "fp_reg[31]"; case gcc_dwarf_fcsr_mips: return "fcsr"; case gcc_dwarf_fir_mips: return "fir"; } diff --git a/lldb/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp b/lldb/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp index d535b3f..09bbcbd 100644 --- a/lldb/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp +++ b/lldb/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp @@ -33,7 +33,7 @@ #include "llvm/ADT/STLExtras.h" #include "Plugins/Process/Utility/InstructionUtils.h" -#include "Plugins/Process/Utility/RegisterContext_mips.h" +#include "Plugins/Process/Utility/RegisterContext_mips64.h" using namespace lldb; using namespace lldb_private; @@ -302,38 +302,38 @@ EmulateInstructionMIPS64::GetRegisterName (unsigned reg_num, bool alternate_name case gcc_dwarf_bad_mips64: return "bad"; case gcc_dwarf_cause_mips64: return "cause"; case gcc_dwarf_pc_mips64: return "pc"; - case gcc_dwarf_f0_mips64: return "f0"; - case gcc_dwarf_f1_mips64: return "f1"; - case gcc_dwarf_f2_mips64: return "f2"; - case gcc_dwarf_f3_mips64: return "f3"; - case gcc_dwarf_f4_mips64: return "f4"; - case gcc_dwarf_f5_mips64: return "f5"; - case gcc_dwarf_f6_mips64: return "f6"; - case gcc_dwarf_f7_mips64: return "f7"; - case gcc_dwarf_f8_mips64: return "f8"; - case gcc_dwarf_f9_mips64: return "f9"; - case gcc_dwarf_f10_mips64: return "f10"; - case gcc_dwarf_f11_mips64: return "f11"; - case gcc_dwarf_f12_mips64: return "f12"; - case gcc_dwarf_f13_mips64: return "f13"; - case gcc_dwarf_f14_mips64: return "f14"; - case gcc_dwarf_f15_mips64: return "f15"; - case gcc_dwarf_f16_mips64: return "f16"; - case gcc_dwarf_f17_mips64: return "f17"; - case gcc_dwarf_f18_mips64: return "f18"; - case gcc_dwarf_f19_mips64: return "f19"; - case gcc_dwarf_f20_mips64: return "f20"; - case gcc_dwarf_f21_mips64: return "f21"; - case gcc_dwarf_f22_mips64: return "f22"; - case gcc_dwarf_f23_mips64: return "f23"; - case gcc_dwarf_f24_mips64: return "f24"; - case gcc_dwarf_f25_mips64: return "f25"; - case gcc_dwarf_f26_mips64: return "f26"; - case gcc_dwarf_f27_mips64: return "f27"; - case gcc_dwarf_f28_mips64: return "f28"; - case gcc_dwarf_f29_mips64: return "f29"; - case gcc_dwarf_f30_mips64: return "f30"; - case gcc_dwarf_f31_mips64: return "f31"; + case gcc_dwarf_f0_mips64: return "fp_reg[0]"; + case gcc_dwarf_f1_mips64: return "fp_reg[1]"; + case gcc_dwarf_f2_mips64: return "fp_reg[2]"; + case gcc_dwarf_f3_mips64: return "fp_reg[3]"; + case gcc_dwarf_f4_mips64: return "fp_reg[4]"; + case gcc_dwarf_f5_mips64: return "fp_reg[5]"; + case gcc_dwarf_f6_mips64: return "fp_reg[6]"; + case gcc_dwarf_f7_mips64: return "fp_reg[7]"; + case gcc_dwarf_f8_mips64: return "fp_reg[8]"; + case gcc_dwarf_f9_mips64: return "fp_reg[9]"; + case gcc_dwarf_f10_mips64: return "fp_reg[10]"; + case gcc_dwarf_f11_mips64: return "fp_reg[11]"; + case gcc_dwarf_f12_mips64: return "fp_reg[12]"; + case gcc_dwarf_f13_mips64: return "fp_reg[13]"; + case gcc_dwarf_f14_mips64: return "fp_reg[14]"; + case gcc_dwarf_f15_mips64: return "fp_reg[15]"; + case gcc_dwarf_f16_mips64: return "fp_reg[16]"; + case gcc_dwarf_f17_mips64: return "fp_reg[17]"; + case gcc_dwarf_f18_mips64: return "fp_reg[18]"; + case gcc_dwarf_f19_mips64: return "fp_reg[19]"; + case gcc_dwarf_f20_mips64: return "fp_reg[20]"; + case gcc_dwarf_f21_mips64: return "fp_reg[21]"; + case gcc_dwarf_f22_mips64: return "fp_reg[22]"; + case gcc_dwarf_f23_mips64: return "fp_reg[23]"; + case gcc_dwarf_f24_mips64: return "fp_reg[24]"; + case gcc_dwarf_f25_mips64: return "fp_reg[25]"; + case gcc_dwarf_f26_mips64: return "fp_reg[26]"; + case gcc_dwarf_f27_mips64: return "fp_reg[27]"; + case gcc_dwarf_f28_mips64: return "fp_reg[28]"; + case gcc_dwarf_f29_mips64: return "fp_reg[29]"; + case gcc_dwarf_f30_mips64: return "fp_reg[30]"; + case gcc_dwarf_f31_mips64: return "fp_reg[31]"; case gcc_dwarf_fcsr_mips64: return "fcsr"; case gcc_dwarf_fir_mips64: return "fir"; } diff --git a/lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp b/lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp index df0a008..9628b4e 100644 --- a/lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp +++ b/lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp @@ -136,7 +136,7 @@ NativeRegisterContextLinux::ReadFPR() { void* buf = GetFPRBuffer(); if (!buf) - return Error("FPR buffer is NULL"); + return Error("GPR buffer is NULL"); size_t buf_size = GetFPRSize(); return DoReadFPR(buf, buf_size); @@ -147,7 +147,7 @@ NativeRegisterContextLinux::WriteFPR() { void* buf = GetFPRBuffer(); if (!buf) - return Error("FPR buffer is NULL"); + return Error("GPR buffer is NULL"); size_t buf_size = GetFPRSize(); return DoWriteFPR(buf, buf_size); diff --git a/lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp b/lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp index 4be535f..917f135 100644 --- a/lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp +++ b/lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp @@ -25,10 +25,6 @@ #include "Plugins/Process/Linux/Procfs.h" #include "Plugins/Process/Utility/RegisterContextLinux_mips64.h" #include "Plugins/Process/Utility/RegisterContextLinux_mips.h" -#define NT_MIPS_MSA 0x600 -#define CONFIG5_FRE (1 << 8) -#define SR_FR (1 << 26) -#define NUM_REGISTERS 32 #include #include @@ -122,13 +118,12 @@ namespace gpr_sp_mips, gpr_r30_mips, gpr_ra_mips, - gpr_sr_mips, gpr_mullo_mips, gpr_mulhi_mips, + gpr_pc_mips, gpr_badvaddr_mips, + gpr_sr_mips, gpr_cause_mips, - gpr_pc_mips, - gpr_config5_mips, LLDB_INVALID_REGNUM // register sets need to end with this flag }; @@ -173,60 +168,12 @@ namespace fpr_f31_mips, fpr_fcsr_mips, fpr_fir_mips, - fpr_config5_mips, LLDB_INVALID_REGNUM // register sets need to end with this flag }; static_assert((sizeof(g_fp_regnums_mips) / sizeof(g_fp_regnums_mips[0])) - 1 == k_num_fpr_registers_mips, "g_fp_regnums_mips has wrong number of register infos"); - // mips MSA registers. - const uint32_t - g_msa_regnums_mips[] = - { - msa_w0_mips, - msa_w1_mips, - msa_w2_mips, - msa_w3_mips, - msa_w4_mips, - msa_w5_mips, - msa_w6_mips, - msa_w7_mips, - msa_w8_mips, - msa_w9_mips, - msa_w10_mips, - msa_w11_mips, - msa_w12_mips, - msa_w13_mips, - msa_w14_mips, - msa_w15_mips, - msa_w16_mips, - msa_w17_mips, - msa_w18_mips, - msa_w19_mips, - msa_w20_mips, - msa_w21_mips, - msa_w22_mips, - msa_w23_mips, - msa_w24_mips, - msa_w25_mips, - msa_w26_mips, - msa_w27_mips, - msa_w28_mips, - msa_w29_mips, - msa_w30_mips, - msa_w31_mips, - msa_fcsr_mips, - msa_fir_mips, - msa_mcsr_mips, - msa_mir_mips, - msa_config5_mips, - LLDB_INVALID_REGNUM // register sets need to end with this flag - }; - - static_assert((sizeof(g_msa_regnums_mips) / sizeof(g_msa_regnums_mips[0])) - 1 == k_num_msa_registers_mips, - "g_msa_regnums_mips has wrong number of register infos"); - // mips64 general purpose registers. const uint32_t g_gp_regnums_mips64[] = @@ -263,13 +210,14 @@ namespace gpr_sp_mips64, gpr_r30_mips64, gpr_ra_mips64, - gpr_sr_mips64, gpr_mullo_mips64, gpr_mulhi_mips64, + gpr_pc_mips64, gpr_badvaddr_mips64, + gpr_sr_mips64, gpr_cause_mips64, - gpr_pc_mips64, - gpr_config5_mips64, + gpr_ic_mips64, + gpr_dummy_mips64, LLDB_INVALID_REGNUM // register sets need to end with this flag }; @@ -314,64 +262,16 @@ namespace fpr_f31_mips64, fpr_fcsr_mips64, fpr_fir_mips64, - fpr_config5_mips64, LLDB_INVALID_REGNUM // register sets need to end with this flag }; static_assert((sizeof(g_fp_regnums_mips64) / sizeof(g_fp_regnums_mips64[0])) - 1 == k_num_fpr_registers_mips64, "g_fp_regnums_mips64 has wrong number of register infos"); - // mips64 MSA registers. - const uint32_t - g_msa_regnums_mips64[] = - { - msa_w0_mips64, - msa_w1_mips64, - msa_w2_mips64, - msa_w3_mips64, - msa_w4_mips64, - msa_w5_mips64, - msa_w6_mips64, - msa_w7_mips64, - msa_w8_mips64, - msa_w9_mips64, - msa_w10_mips64, - msa_w11_mips64, - msa_w12_mips64, - msa_w13_mips64, - msa_w14_mips64, - msa_w15_mips64, - msa_w16_mips64, - msa_w17_mips64, - msa_w18_mips64, - msa_w19_mips64, - msa_w20_mips64, - msa_w21_mips64, - msa_w22_mips64, - msa_w23_mips64, - msa_w24_mips64, - msa_w25_mips64, - msa_w26_mips64, - msa_w27_mips64, - msa_w28_mips64, - msa_w29_mips64, - msa_w30_mips64, - msa_w31_mips64, - msa_fcsr_mips64, - msa_fir_mips64, - msa_mcsr_mips64, - msa_mir_mips64, - msa_config5_mips64, - LLDB_INVALID_REGNUM // register sets need to end with this flag - }; - - static_assert((sizeof(g_msa_regnums_mips64) / sizeof(g_msa_regnums_mips64[0])) - 1 == k_num_msa_registers_mips64, - "g_msa_regnums_mips64 has wrong number of register infos"); - // Number of register sets provided by this context. enum { - k_num_register_sets = 3 + k_num_register_sets = 2 }; // Register sets for mips. @@ -379,8 +279,7 @@ namespace g_reg_sets_mips[k_num_register_sets] = { { "General Purpose Registers", "gpr", k_num_gpr_registers_mips, g_gp_regnums_mips }, - { "Floating Point Registers", "fpu", k_num_fpr_registers_mips, g_fp_regnums_mips }, - { "MSA Registers", "msa", k_num_msa_registers_mips, g_msa_regnums_mips } + { "Floating Point Registers", "fpu", k_num_fpr_registers_mips, g_fp_regnums_mips } }; // Register sets for mips64. @@ -388,8 +287,7 @@ namespace g_reg_sets_mips64[k_num_register_sets] = { { "General Purpose Registers", "gpr", k_num_gpr_registers_mips64, g_gp_regnums_mips64 }, - { "Floating Point Registers", "fpu", k_num_fpr_registers_mips64, g_fp_regnums_mips64 }, - { "MSA Registers", "msa", k_num_msa_registers_mips64, g_msa_regnums_mips64 }, + { "Floating Point Registers", "fpu", k_num_fpr_registers_mips64, g_fp_regnums_mips64 } }; } // end of anonymous namespace @@ -402,7 +300,7 @@ NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(const ArchSpec& return new NativeRegisterContextLinux_mips64(target_arch, native_thread, concrete_frame_idx); } -#define REG_CONTEXT_SIZE (GetRegisterInfoInterface ().GetGPRSize () + sizeof(FPR_linux_mips) + sizeof(MSA_linux_mips)) +#define REG_CONTEXT_SIZE (GetRegisterInfoInterface ().GetGPRSize () + sizeof(FPR_mips)) // ---------------------------------------------------------------------------- // NativeRegisterContextLinux_mips64 members. @@ -440,8 +338,6 @@ NativeRegisterContextLinux_mips64::NativeRegisterContextLinux_mips64 (const Arch m_reg_info.last_gpr = k_last_gpr_mips; m_reg_info.first_fpr = k_first_fpr_mips; m_reg_info.last_fpr = k_last_fpr_mips; - m_reg_info.first_msa = k_first_msa_mips; - m_reg_info.last_msa = k_last_msa_mips; break; case llvm::Triple::mips64: case llvm::Triple::mips64el: @@ -451,27 +347,18 @@ NativeRegisterContextLinux_mips64::NativeRegisterContextLinux_mips64 (const Arch m_reg_info.last_gpr = k_last_gpr_mips64; m_reg_info.first_fpr = k_first_fpr_mips64; m_reg_info.last_fpr = k_last_fpr_mips64; - m_reg_info.first_msa = k_first_msa_mips64; - m_reg_info.last_msa = k_last_msa_mips64; break; default: assert(false && "Unhandled target architecture."); break; } - // Initialize m_iovec to point to the buffer and buffer size - // using the conventions of Berkeley style UIO structures, as required - // by PTRACE extensions. - m_iovec.iov_base = &m_msa; - m_iovec.iov_len = sizeof(MSA_linux_mips); + // Clear out the FPR state. + ::memset(&m_fpr, 0, sizeof(FPR_mips)); // init h/w watchpoint addr map for (int index = 0;index <= MAX_NUM_WP; index++) hw_addr_map[index] = LLDB_INVALID_ADDRESS; - - ::memset(&m_gpr, 0, sizeof(GPR_linux_mips)); - ::memset(&m_fpr, 0, sizeof(FPR_linux_mips)); - ::memset(&m_msa, 0, sizeof(MSA_linux_mips)); } uint32_t @@ -573,38 +460,16 @@ NativeRegisterContextLinux_mips64::ReadRegister (const RegisterInfo *reg_info, R return error; } - if (IsMSA(reg) && !IsMSAAvailable()) - { - error.SetErrorString ("MSA not available on this processor"); - return error; - } - - if (IsMSA(reg) || IsFPR(reg)) + if (IsFPR(reg)) { - uint8_t *src; - type128 int128; - - error = ReadCP1(); - + error = ReadFPR(); if (!error.Success()) { - error.SetErrorString ("failed to read co-processor 1 register"); + error.SetErrorString ("failed to read floating point register"); return error; } - - if (IsFPR(reg)) - { - assert (reg_info->byte_offset < sizeof(UserArea)); - src = (uint8_t *)&m_fpr + reg_info->byte_offset - (sizeof(m_gpr)); - } - else - { - assert (reg_info->byte_offset < sizeof(UserArea)); - src = (uint8_t *)&m_msa + reg_info->byte_offset - (sizeof(m_gpr) + sizeof(m_fpr)); - } - int128.x[0] = *(uint64_t *)src; - int128.x[1] = *(uint64_t *)(src + 8); - llvm::APInt rhs = llvm::APInt(128, 2, int128.x); + assert (reg_info->byte_offset < sizeof(FPR_mips)); + uint8_t *src = (uint8_t *)&m_fpr + reg_info->byte_offset; switch (reg_info->byte_size) { case 4: @@ -613,9 +478,6 @@ NativeRegisterContextLinux_mips64::ReadRegister (const RegisterInfo *reg_info, R case 8: reg_value.SetUInt64(*(uint64_t *)src); break; - case 16: - reg_value.SetUInt128(rhs); - break; default: assert(false && "Unhandled data size."); error.SetErrorStringWithFormat ("unhandled byte size: %" PRIu32, reg_info->byte_size); @@ -649,32 +511,10 @@ NativeRegisterContextLinux_mips64::WriteRegister (const RegisterInfo *reg_info, if (reg_index == LLDB_INVALID_REGNUM) return Error ("no lldb regnum for %s", reg_info && reg_info->name ? reg_info->name : ""); - if (IsMSA(reg_index) && !IsMSAAvailable()) - { - error.SetErrorString ("MSA not available on this processor"); - return error; - } - - if (IsFPR(reg_index) || IsMSA(reg_index)) + if (IsFPR(reg_index)) { - uint8_t *dst; - const uint64_t *src; - - // Initialise the FP and MSA buffers by reading all co-processor 1 registers - ReadCP1(); - - if (IsFPR(reg_index)) - { - assert (reg_info->byte_offset < sizeof(UserArea)); - dst = (uint8_t *)&m_fpr + reg_info->byte_offset - (sizeof(m_gpr)); - } - else - { - assert (reg_info->byte_offset < sizeof(UserArea)); - dst = (uint8_t *)&m_msa + reg_info->byte_offset - (sizeof(m_gpr) + sizeof(m_fpr)); - } - llvm::APInt lhs; - llvm::APInt fail_value = llvm::APInt::getMaxValue(128); + assert (reg_info->byte_offset < sizeof(FPR_mips)); + uint8_t *dst = (uint8_t *)&m_fpr + reg_info->byte_offset; switch (reg_info->byte_size) { case 4: @@ -683,21 +523,15 @@ NativeRegisterContextLinux_mips64::WriteRegister (const RegisterInfo *reg_info, case 8: *(uint64_t *)dst = reg_value.GetAsUInt64(); break; - case 16: - lhs = reg_value.GetAsUInt128(fail_value); - src = lhs.getRawData(); - *(uint64_t *)dst = *src; - *(uint64_t *)(dst + 8) = *(src + 1); - break; default: assert(false && "Unhandled data size."); error.SetErrorStringWithFormat ("unhandled byte size: %" PRIu32, reg_info->byte_size); break; } - error = WriteCP1(); + error = WriteFPR(); if (!error.Success()) { - error.SetErrorString ("failed to write co-processor 1 register"); + error.SetErrorString ("failed to write floating point register"); return error; } } @@ -728,10 +562,10 @@ NativeRegisterContextLinux_mips64::ReadAllRegisterValues (lldb::DataBufferSP &da return error; } - error = ReadCP1(); + error = ReadFPR(); if (!error.Success()) { - error.SetErrorString ("ReadCP1() failed"); + error.SetErrorString ("ReadFPR() failed"); return error; } @@ -742,13 +576,10 @@ NativeRegisterContextLinux_mips64::ReadAllRegisterValues (lldb::DataBufferSP &da return error; } - ::memcpy (dst, &m_gpr, GetRegisterInfoInterface ().GetGPRSize ()); + ::memcpy (dst, &m_gpr_mips64, GetRegisterInfoInterface ().GetGPRSize ()); dst += GetRegisterInfoInterface ().GetGPRSize (); - ::memcpy (dst, &m_fpr, GetFPRSize ()); - dst += GetFPRSize (); - - ::memcpy (dst, &m_msa, sizeof(MSA_linux_mips)); + ::memcpy (dst, &m_fpr, sizeof(FPR_mips)); return error; } @@ -777,14 +608,10 @@ NativeRegisterContextLinux_mips64::WriteAllRegisterValues (const lldb::DataBuffe error.SetErrorStringWithFormat ("NativeRegisterContextLinux_mips64::%s DataBuffer::GetBytes() returned a null pointer", __FUNCTION__); return error; } - - ::memcpy (&m_gpr, src, GetRegisterInfoInterface ().GetGPRSize ()); + ::memcpy (&m_gpr_mips64, src, GetRegisterInfoInterface ().GetGPRSize ()); src += GetRegisterInfoInterface ().GetGPRSize (); - ::memcpy (&m_fpr, src, GetFPRSize ()); - src += GetFPRSize (); - - ::memcpy (&m_msa, src, sizeof(MSA_linux_mips)); + ::memcpy (&m_fpr, src, sizeof(FPR_mips)); error = WriteGPR(); if (!error.Success()) @@ -793,10 +620,10 @@ NativeRegisterContextLinux_mips64::WriteAllRegisterValues (const lldb::DataBuffe return error; } - error = WriteCP1(); + error = WriteFPR(); if (!error.Success()) { - error.SetErrorStringWithFormat ("NativeRegisterContextLinux_mips64::%s WriteCP1() failed", __FUNCTION__); + error.SetErrorStringWithFormat ("NativeRegisterContextLinux_mips64::%s WriteFPR() failed", __FUNCTION__); return error; } @@ -804,47 +631,22 @@ NativeRegisterContextLinux_mips64::WriteAllRegisterValues (const lldb::DataBuffe } Error -NativeRegisterContextLinux_mips64::ReadCP1() +NativeRegisterContextLinux_mips64::ReadFPR() { - Error error; - - uint8_t *src, *dst; + void* buf = GetFPRBuffer(); + if (!buf) + return Error("FPR buffer is NULL"); - lldb::ByteOrder byte_order = GetByteOrder(); + Error error = NativeRegisterContextLinux::ReadFPR(); - uint32_t IsBigEndian = (byte_order == lldb::eByteOrderBig); - - if (IsMSAAvailable()) + if (IsFR0()) { - error = NativeRegisterContextLinux::ReadRegisterSet(&m_iovec, sizeof(MSA_linux_mips), NT_MIPS_MSA); - src = (uint8_t *)&m_msa + (IsBigEndian * 8); - dst = (uint8_t *)&m_fpr; - for ( int i = 0; i < NUM_REGISTERS; i++) - { - // Copy fp values from msa buffer fetched via ptrace - *(uint64_t *) dst = *(uint64_t *) src; - src = src + 16; - dst = dst + 8; - } - m_fpr.fir = m_msa.fir; - m_fpr.fcsr = m_msa.fcsr; - m_fpr.config5 = m_msa.config5; - } - else - { - error = NativeRegisterContextLinux::ReadFPR(); - } - - if (IsFR0() || IsFRE()) - { - src = (uint8_t *)&m_fpr + 4 + (IsBigEndian * 4); - dst = (uint8_t *)&m_fpr + 8 + (IsBigEndian * 4); - for (int i = 0; i < (NUM_REGISTERS / 2); i++) + for (int i = 0; i < 16; i++) { // copy odd single from top of neighbouring even double + uint8_t * src = (uint8_t *)buf + 4 + (i * 16); + uint8_t * dst = (uint8_t *)buf + 8 + (i * 16); *(uint32_t *) dst = *(uint32_t *) src; - src = src + 16; - dst = dst + 16; } } @@ -852,77 +654,37 @@ NativeRegisterContextLinux_mips64::ReadCP1() } Error -NativeRegisterContextLinux_mips64::WriteCP1() +NativeRegisterContextLinux_mips64::WriteFPR() { - Error error; - - uint8_t *src, *dst; - - lldb::ByteOrder byte_order = GetByteOrder(); - - uint32_t IsBigEndian = (byte_order == lldb::eByteOrderBig); + void* buf = GetFPRBuffer(); + if (!buf) + return Error("FPR buffer is NULL"); - if (IsFR0() || IsFRE()) + if (IsFR0()) { - src = (uint8_t *)&m_fpr + 8 + (IsBigEndian * 4); - dst = (uint8_t *)&m_fpr + 4 + (IsBigEndian * 4); - for (int i = 0; i < (NUM_REGISTERS / 2); i++) - { + for (int i = 0; i < 16; i++) + { // copy odd single to top of neighbouring even double + uint8_t * src = (uint8_t *)buf + 8 + (i * 16); + uint8_t * dst = (uint8_t *)buf + 4 + (i * 16); *(uint32_t *) dst = *(uint32_t *) src; - src = src + 16; - dst = dst + 16; - } - } - - if (IsMSAAvailable()) - { - dst = (uint8_t *)&m_msa + (IsBigEndian * 8); - src = (uint8_t *)&m_fpr; - for (int i = 0; i < NUM_REGISTERS; i++) - { - // Copy fp values to msa buffer for ptrace - *(uint64_t *) dst = *(uint64_t *) src; - dst = dst + 16; - src = src + 8; - } - m_msa.fir = m_fpr.fir; - m_msa.fcsr = m_fpr.fcsr; - m_msa.config5 = m_fpr.config5; - error = NativeRegisterContextLinux::WriteRegisterSet(&m_iovec, sizeof(MSA_linux_mips), NT_MIPS_MSA); - } - else - { - error = NativeRegisterContextLinux::WriteFPR(); + } } - return error; + return NativeRegisterContextLinux::WriteFPR(); } bool NativeRegisterContextLinux_mips64::IsFR0() { - const RegisterInfo *const reg_info_p = GetRegisterInfoAtIndex (gpr_sr_mips64); + const RegisterInfo *const reg_info_p = GetRegisterInfoAtIndex (36); // Status Register is at index 36 of the register array RegisterValue reg_value; ReadRegister (reg_info_p, reg_value); uint64_t value = reg_value.GetAsUInt64(); - return (!(value & SR_FR)); -} - -bool -NativeRegisterContextLinux_mips64::IsFRE() -{ - const RegisterInfo *const reg_info_p = GetRegisterInfoAtIndex (gpr_config5_mips64); - - RegisterValue reg_value; - ReadRegister (reg_info_p, reg_value); - - uint64_t config5 = reg_value.GetAsUInt64(); - - return (config5 & CONFIG5_FRE); + return (!(value & 0x4000000)); } bool @@ -1107,25 +869,6 @@ GetVacantWatchIndex (struct pt_watch_regs *regs, lldb::addr_t addr, uint32_t siz return 0; } -bool -NativeRegisterContextLinux_mips64::IsMSA(uint32_t reg_index) const -{ - return (m_reg_info.first_msa <= reg_index && reg_index <= m_reg_info.last_msa); -} - -bool -NativeRegisterContextLinux_mips64::IsMSAAvailable() -{ - Error error = NativeRegisterContextLinux::ReadRegisterSet(&m_msa, sizeof(MSA_linux_mips), NT_MIPS_MSA); - - if (error.Success() && m_msa.mir) - { - return true; - } - - return false; -} - Error NativeRegisterContextLinux_mips64::IsWatchpointHit (uint32_t wp_index, bool &is_hit) { @@ -1285,14 +1028,13 @@ NativeRegisterContextLinux_mips64::DoReadRegisterValue(uint32_t offset, uint32_t size, RegisterValue &value) { - GPR_linux_mips regs; - ::memset(®s, 0, sizeof(GPR_linux_mips)); + elf_gregset_t regs; Error error = NativeProcessLinux::PtraceWrapper(PTRACE_GETREGS, m_thread.GetID(), NULL, ®s, sizeof regs); if (error.Success()) { lldb_private::ArchSpec arch; if (m_thread.GetProcess()->GetArchitecture(arch)) - value.SetBytes((void *)(((unsigned char *)(®s)) + offset), 8, arch.GetByteOrder()); + value.SetBytes((void *)(((unsigned char *)(regs)) + offset), 8, arch.GetByteOrder()); else error.SetErrorString("failed to get architecture"); } diff --git a/lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h b/lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h index 9f21bef..9a2e89f 100644 --- a/lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h +++ b/lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h @@ -13,8 +13,8 @@ #define lldb_NativeRegisterContextLinux_mips64_h #include "Plugins/Process/Linux/NativeRegisterContextLinux.h" -#include "Plugins/Process/Utility/RegisterContext_mips.h" -#include "Plugins/Process/Utility/lldb-mips-linux-register-enums.h" +#include "Plugins/Process/Utility/RegisterContext_mips64.h" +#include "Plugins/Process/Utility/lldb-mips64-register-enums.h" #define MAX_NUM_WP 8 @@ -52,10 +52,10 @@ namespace process_linux { WriteAllRegisterValues (const lldb::DataBufferSP &data_sp) override; Error - ReadCP1(); + ReadFPR() override; Error - WriteCP1(); + WriteFPR() override; Error IsWatchpointHit (uint32_t wp_index, bool &is_hit) override; @@ -108,25 +108,16 @@ namespace process_linux { IsFR0(); bool - IsFRE(); - - bool IsFPR(uint32_t reg_index) const; - bool - IsMSA(uint32_t reg_index) const; - - bool - IsMSAAvailable(); - void* - GetGPRBuffer() override { return &m_gpr; } + GetGPRBuffer() override { return &m_gpr_mips64; } void* GetFPRBuffer() override { return &m_fpr; } size_t - GetFPRSize() override { return sizeof(FPR_linux_mips); } + GetFPRSize() override { return sizeof(FPR_mips); } private: // Info about register ranges. @@ -139,21 +130,15 @@ namespace process_linux { uint32_t last_gpr; uint32_t first_fpr; uint32_t last_fpr; - uint32_t first_msa; - uint32_t last_msa; }; RegInfo m_reg_info; - GPR_linux_mips m_gpr; + uint64_t m_gpr_mips64[k_num_gpr_registers_mips64]; - FPR_linux_mips m_fpr; - - MSA_linux_mips m_msa; + FPR_mips m_fpr; lldb::addr_t hw_addr_map[MAX_NUM_WP]; - - IOVEC_mips m_iovec; }; } // namespace process_linux diff --git a/lldb/source/Plugins/Process/Utility/RegisterContextFreeBSD_mips64.cpp b/lldb/source/Plugins/Process/Utility/RegisterContextFreeBSD_mips64.cpp index 53fa416..c31b0ee 100644 --- a/lldb/source/Plugins/Process/Utility/RegisterContextFreeBSD_mips64.cpp +++ b/lldb/source/Plugins/Process/Utility/RegisterContextFreeBSD_mips64.cpp @@ -57,7 +57,7 @@ typedef struct _GPR uint64_t pc; uint64_t ic; uint64_t dummy; -} GPR_freebsd_mips; +} GPR; //--------------------------------------------------------------------------- // Include RegisterInfos_mips64 to declare our g_register_infos_mips64 structure. @@ -74,7 +74,7 @@ RegisterContextFreeBSD_mips64::RegisterContextFreeBSD_mips64(const ArchSpec &tar size_t RegisterContextFreeBSD_mips64::GetGPRSize() const { - return sizeof(GPR_freebsd_mips); + return sizeof(GPR); } const RegisterInfo * diff --git a/lldb/source/Plugins/Process/Utility/RegisterContextLinux_mips.cpp b/lldb/source/Plugins/Process/Utility/RegisterContextLinux_mips.cpp index cf1e7f5..948437f 100644 --- a/lldb/source/Plugins/Process/Utility/RegisterContextLinux_mips.cpp +++ b/lldb/source/Plugins/Process/Utility/RegisterContextLinux_mips.cpp @@ -10,17 +10,59 @@ #include #include +// For GDB, GCC and DWARF Register numbers #include "RegisterContextLinux_mips.h" // Internal codes for mips registers -#include "lldb-mips-linux-register-enums.h" - -// For GP and FP buffers -#include "RegisterContext_mips.h" +#include "lldb-mips64-register-enums.h" +#include "RegisterContext_mips64.h" using namespace lldb_private; using namespace lldb; +// GP registers +typedef struct _GPR +{ + uint32_t zero; + uint32_t r1; + uint32_t r2; + uint32_t r3; + uint32_t r4; + uint32_t r5; + uint32_t r6; + uint32_t r7; + uint32_t r8; + uint32_t r9; + uint32_t r10; + uint32_t r11; + uint32_t r12; + uint32_t r13; + uint32_t r14; + uint32_t r15; + uint32_t r16; + uint32_t r17; + uint32_t r18; + uint32_t r19; + uint32_t r20; + uint32_t r21; + uint32_t r22; + uint32_t r23; + uint32_t r24; + uint32_t r25; + uint32_t r26; + uint32_t r27; + uint32_t gp; + uint32_t sp; + uint32_t r30; + uint32_t ra; + uint32_t mullo; + uint32_t mulhi; + uint32_t pc; + uint32_t badvaddr; + uint32_t sr; + uint32_t cause; +} GPR; + //--------------------------------------------------------------------------- // Include RegisterInfos_mips to declare our g_register_infos_mips structure. //--------------------------------------------------------------------------- @@ -36,7 +78,7 @@ RegisterContextLinux_mips::RegisterContextLinux_mips(const ArchSpec &target_arch size_t RegisterContextLinux_mips::GetGPRSize() const { - return sizeof(GPR_linux_mips); + return sizeof(GPR); } const RegisterInfo * @@ -58,9 +100,3 @@ RegisterContextLinux_mips::GetRegisterCount () const { return static_cast (sizeof (g_register_infos_mips) / sizeof (g_register_infos_mips [0])); } - -uint32_t -RegisterContextLinux_mips::GetUserRegisterCount () const -{ - return static_cast (k_num_user_registers_mips); -} diff --git a/lldb/source/Plugins/Process/Utility/RegisterContextLinux_mips.h b/lldb/source/Plugins/Process/Utility/RegisterContextLinux_mips.h index bcc2d00..815473e 100644 --- a/lldb/source/Plugins/Process/Utility/RegisterContextLinux_mips.h +++ b/lldb/source/Plugins/Process/Utility/RegisterContextLinux_mips.h @@ -27,9 +27,6 @@ public: uint32_t GetRegisterCount () const override; - - uint32_t - GetUserRegisterCount () const override; }; #endif diff --git a/lldb/source/Plugins/Process/Utility/RegisterContextLinux_mips64.cpp b/lldb/source/Plugins/Process/Utility/RegisterContextLinux_mips64.cpp index dd57703..a762930 100644 --- a/lldb/source/Plugins/Process/Utility/RegisterContextLinux_mips64.cpp +++ b/lldb/source/Plugins/Process/Utility/RegisterContextLinux_mips64.cpp @@ -12,24 +12,66 @@ #include #include +// For GDB, GCC and DWARF Register numbers #include "RegisterContextLinux_mips64.h" -// For GP and FP buffers -#include "RegisterContext_mips.h" - -// Internal codes for all mips32 and mips64 registers -#include "lldb-mips-linux-register-enums.h" +// Internal codes for all mips64 registers +#include "lldb-mips64-register-enums.h" +#include "RegisterContext_mips64.h" using namespace lldb; using namespace lldb_private; +// GP registers +typedef struct _GPR +{ + uint64_t zero; + uint64_t r1; + uint64_t r2; + uint64_t r3; + uint64_t r4; + uint64_t r5; + uint64_t r6; + uint64_t r7; + uint64_t r8; + uint64_t r9; + uint64_t r10; + uint64_t r11; + uint64_t r12; + uint64_t r13; + uint64_t r14; + uint64_t r15; + uint64_t r16; + uint64_t r17; + uint64_t r18; + uint64_t r19; + uint64_t r20; + uint64_t r21; + uint64_t r22; + uint64_t r23; + uint64_t r24; + uint64_t r25; + uint64_t r26; + uint64_t r27; + uint64_t gp; + uint64_t sp; + uint64_t r30; + uint64_t ra; + uint64_t mullo; + uint64_t mulhi; + uint64_t pc; + uint64_t badvaddr; + uint64_t sr; + uint64_t cause; + uint64_t ic; + uint64_t dummy; +} GPR; + //--------------------------------------------------------------------------- // Include RegisterInfos_mips64 to declare our g_register_infos_mips64 structure. //--------------------------------------------------------------------------- #define DECLARE_REGISTER_INFOS_MIPS64_STRUCT -#define LINUX_MIPS64 #include "RegisterInfos_mips64.h" -#undef LINUX_MIPS64 #undef DECLARE_REGISTER_INFOS_MIPS64_STRUCT //--------------------------------------------------------------------------- @@ -73,35 +115,17 @@ GetRegisterInfoCount (const ArchSpec &target_arch) } } -uint32_t -GetUserRegisterInfoCount (const ArchSpec &target_arch) -{ - switch (target_arch.GetMachine()) - { - case llvm::Triple::mips: - case llvm::Triple::mipsel: - return static_cast (k_num_user_registers_mips); - case llvm::Triple::mips64el: - case llvm::Triple::mips64: - return static_cast (k_num_user_registers_mips64); - default: - assert(false && "Unhandled target architecture."); - return 0; - } -} - RegisterContextLinux_mips64::RegisterContextLinux_mips64(const ArchSpec &target_arch) : lldb_private::RegisterInfoInterface(target_arch), m_register_info_p (GetRegisterInfoPtr (target_arch)), - m_register_info_count (GetRegisterInfoCount (target_arch)), - m_user_register_count (GetUserRegisterInfoCount (target_arch)) + m_register_info_count (GetRegisterInfoCount (target_arch)) { } size_t RegisterContextLinux_mips64::GetGPRSize() const { - return sizeof(GPR_linux_mips); + return sizeof(GPR); } const RegisterInfo * @@ -116,10 +140,4 @@ RegisterContextLinux_mips64::GetRegisterCount () const return m_register_info_count; } -uint32_t -RegisterContextLinux_mips64::GetUserRegisterCount () const -{ - return m_user_register_count; -} - #endif diff --git a/lldb/source/Plugins/Process/Utility/RegisterContextLinux_mips64.h b/lldb/source/Plugins/Process/Utility/RegisterContextLinux_mips64.h index 86c662c..546d148 100644 --- a/lldb/source/Plugins/Process/Utility/RegisterContextLinux_mips64.h +++ b/lldb/source/Plugins/Process/Utility/RegisterContextLinux_mips64.h @@ -30,13 +30,9 @@ public: uint32_t GetRegisterCount () const override; - uint32_t - GetUserRegisterCount () const override; - private: const lldb_private::RegisterInfo *m_register_info_p; uint32_t m_register_info_count; - uint32_t m_user_register_count; }; #endif diff --git a/lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.h b/lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.h index 612a034..2a61685 100644 --- a/lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.h +++ b/lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.h @@ -12,8 +12,8 @@ #include "lldb/Core/Log.h" #include "RegisterContextPOSIX.h" -#include "RegisterContext_mips.h" -#include "lldb-mips-freebsd-register-enums.h" +#include "RegisterContext_mips64.h" +#include "lldb-mips64-register-enums.h" using namespace lldb_private; diff --git a/lldb/source/Plugins/Process/Utility/RegisterContext_mips.h b/lldb/source/Plugins/Process/Utility/RegisterContext_mips64.h similarity index 54% rename from lldb/source/Plugins/Process/Utility/RegisterContext_mips.h rename to lldb/source/Plugins/Process/Utility/RegisterContext_mips64.h index 871ad06..96ce2a0 100644 --- a/lldb/source/Plugins/Process/Utility/RegisterContext_mips.h +++ b/lldb/source/Plugins/Process/Utility/RegisterContext_mips64.h @@ -1,4 +1,4 @@ -//===-- RegisterContext_mips.h --------------------------------*- C++ -*-===// +//===-- RegisterContext_mips64.h --------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -10,10 +10,6 @@ #ifndef liblldb_RegisterContext_mips64_H_ #define liblldb_RegisterContext_mips64_H_ -#if defined(__mips64) - #define ENABLE_128_BIT_SUPPORT 1 -#endif - // GCC and DWARF Register numbers (eRegisterKindGCC & eRegisterKindDWARF) enum { @@ -50,12 +46,12 @@ enum gcc_dwarf_sp_mips, gcc_dwarf_r30_mips, gcc_dwarf_ra_mips, - gcc_dwarf_sr_mips, gcc_dwarf_lo_mips, gcc_dwarf_hi_mips, + gcc_dwarf_pc_mips, gcc_dwarf_bad_mips, + gcc_dwarf_sr_mips, gcc_dwarf_cause_mips, - gcc_dwarf_pc_mips, gcc_dwarf_f0_mips, gcc_dwarf_f1_mips, gcc_dwarf_f2_mips, @@ -90,41 +86,6 @@ enum gcc_dwarf_f31_mips, gcc_dwarf_fcsr_mips, gcc_dwarf_fir_mips, - gcc_dwarf_w0_mips, - gcc_dwarf_w1_mips, - gcc_dwarf_w2_mips, - gcc_dwarf_w3_mips, - gcc_dwarf_w4_mips, - gcc_dwarf_w5_mips, - gcc_dwarf_w6_mips, - gcc_dwarf_w7_mips, - gcc_dwarf_w8_mips, - gcc_dwarf_w9_mips, - gcc_dwarf_w10_mips, - gcc_dwarf_w11_mips, - gcc_dwarf_w12_mips, - gcc_dwarf_w13_mips, - gcc_dwarf_w14_mips, - gcc_dwarf_w15_mips, - gcc_dwarf_w16_mips, - gcc_dwarf_w17_mips, - gcc_dwarf_w18_mips, - gcc_dwarf_w19_mips, - gcc_dwarf_w20_mips, - gcc_dwarf_w21_mips, - gcc_dwarf_w22_mips, - gcc_dwarf_w23_mips, - gcc_dwarf_w24_mips, - gcc_dwarf_w25_mips, - gcc_dwarf_w26_mips, - gcc_dwarf_w27_mips, - gcc_dwarf_w28_mips, - gcc_dwarf_w29_mips, - gcc_dwarf_w30_mips, - gcc_dwarf_w31_mips, - gcc_dwarf_mcsr_mips, - gcc_dwarf_mir_mips, - gcc_dwarf_config5_mips, gcc_dwarf_ic_mips, gcc_dwarf_dummy_mips }; @@ -204,42 +165,7 @@ enum gcc_dwarf_fcsr_mips64, gcc_dwarf_fir_mips64, gcc_dwarf_ic_mips64, - gcc_dwarf_dummy_mips64, - gcc_dwarf_w0_mips64, - gcc_dwarf_w1_mips64, - gcc_dwarf_w2_mips64, - gcc_dwarf_w3_mips64, - gcc_dwarf_w4_mips64, - gcc_dwarf_w5_mips64, - gcc_dwarf_w6_mips64, - gcc_dwarf_w7_mips64, - gcc_dwarf_w8_mips64, - gcc_dwarf_w9_mips64, - gcc_dwarf_w10_mips64, - gcc_dwarf_w11_mips64, - gcc_dwarf_w12_mips64, - gcc_dwarf_w13_mips64, - gcc_dwarf_w14_mips64, - gcc_dwarf_w15_mips64, - gcc_dwarf_w16_mips64, - gcc_dwarf_w17_mips64, - gcc_dwarf_w18_mips64, - gcc_dwarf_w19_mips64, - gcc_dwarf_w20_mips64, - gcc_dwarf_w21_mips64, - gcc_dwarf_w22_mips64, - gcc_dwarf_w23_mips64, - gcc_dwarf_w24_mips64, - gcc_dwarf_w25_mips64, - gcc_dwarf_w26_mips64, - gcc_dwarf_w27_mips64, - gcc_dwarf_w28_mips64, - gcc_dwarf_w29_mips64, - gcc_dwarf_w30_mips64, - gcc_dwarf_w31_mips64, - gcc_dwarf_mcsr_mips64, - gcc_dwarf_mir_mips64, - gcc_dwarf_config5_mips64, + gcc_dwarf_dummy_mips64 }; // GDB Register numbers (eRegisterKindGDB) @@ -277,12 +203,12 @@ enum gdb_sp_mips, gdb_r30_mips, gdb_ra_mips, - gdb_sr_mips, gdb_lo_mips, gdb_hi_mips, + gdb_pc_mips, gdb_bad_mips, + gdb_sr_mips, gdb_cause_mips, - gdb_pc_mips, gdb_f0_mips, gdb_f1_mips, gdb_f2_mips, @@ -317,41 +243,6 @@ enum gdb_f31_mips, gdb_fcsr_mips, gdb_fir_mips, - gdb_w0_mips, - gdb_w1_mips, - gdb_w2_mips, - gdb_w3_mips, - gdb_w4_mips, - gdb_w5_mips, - gdb_w6_mips, - gdb_w7_mips, - gdb_w8_mips, - gdb_w9_mips, - gdb_w10_mips, - gdb_w11_mips, - gdb_w12_mips, - gdb_w13_mips, - gdb_w14_mips, - gdb_w15_mips, - gdb_w16_mips, - gdb_w17_mips, - gdb_w18_mips, - gdb_w19_mips, - gdb_w20_mips, - gdb_w21_mips, - gdb_w22_mips, - gdb_w23_mips, - gdb_w24_mips, - gdb_w25_mips, - gdb_w26_mips, - gdb_w27_mips, - gdb_w28_mips, - gdb_w29_mips, - gdb_w30_mips, - gdb_w31_mips, - gdb_mcsr_mips, - gdb_mir_mips, - gdb_config5_mips, gdb_ic_mips, gdb_dummy_mips }; @@ -431,184 +322,15 @@ enum gdb_fcsr_mips64, gdb_fir_mips64, gdb_ic_mips64, - gdb_dummy_mips64, - gdb_w0_mips64, - gdb_w1_mips64, - gdb_w2_mips64, - gdb_w3_mips64, - gdb_w4_mips64, - gdb_w5_mips64, - gdb_w6_mips64, - gdb_w7_mips64, - gdb_w8_mips64, - gdb_w9_mips64, - gdb_w10_mips64, - gdb_w11_mips64, - gdb_w12_mips64, - gdb_w13_mips64, - gdb_w14_mips64, - gdb_w15_mips64, - gdb_w16_mips64, - gdb_w17_mips64, - gdb_w18_mips64, - gdb_w19_mips64, - gdb_w20_mips64, - gdb_w21_mips64, - gdb_w22_mips64, - gdb_w23_mips64, - gdb_w24_mips64, - gdb_w25_mips64, - gdb_w26_mips64, - gdb_w27_mips64, - gdb_w28_mips64, - gdb_w29_mips64, - gdb_w30_mips64, - gdb_w31_mips64, - gdb_mcsr_mips64, - gdb_mir_mips64, - gdb_config5_mips64, -}; - -struct IOVEC_mips -{ - void *iov_base; - size_t iov_len; -}; - -// GP registers -struct GPR_linux_mips -{ - uint64_t zero; - uint64_t r1; - uint64_t r2; - uint64_t r3; - uint64_t r4; - uint64_t r5; - uint64_t r6; - uint64_t r7; - uint64_t r8; - uint64_t r9; - uint64_t r10; - uint64_t r11; - uint64_t r12; - uint64_t r13; - uint64_t r14; - uint64_t r15; - uint64_t r16; - uint64_t r17; - uint64_t r18; - uint64_t r19; - uint64_t r20; - uint64_t r21; - uint64_t r22; - uint64_t r23; - uint64_t r24; - uint64_t r25; - uint64_t r26; - uint64_t r27; - uint64_t gp; - uint64_t sp; - uint64_t r30; - uint64_t ra; - uint64_t mullo; - uint64_t mulhi; - uint64_t pc; - uint64_t badvaddr; - uint64_t sr; - uint64_t cause; - uint64_t config5; -}; - -struct FPR_linux_mips -{ - uint64_t f0; - uint64_t f1; - uint64_t f2; - uint64_t f3; - uint64_t f4; - uint64_t f5; - uint64_t f6; - uint64_t f7; - uint64_t f8; - uint64_t f9; - uint64_t f10; - uint64_t f11; - uint64_t f12; - uint64_t f13; - uint64_t f14; - uint64_t f15; - uint64_t f16; - uint64_t f17; - uint64_t f18; - uint64_t f19; - uint64_t f20; - uint64_t f21; - uint64_t f22; - uint64_t f23; - uint64_t f24; - uint64_t f25; - uint64_t f26; - uint64_t f27; - uint64_t f28; - uint64_t f29; - uint64_t f30; - uint64_t f31; - uint32_t fcsr; - uint32_t fir; - uint32_t config5; -}; - -struct MSAReg -{ - uint8_t byte[16]; -}; - -struct MSA_linux_mips -{ - MSAReg w0; - MSAReg w1; - MSAReg w2; - MSAReg w3; - MSAReg w4; - MSAReg w5; - MSAReg w6; - MSAReg w7; - MSAReg w8; - MSAReg w9; - MSAReg w10; - MSAReg w11; - MSAReg w12; - MSAReg w13; - MSAReg w14; - MSAReg w15; - MSAReg w16; - MSAReg w17; - MSAReg w18; - MSAReg w19; - MSAReg w20; - MSAReg w21; - MSAReg w22; - MSAReg w23; - MSAReg w24; - MSAReg w25; - MSAReg w26; - MSAReg w27; - MSAReg w28; - MSAReg w29; - MSAReg w30; - MSAReg w31; - uint32_t fcsr; /* FPU control status register */ - uint32_t fir; /* FPU implementaion revision */ - uint32_t mcsr; /* MSA control status register */ - uint32_t mir; /* MSA implementation revision */ - uint32_t config5; /* Config5 register */ + gdb_dummy_mips64 }; -struct UserArea +// FP registers +struct FPR_mips { - GPR_linux_mips gpr; // General purpose registers. - FPR_linux_mips fpr; // Floating point registers. - MSA_linux_mips msa; // MSA registers. + uint64_t fp_reg[32]; + uint32_t fcsr; /* FPU status register */ + uint32_t fir; /* FPU control register */ }; #endif // liblldb_RegisterContext_mips64_H_ diff --git a/lldb/source/Plugins/Process/Utility/RegisterInfos_mips.h b/lldb/source/Plugins/Process/Utility/RegisterInfos_mips.h index 83ce6f0..0956b2c 100644 --- a/lldb/source/Plugins/Process/Utility/RegisterInfos_mips.h +++ b/lldb/source/Plugins/Process/Utility/RegisterInfos_mips.h @@ -14,35 +14,24 @@ // Computes the offset of the given GPR in the user data area. #define GPR_OFFSET(regname) \ - (LLVM_EXTENSION offsetof(UserArea, gpr) + \ - LLVM_EXTENSION offsetof(GPR_linux_mips, regname)) + (LLVM_EXTENSION offsetof(GPR, regname)) // Computes the offset of the given FPR in the extended data area. #define FPR_OFFSET(regname) \ - (LLVM_EXTENSION offsetof(UserArea, fpr) + \ - LLVM_EXTENSION offsetof(FPR_linux_mips, regname)) - -// Computes the offset of the given MSA in the extended data area. -#define MSA_OFFSET(regname) \ - (LLVM_EXTENSION offsetof(UserArea, msa) + \ - LLVM_EXTENSION offsetof(MSA_linux_mips, regname)) + (LLVM_EXTENSION offsetof(FPR_mips, regname)) // Note that the size and offset will be updated by platform-specific classes. #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4) \ - { #reg, alt, sizeof(((GPR_linux_mips*)NULL)->reg) / 2, GPR_OFFSET(reg), eEncodingUint, \ + { #reg, alt, sizeof(((GPR*)NULL)->reg), GPR_OFFSET(reg), eEncodingUint, \ eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg##_mips }, NULL, NULL } -#define DEFINE_FPR(reg, alt, kind1, kind2, kind3, kind4) \ - { #reg, alt, sizeof(((FPR_linux_mips*)NULL)->reg), FPR_OFFSET(reg), eEncodingUint, \ +#define DEFINE_FPR(member, reg, alt, kind1, kind2, kind3, kind4) \ + { #reg, alt, sizeof(((FPR_mips*)NULL)->member) / 2, FPR_OFFSET(member), eEncodingUint, \ eFormatHex, { kind1, kind2, kind3, kind4, fpr_##reg##_mips }, NULL, NULL } -#define DEFINE_MSA(reg, alt, kind1, kind2, kind3, kind4) \ - { #reg, alt, sizeof(((MSA_linux_mips*)0)->reg), MSA_OFFSET(reg), eEncodingVector, \ - eFormatVectorOfUInt8, { kind1, kind2, kind3, kind4, msa_##reg##_mips }, NULL, NULL } - -#define DEFINE_MSA_INFO(reg, alt, kind1, kind2, kind3, kind4) \ - { #reg, alt, sizeof(((MSA_linux_mips*)0)->reg), MSA_OFFSET(reg), eEncodingUint, \ - eFormatHex, { kind1, kind2, kind3, kind4, msa_##reg##_mips }, NULL, NULL } +#define DEFINE_FPR_INFO(member, reg, alt, kind1, kind2, kind3, kind4) \ + { #reg, alt, sizeof(((FPR_mips*)NULL)->member), FPR_OFFSET(member), eEncodingUint, \ + eFormatHex, { kind1, kind2, kind3, kind4, fpr_##reg##_mips }, NULL, NULL } // RegisterKind: GCC, DWARF, Generic, GDB, LLDB @@ -81,95 +70,53 @@ g_register_infos_mips[] = DEFINE_GPR (sp, "sp", gcc_dwarf_sp_mips, gcc_dwarf_sp_mips, LLDB_REGNUM_GENERIC_SP, gdb_sp_mips), DEFINE_GPR (r30, "fp", gcc_dwarf_r30_mips, gcc_dwarf_r30_mips, LLDB_REGNUM_GENERIC_FP, gdb_r30_mips), DEFINE_GPR (ra, "ra", gcc_dwarf_ra_mips, gcc_dwarf_ra_mips, LLDB_REGNUM_GENERIC_RA, gdb_ra_mips), - DEFINE_GPR (sr, "status", gcc_dwarf_sr_mips, gcc_dwarf_sr_mips, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM), DEFINE_GPR (mullo, NULL, gcc_dwarf_lo_mips, gcc_dwarf_lo_mips, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM), DEFINE_GPR (mulhi, NULL, gcc_dwarf_hi_mips, gcc_dwarf_hi_mips, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM), + DEFINE_GPR (pc, NULL, gcc_dwarf_pc_mips, gcc_dwarf_pc_mips, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM), DEFINE_GPR (badvaddr, NULL, gcc_dwarf_bad_mips, gcc_dwarf_bad_mips, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM), + DEFINE_GPR (sr, "status", gcc_dwarf_sr_mips, gcc_dwarf_sr_mips, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM), DEFINE_GPR (cause, NULL, gcc_dwarf_cause_mips, gcc_dwarf_cause_mips, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM), - DEFINE_GPR (pc, NULL, gcc_dwarf_pc_mips, gcc_dwarf_pc_mips, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM), - DEFINE_GPR (config5, NULL, gcc_dwarf_config5_mips, gcc_dwarf_config5_mips, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM), - DEFINE_FPR (f0, NULL, gcc_dwarf_f0_mips, gcc_dwarf_f0_mips, LLDB_INVALID_REGNUM, gdb_f0_mips), - DEFINE_FPR (f1, NULL, gcc_dwarf_f1_mips, gcc_dwarf_f1_mips, LLDB_INVALID_REGNUM, gdb_f1_mips), - DEFINE_FPR (f2, NULL, gcc_dwarf_f2_mips, gcc_dwarf_f2_mips, LLDB_INVALID_REGNUM, gdb_f2_mips), - DEFINE_FPR (f3, NULL, gcc_dwarf_f3_mips, gcc_dwarf_f3_mips, LLDB_INVALID_REGNUM, gdb_f3_mips), - DEFINE_FPR (f4, NULL, gcc_dwarf_f4_mips, gcc_dwarf_f4_mips, LLDB_INVALID_REGNUM, gdb_f4_mips), - DEFINE_FPR (f5, NULL, gcc_dwarf_f5_mips, gcc_dwarf_f5_mips, LLDB_INVALID_REGNUM, gdb_f5_mips), - DEFINE_FPR (f6, NULL, gcc_dwarf_f6_mips, gcc_dwarf_f6_mips, LLDB_INVALID_REGNUM, gdb_f6_mips), - DEFINE_FPR (f7, NULL, gcc_dwarf_f7_mips, gcc_dwarf_f7_mips, LLDB_INVALID_REGNUM, gdb_f7_mips), - DEFINE_FPR (f8, NULL, gcc_dwarf_f8_mips, gcc_dwarf_f8_mips, LLDB_INVALID_REGNUM, gdb_f8_mips), - DEFINE_FPR (f9, NULL, gcc_dwarf_f9_mips, gcc_dwarf_f9_mips, LLDB_INVALID_REGNUM, gdb_f9_mips), - DEFINE_FPR (f10, NULL, gcc_dwarf_f10_mips, gcc_dwarf_f10_mips, LLDB_INVALID_REGNUM, gdb_f10_mips), - DEFINE_FPR (f11, NULL, gcc_dwarf_f11_mips, gcc_dwarf_f11_mips, LLDB_INVALID_REGNUM, gdb_f11_mips), - DEFINE_FPR (f12, NULL, gcc_dwarf_f12_mips, gcc_dwarf_f12_mips, LLDB_INVALID_REGNUM, gdb_f12_mips), - DEFINE_FPR (f13, NULL, gcc_dwarf_f13_mips, gcc_dwarf_f13_mips, LLDB_INVALID_REGNUM, gdb_f13_mips), - DEFINE_FPR (f14, NULL, gcc_dwarf_f14_mips, gcc_dwarf_f14_mips, LLDB_INVALID_REGNUM, gdb_f14_mips), - DEFINE_FPR (f15, NULL, gcc_dwarf_f15_mips, gcc_dwarf_f15_mips, LLDB_INVALID_REGNUM, gdb_f15_mips), - DEFINE_FPR (f16, NULL, gcc_dwarf_f16_mips, gcc_dwarf_f16_mips, LLDB_INVALID_REGNUM, gdb_f16_mips), - DEFINE_FPR (f17, NULL, gcc_dwarf_f17_mips, gcc_dwarf_f17_mips, LLDB_INVALID_REGNUM, gdb_f17_mips), - DEFINE_FPR (f18, NULL, gcc_dwarf_f18_mips, gcc_dwarf_f18_mips, LLDB_INVALID_REGNUM, gdb_f18_mips), - DEFINE_FPR (f19, NULL, gcc_dwarf_f19_mips, gcc_dwarf_f19_mips, LLDB_INVALID_REGNUM, gdb_f19_mips), - DEFINE_FPR (f20, NULL, gcc_dwarf_f20_mips, gcc_dwarf_f20_mips, LLDB_INVALID_REGNUM, gdb_f20_mips), - DEFINE_FPR (f21, NULL, gcc_dwarf_f21_mips, gcc_dwarf_f21_mips, LLDB_INVALID_REGNUM, gdb_f21_mips), - DEFINE_FPR (f22, NULL, gcc_dwarf_f22_mips, gcc_dwarf_f22_mips, LLDB_INVALID_REGNUM, gdb_f22_mips), - DEFINE_FPR (f23, NULL, gcc_dwarf_f23_mips, gcc_dwarf_f23_mips, LLDB_INVALID_REGNUM, gdb_f23_mips), - DEFINE_FPR (f24, NULL, gcc_dwarf_f24_mips, gcc_dwarf_f24_mips, LLDB_INVALID_REGNUM, gdb_f24_mips), - DEFINE_FPR (f25, NULL, gcc_dwarf_f25_mips, gcc_dwarf_f25_mips, LLDB_INVALID_REGNUM, gdb_f25_mips), - DEFINE_FPR (f26, NULL, gcc_dwarf_f26_mips, gcc_dwarf_f26_mips, LLDB_INVALID_REGNUM, gdb_f26_mips), - DEFINE_FPR (f27, NULL, gcc_dwarf_f27_mips, gcc_dwarf_f27_mips, LLDB_INVALID_REGNUM, gdb_f27_mips), - DEFINE_FPR (f28, NULL, gcc_dwarf_f28_mips, gcc_dwarf_f28_mips, LLDB_INVALID_REGNUM, gdb_f28_mips), - DEFINE_FPR (f29, NULL, gcc_dwarf_f29_mips, gcc_dwarf_f29_mips, LLDB_INVALID_REGNUM, gdb_f29_mips), - DEFINE_FPR (f30, NULL, gcc_dwarf_f30_mips, gcc_dwarf_f30_mips, LLDB_INVALID_REGNUM, gdb_f30_mips), - DEFINE_FPR (f31, NULL, gcc_dwarf_f31_mips, gcc_dwarf_f31_mips, LLDB_INVALID_REGNUM, gdb_f31_mips), - DEFINE_FPR (fcsr, NULL, gcc_dwarf_fcsr_mips, gcc_dwarf_fcsr_mips, LLDB_INVALID_REGNUM, gdb_fcsr_mips), - DEFINE_FPR (fir, NULL, gcc_dwarf_fir_mips, gcc_dwarf_fir_mips, LLDB_INVALID_REGNUM, gdb_fir_mips), - DEFINE_FPR (config5, NULL, gcc_dwarf_config5_mips, gcc_dwarf_config5_mips, LLDB_INVALID_REGNUM, gdb_config5_mips), - DEFINE_MSA (w0, NULL, gcc_dwarf_w0_mips, gcc_dwarf_w0_mips, LLDB_INVALID_REGNUM, gdb_w0_mips), - DEFINE_MSA (w1, NULL, gcc_dwarf_w1_mips, gcc_dwarf_w1_mips, LLDB_INVALID_REGNUM, gdb_w1_mips), - DEFINE_MSA (w2, NULL, gcc_dwarf_w2_mips, gcc_dwarf_w2_mips, LLDB_INVALID_REGNUM, gdb_w2_mips), - DEFINE_MSA (w3, NULL, gcc_dwarf_w3_mips, gcc_dwarf_w3_mips, LLDB_INVALID_REGNUM, gdb_w3_mips), - DEFINE_MSA (w4, NULL, gcc_dwarf_w4_mips, gcc_dwarf_w4_mips, LLDB_INVALID_REGNUM, gdb_w4_mips), - DEFINE_MSA (w5, NULL, gcc_dwarf_w5_mips, gcc_dwarf_w5_mips, LLDB_INVALID_REGNUM, gdb_w5_mips), - DEFINE_MSA (w6, NULL, gcc_dwarf_w6_mips, gcc_dwarf_w6_mips, LLDB_INVALID_REGNUM, gdb_w6_mips), - DEFINE_MSA (w7, NULL, gcc_dwarf_w7_mips, gcc_dwarf_w7_mips, LLDB_INVALID_REGNUM, gdb_w7_mips), - DEFINE_MSA (w8, NULL, gcc_dwarf_w8_mips, gcc_dwarf_w8_mips, LLDB_INVALID_REGNUM, gdb_w8_mips), - DEFINE_MSA (w9, NULL, gcc_dwarf_w9_mips, gcc_dwarf_w9_mips, LLDB_INVALID_REGNUM, gdb_w9_mips), - DEFINE_MSA (w10, NULL, gcc_dwarf_w10_mips, gcc_dwarf_w10_mips, LLDB_INVALID_REGNUM, gdb_w10_mips), - DEFINE_MSA (w11, NULL, gcc_dwarf_w11_mips, gcc_dwarf_w11_mips, LLDB_INVALID_REGNUM, gdb_w11_mips), - DEFINE_MSA (w12, NULL, gcc_dwarf_w12_mips, gcc_dwarf_w12_mips, LLDB_INVALID_REGNUM, gdb_w12_mips), - DEFINE_MSA (w13, NULL, gcc_dwarf_w13_mips, gcc_dwarf_w13_mips, LLDB_INVALID_REGNUM, gdb_w13_mips), - DEFINE_MSA (w14, NULL, gcc_dwarf_w14_mips, gcc_dwarf_w14_mips, LLDB_INVALID_REGNUM, gdb_w14_mips), - DEFINE_MSA (w15, NULL, gcc_dwarf_w15_mips, gcc_dwarf_w15_mips, LLDB_INVALID_REGNUM, gdb_w15_mips), - DEFINE_MSA (w16, NULL, gcc_dwarf_w16_mips, gcc_dwarf_w16_mips, LLDB_INVALID_REGNUM, gdb_w16_mips), - DEFINE_MSA (w17, NULL, gcc_dwarf_w17_mips, gcc_dwarf_w17_mips, LLDB_INVALID_REGNUM, gdb_w17_mips), - DEFINE_MSA (w18, NULL, gcc_dwarf_w18_mips, gcc_dwarf_w18_mips, LLDB_INVALID_REGNUM, gdb_w18_mips), - DEFINE_MSA (w19, NULL, gcc_dwarf_w19_mips, gcc_dwarf_w19_mips, LLDB_INVALID_REGNUM, gdb_w19_mips), - DEFINE_MSA (w20, NULL, gcc_dwarf_w10_mips, gcc_dwarf_w20_mips, LLDB_INVALID_REGNUM, gdb_w20_mips), - DEFINE_MSA (w21, NULL, gcc_dwarf_w21_mips, gcc_dwarf_w21_mips, LLDB_INVALID_REGNUM, gdb_w21_mips), - DEFINE_MSA (w22, NULL, gcc_dwarf_w22_mips, gcc_dwarf_w22_mips, LLDB_INVALID_REGNUM, gdb_w22_mips), - DEFINE_MSA (w23, NULL, gcc_dwarf_w23_mips, gcc_dwarf_w23_mips, LLDB_INVALID_REGNUM, gdb_w23_mips), - DEFINE_MSA (w24, NULL, gcc_dwarf_w24_mips, gcc_dwarf_w24_mips, LLDB_INVALID_REGNUM, gdb_w24_mips), - DEFINE_MSA (w25, NULL, gcc_dwarf_w25_mips, gcc_dwarf_w25_mips, LLDB_INVALID_REGNUM, gdb_w25_mips), - DEFINE_MSA (w26, NULL, gcc_dwarf_w26_mips, gcc_dwarf_w26_mips, LLDB_INVALID_REGNUM, gdb_w26_mips), - DEFINE_MSA (w27, NULL, gcc_dwarf_w27_mips, gcc_dwarf_w27_mips, LLDB_INVALID_REGNUM, gdb_w27_mips), - DEFINE_MSA (w28, NULL, gcc_dwarf_w28_mips, gcc_dwarf_w28_mips, LLDB_INVALID_REGNUM, gdb_w28_mips), - DEFINE_MSA (w29, NULL, gcc_dwarf_w29_mips, gcc_dwarf_w29_mips, LLDB_INVALID_REGNUM, gdb_w29_mips), - DEFINE_MSA (w30, NULL, gcc_dwarf_w30_mips, gcc_dwarf_w30_mips, LLDB_INVALID_REGNUM, gdb_w30_mips), - DEFINE_MSA (w31, NULL, gcc_dwarf_w31_mips, gcc_dwarf_w31_mips, LLDB_INVALID_REGNUM, gdb_w31_mips), - DEFINE_MSA_INFO (mcsr, NULL, gcc_dwarf_mcsr_mips, gcc_dwarf_mcsr_mips, LLDB_INVALID_REGNUM, gdb_mcsr_mips), - DEFINE_MSA_INFO (mir, NULL, gcc_dwarf_mir_mips, gcc_dwarf_mir_mips, LLDB_INVALID_REGNUM, gdb_mir_mips), - DEFINE_MSA_INFO (fcsr, NULL, gcc_dwarf_fcsr_mips, gcc_dwarf_fcsr_mips, LLDB_INVALID_REGNUM, gdb_fcsr_mips), - DEFINE_MSA_INFO (fir, NULL, gcc_dwarf_fir_mips, gcc_dwarf_fir_mips, LLDB_INVALID_REGNUM, gdb_fir_mips), - DEFINE_MSA_INFO (config5, NULL, gcc_dwarf_config5_mips, gcc_dwarf_config5_mips, LLDB_INVALID_REGNUM, gdb_config5_mips) + DEFINE_FPR (fp_reg[0], f0, NULL, gcc_dwarf_f0_mips, gcc_dwarf_f0_mips, LLDB_INVALID_REGNUM, gdb_f0_mips), + DEFINE_FPR (fp_reg[1], f1, NULL, gcc_dwarf_f1_mips, gcc_dwarf_f1_mips, LLDB_INVALID_REGNUM, gdb_f1_mips), + DEFINE_FPR (fp_reg[2], f2, NULL, gcc_dwarf_f2_mips, gcc_dwarf_f2_mips, LLDB_INVALID_REGNUM, gdb_f2_mips), + DEFINE_FPR (fp_reg[3], f3, NULL, gcc_dwarf_f3_mips, gcc_dwarf_f3_mips, LLDB_INVALID_REGNUM, gdb_f3_mips), + DEFINE_FPR (fp_reg[4], f4, NULL, gcc_dwarf_f4_mips, gcc_dwarf_f4_mips, LLDB_INVALID_REGNUM, gdb_f4_mips), + DEFINE_FPR (fp_reg[5], f5, NULL, gcc_dwarf_f5_mips, gcc_dwarf_f5_mips, LLDB_INVALID_REGNUM, gdb_f5_mips), + DEFINE_FPR (fp_reg[6], f6, NULL, gcc_dwarf_f6_mips, gcc_dwarf_f6_mips, LLDB_INVALID_REGNUM, gdb_f6_mips), + DEFINE_FPR (fp_reg[7], f7, NULL, gcc_dwarf_f7_mips, gcc_dwarf_f7_mips, LLDB_INVALID_REGNUM, gdb_f7_mips), + DEFINE_FPR (fp_reg[8], f8, NULL, gcc_dwarf_f8_mips, gcc_dwarf_f8_mips, LLDB_INVALID_REGNUM, gdb_f8_mips), + DEFINE_FPR (fp_reg[9], f9, NULL, gcc_dwarf_f9_mips, gcc_dwarf_f9_mips, LLDB_INVALID_REGNUM, gdb_f9_mips), + DEFINE_FPR (fp_reg[10], f10, NULL, gcc_dwarf_f10_mips, gcc_dwarf_f10_mips, LLDB_INVALID_REGNUM, gdb_f10_mips), + DEFINE_FPR (fp_reg[11], f11, NULL, gcc_dwarf_f11_mips, gcc_dwarf_f11_mips, LLDB_INVALID_REGNUM, gdb_f11_mips), + DEFINE_FPR (fp_reg[12], f12, NULL, gcc_dwarf_f12_mips, gcc_dwarf_f12_mips, LLDB_INVALID_REGNUM, gdb_f12_mips), + DEFINE_FPR (fp_reg[13], f13, NULL, gcc_dwarf_f13_mips, gcc_dwarf_f13_mips, LLDB_INVALID_REGNUM, gdb_f13_mips), + DEFINE_FPR (fp_reg[14], f14, NULL, gcc_dwarf_f14_mips, gcc_dwarf_f14_mips, LLDB_INVALID_REGNUM, gdb_f14_mips), + DEFINE_FPR (fp_reg[15], f15, NULL, gcc_dwarf_f15_mips, gcc_dwarf_f15_mips, LLDB_INVALID_REGNUM, gdb_f15_mips), + DEFINE_FPR (fp_reg[16], f16, NULL, gcc_dwarf_f16_mips, gcc_dwarf_f16_mips, LLDB_INVALID_REGNUM, gdb_f16_mips), + DEFINE_FPR (fp_reg[17], f17, NULL, gcc_dwarf_f17_mips, gcc_dwarf_f17_mips, LLDB_INVALID_REGNUM, gdb_f17_mips), + DEFINE_FPR (fp_reg[18], f18, NULL, gcc_dwarf_f18_mips, gcc_dwarf_f18_mips, LLDB_INVALID_REGNUM, gdb_f18_mips), + DEFINE_FPR (fp_reg[19], f19, NULL, gcc_dwarf_f19_mips, gcc_dwarf_f19_mips, LLDB_INVALID_REGNUM, gdb_f19_mips), + DEFINE_FPR (fp_reg[20], f20, NULL, gcc_dwarf_f20_mips, gcc_dwarf_f20_mips, LLDB_INVALID_REGNUM, gdb_f20_mips), + DEFINE_FPR (fp_reg[21], f21, NULL, gcc_dwarf_f21_mips, gcc_dwarf_f21_mips, LLDB_INVALID_REGNUM, gdb_f21_mips), + DEFINE_FPR (fp_reg[22], f22, NULL, gcc_dwarf_f22_mips, gcc_dwarf_f22_mips, LLDB_INVALID_REGNUM, gdb_f22_mips), + DEFINE_FPR (fp_reg[23], f23, NULL, gcc_dwarf_f23_mips, gcc_dwarf_f23_mips, LLDB_INVALID_REGNUM, gdb_f23_mips), + DEFINE_FPR (fp_reg[24], f24, NULL, gcc_dwarf_f24_mips, gcc_dwarf_f24_mips, LLDB_INVALID_REGNUM, gdb_f24_mips), + DEFINE_FPR (fp_reg[25], f25, NULL, gcc_dwarf_f25_mips, gcc_dwarf_f25_mips, LLDB_INVALID_REGNUM, gdb_f25_mips), + DEFINE_FPR (fp_reg[26], f26, NULL, gcc_dwarf_f26_mips, gcc_dwarf_f26_mips, LLDB_INVALID_REGNUM, gdb_f26_mips), + DEFINE_FPR (fp_reg[27], f27, NULL, gcc_dwarf_f27_mips, gcc_dwarf_f27_mips, LLDB_INVALID_REGNUM, gdb_f27_mips), + DEFINE_FPR (fp_reg[28], f28, NULL, gcc_dwarf_f28_mips, gcc_dwarf_f28_mips, LLDB_INVALID_REGNUM, gdb_f28_mips), + DEFINE_FPR (fp_reg[29], f29, NULL, gcc_dwarf_f29_mips, gcc_dwarf_f29_mips, LLDB_INVALID_REGNUM, gdb_f29_mips), + DEFINE_FPR (fp_reg[30], f30, NULL, gcc_dwarf_f30_mips, gcc_dwarf_f30_mips, LLDB_INVALID_REGNUM, gdb_f30_mips), + DEFINE_FPR (fp_reg[31], f31, NULL, gcc_dwarf_f31_mips, gcc_dwarf_f31_mips, LLDB_INVALID_REGNUM, gdb_f31_mips), + DEFINE_FPR_INFO (fcsr, fcsr, NULL, gcc_dwarf_fcsr_mips, gcc_dwarf_fcsr_mips, LLDB_INVALID_REGNUM, gdb_fcsr_mips), + DEFINE_FPR_INFO (fir, fir, NULL, gcc_dwarf_fir_mips, gcc_dwarf_fir_mips, LLDB_INVALID_REGNUM, gdb_fir_mips) }; static_assert((sizeof(g_register_infos_mips) / sizeof(g_register_infos_mips[0])) == k_num_registers_mips, "g_register_infos_mips has wrong number of register infos"); #undef GPR_OFFSET #undef FPR_OFFSET -#undef MSA_OFFSET #undef DEFINE_GPR #undef DEFINE_FPR -#undef DEFINE_MSA -#undef DEFINE_MSA_INFO #endif // DECLARE_REGISTER_INFOS_MIPS_STRUCT diff --git a/lldb/source/Plugins/Process/Utility/RegisterInfos_mips64.h b/lldb/source/Plugins/Process/Utility/RegisterInfos_mips64.h index 101842e..e03aea4 100644 --- a/lldb/source/Plugins/Process/Utility/RegisterInfos_mips64.h +++ b/lldb/source/Plugins/Process/Utility/RegisterInfos_mips64.h @@ -13,59 +13,28 @@ #ifdef DECLARE_REGISTER_INFOS_MIPS64_STRUCT // Computes the offset of the given GPR in the user data area. -#ifdef LINUX_MIPS64 - #define GPR_OFFSET(regname) \ - (LLVM_EXTENSION offsetof(UserArea, gpr) + \ - LLVM_EXTENSION offsetof(GPR_linux_mips, regname)) -#else - #define GPR_OFFSET(regname) \ - (LLVM_EXTENSION offsetof(GPR_freebsd_mips, regname)) -#endif +#define GPR_OFFSET(regname) \ + (LLVM_EXTENSION offsetof(GPR, regname)) // Computes the offset of the given FPR in the extended data area. #define FPR_OFFSET(regname) \ - (LLVM_EXTENSION offsetof(UserArea, fpr) + \ - LLVM_EXTENSION offsetof(FPR_linux_mips, regname)) - -// Computes the offset of the given MSA in the extended data area. -#define MSA_OFFSET(regname) \ - (LLVM_EXTENSION offsetof(UserArea, msa) + \ - LLVM_EXTENSION offsetof(MSA_linux_mips, regname)) + LLVM_EXTENSION offsetof(FPR_mips, regname) \ // RegisterKind: GCC, DWARF, Generic, GDB, LLDB // Note that the size and offset will be updated by platform-specific classes. -#ifdef LINUX_MIPS64 - #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4) \ - { #reg, alt, sizeof(((GPR_linux_mips*)0)->reg), GPR_OFFSET(reg), eEncodingUint, \ - eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg##_mips64 }, NULL, NULL } -#else - #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4) \ - { #reg, alt, sizeof(((GPR_freebsd_mips*)0)->reg), GPR_OFFSET(reg), eEncodingUint, \ - eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg##_mips64 }, NULL, NULL } -#endif - -#define DEFINE_GPR_INFO(reg, alt, kind1, kind2, kind3, kind4) \ - { #reg, alt, sizeof(((GPR_linux_mips*)0)->reg) / 2, GPR_OFFSET(reg), eEncodingUint, \ +#define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4) \ + { #reg, alt, sizeof(((GPR*)0)->reg), GPR_OFFSET(reg), eEncodingUint, \ eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg##_mips64 }, NULL, NULL } -#define DEFINE_FPR(reg, alt, kind1, kind2, kind3, kind4) \ - { #reg, alt, sizeof(((FPR_linux_mips*)0)->reg), FPR_OFFSET(reg), eEncodingUint, \ +#define DEFINE_FPR(member, reg, alt, kind1, kind2, kind3, kind4) \ + { #reg, alt, sizeof(((FPR_mips*)0)->member), FPR_OFFSET(member), eEncodingUint, \ eFormatHex, { kind1, kind2, kind3, kind4, fpr_##reg##_mips64 }, NULL, NULL } -#define DEFINE_MSA(reg, alt, kind1, kind2, kind3, kind4) \ - { #reg, alt, sizeof(((MSA_linux_mips*)0)->reg), MSA_OFFSET(reg), eEncodingVector, \ - eFormatVectorOfUInt8, { kind1, kind2, kind3, kind4, msa_##reg##_mips64 }, NULL, NULL } - -#define DEFINE_MSA_INFO(reg, alt, kind1, kind2, kind3, kind4) \ - { #reg, alt, sizeof(((MSA_linux_mips*)0)->reg), MSA_OFFSET(reg), eEncodingUint, \ - eFormatHex, { kind1, kind2, kind3, kind4, msa_##reg##_mips64 }, NULL, NULL } - static RegisterInfo g_register_infos_mips64[] = { // General purpose registers. GCC, DWARF, Generic, GDB -#ifndef LINUX_MIPS64 DEFINE_GPR(zero, "r0", gcc_dwarf_zero_mips64, gcc_dwarf_zero_mips64, LLDB_INVALID_REGNUM, gdb_zero_mips64), DEFINE_GPR(r1, NULL, gcc_dwarf_r1_mips64, gcc_dwarf_r1_mips64, LLDB_INVALID_REGNUM, gdb_r1_mips64), DEFINE_GPR(r2, NULL, gcc_dwarf_r2_mips64, gcc_dwarf_r2_mips64, LLDB_INVALID_REGNUM, gdb_r2_mips64), @@ -98,140 +67,56 @@ g_register_infos_mips64[] = DEFINE_GPR(sp, "r29", gcc_dwarf_sp_mips64, gcc_dwarf_sp_mips64, LLDB_REGNUM_GENERIC_SP, gdb_sp_mips64), DEFINE_GPR(r30, NULL, gcc_dwarf_r30_mips64, gcc_dwarf_r30_mips64, LLDB_REGNUM_GENERIC_FP, gdb_r30_mips64), DEFINE_GPR(ra, "r31", gcc_dwarf_ra_mips64, gcc_dwarf_ra_mips64, LLDB_REGNUM_GENERIC_RA, gdb_ra_mips64), - DEFINE_GPR(sr, NULL, gcc_dwarf_sr_mips64, gcc_dwarf_sr_mips64, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM), DEFINE_GPR(mullo, NULL, gcc_dwarf_lo_mips64, gcc_dwarf_lo_mips64, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM), DEFINE_GPR(mulhi, NULL, gcc_dwarf_hi_mips64, gcc_dwarf_hi_mips64, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM), + DEFINE_GPR(pc, "pc", gcc_dwarf_pc_mips64, gcc_dwarf_pc_mips64, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM), DEFINE_GPR(badvaddr, NULL, gcc_dwarf_bad_mips64, gcc_dwarf_bad_mips64, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM), + DEFINE_GPR(sr, NULL, gcc_dwarf_sr_mips64, gcc_dwarf_sr_mips64, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM), DEFINE_GPR(cause, NULL, gcc_dwarf_cause_mips64, gcc_dwarf_cause_mips64, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM), - DEFINE_GPR(pc, "pc", gcc_dwarf_pc_mips64, gcc_dwarf_pc_mips64, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM), DEFINE_GPR(ic, NULL, gcc_dwarf_ic_mips64, gcc_dwarf_ic_mips64, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM), DEFINE_GPR(dummy, NULL, gcc_dwarf_dummy_mips64, gcc_dwarf_dummy_mips64, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM), -#else - DEFINE_GPR(zero, "r0", gcc_dwarf_zero_mips64, gcc_dwarf_zero_mips64, LLDB_INVALID_REGNUM, gdb_zero_mips64), - DEFINE_GPR(r1, NULL, gcc_dwarf_r1_mips64, gcc_dwarf_r1_mips64, LLDB_INVALID_REGNUM, gdb_r1_mips64), - DEFINE_GPR(r2, NULL, gcc_dwarf_r2_mips64, gcc_dwarf_r2_mips64, LLDB_INVALID_REGNUM, gdb_r2_mips64), - DEFINE_GPR(r3, NULL, gcc_dwarf_r3_mips64, gcc_dwarf_r3_mips64, LLDB_INVALID_REGNUM, gdb_r3_mips64), - DEFINE_GPR(r4, NULL, gcc_dwarf_r4_mips64, gcc_dwarf_r4_mips64, LLDB_REGNUM_GENERIC_ARG1, gdb_r4_mips64), - DEFINE_GPR(r5, NULL, gcc_dwarf_r5_mips64, gcc_dwarf_r5_mips64, LLDB_REGNUM_GENERIC_ARG2, gdb_r5_mips64), - DEFINE_GPR(r6, NULL, gcc_dwarf_r6_mips64, gcc_dwarf_r6_mips64, LLDB_REGNUM_GENERIC_ARG3, gdb_r6_mips64), - DEFINE_GPR(r7, NULL, gcc_dwarf_r7_mips64, gcc_dwarf_r7_mips64, LLDB_REGNUM_GENERIC_ARG4, gdb_r7_mips64), - DEFINE_GPR(r8, NULL, gcc_dwarf_r8_mips64, gcc_dwarf_r8_mips64, LLDB_REGNUM_GENERIC_ARG5, gdb_r8_mips64), - DEFINE_GPR(r9, NULL, gcc_dwarf_r9_mips64, gcc_dwarf_r9_mips64, LLDB_REGNUM_GENERIC_ARG6, gdb_r9_mips64), - DEFINE_GPR(r10, NULL, gcc_dwarf_r10_mips64, gcc_dwarf_r10_mips64, LLDB_REGNUM_GENERIC_ARG7, gdb_r10_mips64), - DEFINE_GPR(r11, NULL, gcc_dwarf_r11_mips64, gcc_dwarf_r11_mips64, LLDB_REGNUM_GENERIC_ARG8, gdb_r11_mips64), - DEFINE_GPR(r12, NULL, gcc_dwarf_r12_mips64, gcc_dwarf_r12_mips64, LLDB_INVALID_REGNUM, gdb_r12_mips64), - DEFINE_GPR(r13, NULL, gcc_dwarf_r13_mips64, gcc_dwarf_r13_mips64, LLDB_INVALID_REGNUM, gdb_r13_mips64), - DEFINE_GPR(r14, NULL, gcc_dwarf_r14_mips64, gcc_dwarf_r14_mips64, LLDB_INVALID_REGNUM, gdb_r14_mips64), - DEFINE_GPR(r15, NULL, gcc_dwarf_r15_mips64, gcc_dwarf_r15_mips64, LLDB_INVALID_REGNUM, gdb_r15_mips64), - DEFINE_GPR(r16, NULL, gcc_dwarf_r16_mips64, gcc_dwarf_r16_mips64, LLDB_INVALID_REGNUM, gdb_r16_mips64), - DEFINE_GPR(r17, NULL, gcc_dwarf_r17_mips64, gcc_dwarf_r17_mips64, LLDB_INVALID_REGNUM, gdb_r17_mips64), - DEFINE_GPR(r18, NULL, gcc_dwarf_r18_mips64, gcc_dwarf_r18_mips64, LLDB_INVALID_REGNUM, gdb_r18_mips64), - DEFINE_GPR(r19, NULL, gcc_dwarf_r19_mips64, gcc_dwarf_r19_mips64, LLDB_INVALID_REGNUM, gdb_r19_mips64), - DEFINE_GPR(r20, NULL, gcc_dwarf_r20_mips64, gcc_dwarf_r20_mips64, LLDB_INVALID_REGNUM, gdb_r20_mips64), - DEFINE_GPR(r21, NULL, gcc_dwarf_r21_mips64, gcc_dwarf_r21_mips64, LLDB_INVALID_REGNUM, gdb_r21_mips64), - DEFINE_GPR(r22, NULL, gcc_dwarf_r22_mips64, gcc_dwarf_r22_mips64, LLDB_INVALID_REGNUM, gdb_r22_mips64), - DEFINE_GPR(r23, NULL, gcc_dwarf_r23_mips64, gcc_dwarf_r23_mips64, LLDB_INVALID_REGNUM, gdb_r23_mips64), - DEFINE_GPR(r24, NULL, gcc_dwarf_r24_mips64, gcc_dwarf_r24_mips64, LLDB_INVALID_REGNUM, gdb_r24_mips64), - DEFINE_GPR(r25, NULL, gcc_dwarf_r25_mips64, gcc_dwarf_r25_mips64, LLDB_INVALID_REGNUM, gdb_r25_mips64), - DEFINE_GPR(r26, NULL, gcc_dwarf_r26_mips64, gcc_dwarf_r26_mips64, LLDB_INVALID_REGNUM, gdb_r26_mips64), - DEFINE_GPR(r27, NULL, gcc_dwarf_r27_mips64, gcc_dwarf_r27_mips64, LLDB_INVALID_REGNUM, gdb_r27_mips64), - DEFINE_GPR(gp, "r28", gcc_dwarf_gp_mips64, gcc_dwarf_gp_mips64, LLDB_INVALID_REGNUM, gdb_gp_mips64), - DEFINE_GPR(sp, "r29", gcc_dwarf_sp_mips64, gcc_dwarf_sp_mips64, LLDB_REGNUM_GENERIC_SP, gdb_sp_mips64), - DEFINE_GPR(r30, NULL, gcc_dwarf_r30_mips64, gcc_dwarf_r30_mips64, LLDB_REGNUM_GENERIC_FP, gdb_r30_mips64), - DEFINE_GPR(ra, "r31", gcc_dwarf_ra_mips64, gcc_dwarf_ra_mips64, LLDB_REGNUM_GENERIC_RA, gdb_ra_mips64), - DEFINE_GPR_INFO(sr, NULL, gcc_dwarf_sr_mips64, gcc_dwarf_sr_mips64, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM), - DEFINE_GPR(mullo, NULL, gcc_dwarf_lo_mips64, gcc_dwarf_lo_mips64, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM), - DEFINE_GPR(mulhi, NULL, gcc_dwarf_hi_mips64, gcc_dwarf_hi_mips64, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM), - DEFINE_GPR(badvaddr, NULL, gcc_dwarf_bad_mips64, gcc_dwarf_bad_mips64, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM), - DEFINE_GPR_INFO(cause, NULL, gcc_dwarf_cause_mips64, gcc_dwarf_cause_mips64, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM), - DEFINE_GPR(pc, "pc", gcc_dwarf_pc_mips64, gcc_dwarf_pc_mips64, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM), - DEFINE_GPR_INFO(config5, NULL, gcc_dwarf_config5_mips64, gcc_dwarf_config5_mips64, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM), - DEFINE_FPR (f0, NULL, gcc_dwarf_f0_mips64, gcc_dwarf_f0_mips64, LLDB_INVALID_REGNUM, gdb_f0_mips64), - DEFINE_FPR (f1, NULL, gcc_dwarf_f1_mips64, gcc_dwarf_f1_mips64, LLDB_INVALID_REGNUM, gdb_f1_mips64), - DEFINE_FPR (f2, NULL, gcc_dwarf_f2_mips64, gcc_dwarf_f2_mips64, LLDB_INVALID_REGNUM, gdb_f2_mips64), - DEFINE_FPR (f3, NULL, gcc_dwarf_f3_mips64, gcc_dwarf_f3_mips64, LLDB_INVALID_REGNUM, gdb_f3_mips64), - DEFINE_FPR (f4, NULL, gcc_dwarf_f4_mips64, gcc_dwarf_f4_mips64, LLDB_INVALID_REGNUM, gdb_f4_mips64), - DEFINE_FPR (f5, NULL, gcc_dwarf_f5_mips64, gcc_dwarf_f5_mips64, LLDB_INVALID_REGNUM, gdb_f5_mips64), - DEFINE_FPR (f6, NULL, gcc_dwarf_f6_mips64, gcc_dwarf_f6_mips64, LLDB_INVALID_REGNUM, gdb_f6_mips64), - DEFINE_FPR (f7, NULL, gcc_dwarf_f7_mips64, gcc_dwarf_f7_mips64, LLDB_INVALID_REGNUM, gdb_f7_mips64), - DEFINE_FPR (f8, NULL, gcc_dwarf_f8_mips64, gcc_dwarf_f8_mips64, LLDB_INVALID_REGNUM, gdb_f8_mips64), - DEFINE_FPR (f9, NULL, gcc_dwarf_f9_mips64, gcc_dwarf_f9_mips64, LLDB_INVALID_REGNUM, gdb_f9_mips64), - DEFINE_FPR (f10, NULL, gcc_dwarf_f10_mips64, gcc_dwarf_f10_mips64, LLDB_INVALID_REGNUM, gdb_f10_mips64), - DEFINE_FPR (f11, NULL, gcc_dwarf_f11_mips64, gcc_dwarf_f11_mips64, LLDB_INVALID_REGNUM, gdb_f11_mips64), - DEFINE_FPR (f12, NULL, gcc_dwarf_f12_mips64, gcc_dwarf_f12_mips64, LLDB_INVALID_REGNUM, gdb_f12_mips64), - DEFINE_FPR (f13, NULL, gcc_dwarf_f13_mips64, gcc_dwarf_f13_mips64, LLDB_INVALID_REGNUM, gdb_f13_mips64), - DEFINE_FPR (f14, NULL, gcc_dwarf_f14_mips64, gcc_dwarf_f14_mips64, LLDB_INVALID_REGNUM, gdb_f14_mips64), - DEFINE_FPR (f15, NULL, gcc_dwarf_f15_mips64, gcc_dwarf_f15_mips64, LLDB_INVALID_REGNUM, gdb_f15_mips64), - DEFINE_FPR (f16, NULL, gcc_dwarf_f16_mips64, gcc_dwarf_f16_mips64, LLDB_INVALID_REGNUM, gdb_f16_mips64), - DEFINE_FPR (f17, NULL, gcc_dwarf_f17_mips64, gcc_dwarf_f17_mips64, LLDB_INVALID_REGNUM, gdb_f17_mips64), - DEFINE_FPR (f18, NULL, gcc_dwarf_f18_mips64, gcc_dwarf_f18_mips64, LLDB_INVALID_REGNUM, gdb_f18_mips64), - DEFINE_FPR (f19, NULL, gcc_dwarf_f19_mips64, gcc_dwarf_f19_mips64, LLDB_INVALID_REGNUM, gdb_f19_mips64), - DEFINE_FPR (f20, NULL, gcc_dwarf_f20_mips64, gcc_dwarf_f20_mips64, LLDB_INVALID_REGNUM, gdb_f20_mips64), - DEFINE_FPR (f21, NULL, gcc_dwarf_f21_mips64, gcc_dwarf_f21_mips64, LLDB_INVALID_REGNUM, gdb_f21_mips64), - DEFINE_FPR (f22, NULL, gcc_dwarf_f22_mips64, gcc_dwarf_f22_mips64, LLDB_INVALID_REGNUM, gdb_f22_mips64), - DEFINE_FPR (f23, NULL, gcc_dwarf_f23_mips64, gcc_dwarf_f23_mips64, LLDB_INVALID_REGNUM, gdb_f23_mips64), - DEFINE_FPR (f24, NULL, gcc_dwarf_f24_mips64, gcc_dwarf_f24_mips64, LLDB_INVALID_REGNUM, gdb_f24_mips64), - DEFINE_FPR (f25, NULL, gcc_dwarf_f25_mips64, gcc_dwarf_f25_mips64, LLDB_INVALID_REGNUM, gdb_f25_mips64), - DEFINE_FPR (f26, NULL, gcc_dwarf_f26_mips64, gcc_dwarf_f26_mips64, LLDB_INVALID_REGNUM, gdb_f26_mips64), - DEFINE_FPR (f27, NULL, gcc_dwarf_f27_mips64, gcc_dwarf_f27_mips64, LLDB_INVALID_REGNUM, gdb_f27_mips64), - DEFINE_FPR (f28, NULL, gcc_dwarf_f28_mips64, gcc_dwarf_f28_mips64, LLDB_INVALID_REGNUM, gdb_f28_mips64), - DEFINE_FPR (f29, NULL, gcc_dwarf_f29_mips64, gcc_dwarf_f29_mips64, LLDB_INVALID_REGNUM, gdb_f29_mips64), - DEFINE_FPR (f30, NULL, gcc_dwarf_f30_mips64, gcc_dwarf_f30_mips64, LLDB_INVALID_REGNUM, gdb_f30_mips64), - DEFINE_FPR (f31, NULL, gcc_dwarf_f31_mips64, gcc_dwarf_f31_mips64, LLDB_INVALID_REGNUM, gdb_f31_mips64), - DEFINE_FPR (fcsr, NULL, gcc_dwarf_fcsr_mips64, gcc_dwarf_fcsr_mips64, LLDB_INVALID_REGNUM, gdb_fcsr_mips64), - DEFINE_FPR (fir, NULL, gcc_dwarf_fir_mips64, gcc_dwarf_fir_mips64, LLDB_INVALID_REGNUM, gdb_fir_mips64), - DEFINE_FPR (config5, NULL, gcc_dwarf_config5_mips64, gcc_dwarf_config5_mips64, LLDB_INVALID_REGNUM, gdb_config5_mips64), - DEFINE_MSA (w0, NULL, gcc_dwarf_w0_mips64, gcc_dwarf_w0_mips64, LLDB_INVALID_REGNUM, gdb_w0_mips64), - DEFINE_MSA (w1, NULL, gcc_dwarf_w1_mips64, gcc_dwarf_w1_mips64, LLDB_INVALID_REGNUM, gdb_w1_mips64), - DEFINE_MSA (w2, NULL, gcc_dwarf_w2_mips64, gcc_dwarf_w2_mips64, LLDB_INVALID_REGNUM, gdb_w2_mips64), - DEFINE_MSA (w3, NULL, gcc_dwarf_w3_mips64, gcc_dwarf_w3_mips64, LLDB_INVALID_REGNUM, gdb_w3_mips64), - DEFINE_MSA (w4, NULL, gcc_dwarf_w4_mips64, gcc_dwarf_w4_mips64, LLDB_INVALID_REGNUM, gdb_w4_mips64), - DEFINE_MSA (w5, NULL, gcc_dwarf_w5_mips64, gcc_dwarf_w5_mips64, LLDB_INVALID_REGNUM, gdb_w5_mips64), - DEFINE_MSA (w6, NULL, gcc_dwarf_w6_mips64, gcc_dwarf_w6_mips64, LLDB_INVALID_REGNUM, gdb_w6_mips64), - DEFINE_MSA (w7, NULL, gcc_dwarf_w7_mips64, gcc_dwarf_w7_mips64, LLDB_INVALID_REGNUM, gdb_w7_mips64), - DEFINE_MSA (w8, NULL, gcc_dwarf_w8_mips64, gcc_dwarf_w8_mips64, LLDB_INVALID_REGNUM, gdb_w8_mips64), - DEFINE_MSA (w9, NULL, gcc_dwarf_w9_mips64, gcc_dwarf_w9_mips64, LLDB_INVALID_REGNUM, gdb_w9_mips64), - DEFINE_MSA (w10, NULL, gcc_dwarf_w10_mips64, gcc_dwarf_w10_mips64, LLDB_INVALID_REGNUM, gdb_w10_mips64), - DEFINE_MSA (w11, NULL, gcc_dwarf_w11_mips64, gcc_dwarf_w11_mips64, LLDB_INVALID_REGNUM, gdb_w11_mips64), - DEFINE_MSA (w12, NULL, gcc_dwarf_w12_mips64, gcc_dwarf_w12_mips64, LLDB_INVALID_REGNUM, gdb_w12_mips64), - DEFINE_MSA (w13, NULL, gcc_dwarf_w13_mips64, gcc_dwarf_w13_mips64, LLDB_INVALID_REGNUM, gdb_w13_mips64), - DEFINE_MSA (w14, NULL, gcc_dwarf_w14_mips64, gcc_dwarf_w14_mips64, LLDB_INVALID_REGNUM, gdb_w14_mips64), - DEFINE_MSA (w15, NULL, gcc_dwarf_w15_mips64, gcc_dwarf_w15_mips64, LLDB_INVALID_REGNUM, gdb_w15_mips64), - DEFINE_MSA (w16, NULL, gcc_dwarf_w16_mips64, gcc_dwarf_w16_mips64, LLDB_INVALID_REGNUM, gdb_w16_mips64), - DEFINE_MSA (w17, NULL, gcc_dwarf_w17_mips64, gcc_dwarf_w17_mips64, LLDB_INVALID_REGNUM, gdb_w17_mips64), - DEFINE_MSA (w18, NULL, gcc_dwarf_w18_mips64, gcc_dwarf_w18_mips64, LLDB_INVALID_REGNUM, gdb_w18_mips64), - DEFINE_MSA (w19, NULL, gcc_dwarf_w19_mips64, gcc_dwarf_w19_mips64, LLDB_INVALID_REGNUM, gdb_w19_mips64), - DEFINE_MSA (w20, NULL, gcc_dwarf_w10_mips64, gcc_dwarf_w20_mips64, LLDB_INVALID_REGNUM, gdb_w20_mips64), - DEFINE_MSA (w21, NULL, gcc_dwarf_w21_mips64, gcc_dwarf_w21_mips64, LLDB_INVALID_REGNUM, gdb_w21_mips64), - DEFINE_MSA (w22, NULL, gcc_dwarf_w22_mips64, gcc_dwarf_w22_mips64, LLDB_INVALID_REGNUM, gdb_w22_mips64), - DEFINE_MSA (w23, NULL, gcc_dwarf_w23_mips64, gcc_dwarf_w23_mips64, LLDB_INVALID_REGNUM, gdb_w23_mips64), - DEFINE_MSA (w24, NULL, gcc_dwarf_w24_mips64, gcc_dwarf_w24_mips64, LLDB_INVALID_REGNUM, gdb_w24_mips64), - DEFINE_MSA (w25, NULL, gcc_dwarf_w25_mips64, gcc_dwarf_w25_mips64, LLDB_INVALID_REGNUM, gdb_w25_mips64), - DEFINE_MSA (w26, NULL, gcc_dwarf_w26_mips64, gcc_dwarf_w26_mips64, LLDB_INVALID_REGNUM, gdb_w26_mips64), - DEFINE_MSA (w27, NULL, gcc_dwarf_w27_mips64, gcc_dwarf_w27_mips64, LLDB_INVALID_REGNUM, gdb_w27_mips64), - DEFINE_MSA (w28, NULL, gcc_dwarf_w28_mips64, gcc_dwarf_w28_mips64, LLDB_INVALID_REGNUM, gdb_w28_mips64), - DEFINE_MSA (w29, NULL, gcc_dwarf_w29_mips64, gcc_dwarf_w29_mips64, LLDB_INVALID_REGNUM, gdb_w29_mips64), - DEFINE_MSA (w30, NULL, gcc_dwarf_w30_mips64, gcc_dwarf_w30_mips64, LLDB_INVALID_REGNUM, gdb_w30_mips64), - DEFINE_MSA (w31, NULL, gcc_dwarf_w31_mips64, gcc_dwarf_w31_mips64, LLDB_INVALID_REGNUM, gdb_w31_mips64), - DEFINE_MSA_INFO (mcsr, NULL, gcc_dwarf_mcsr_mips64, gcc_dwarf_mcsr_mips64, LLDB_INVALID_REGNUM, gdb_mcsr_mips64), - DEFINE_MSA_INFO (mir, NULL, gcc_dwarf_mir_mips64, gcc_dwarf_mir_mips64, LLDB_INVALID_REGNUM, gdb_mir_mips64), - DEFINE_MSA_INFO (fcsr, NULL, gcc_dwarf_fcsr_mips64, gcc_dwarf_fcsr_mips64, LLDB_INVALID_REGNUM, gdb_fcsr_mips64), - DEFINE_MSA_INFO (fir, NULL, gcc_dwarf_fir_mips64, gcc_dwarf_fir_mips64, LLDB_INVALID_REGNUM, gdb_fir_mips64), - DEFINE_MSA_INFO (config5, NULL, gcc_dwarf_config5_mips64, gcc_dwarf_config5_mips64, LLDB_INVALID_REGNUM, gdb_config5_mips64) -#endif + DEFINE_FPR (fp_reg[0], f0, NULL, gcc_dwarf_f0_mips64, gcc_dwarf_f0_mips64, LLDB_INVALID_REGNUM, gdb_f0_mips64), + DEFINE_FPR (fp_reg[1], f1, NULL, gcc_dwarf_f1_mips64, gcc_dwarf_f1_mips64, LLDB_INVALID_REGNUM, gdb_f1_mips64), + DEFINE_FPR (fp_reg[2], f2, NULL, gcc_dwarf_f2_mips64, gcc_dwarf_f2_mips64, LLDB_INVALID_REGNUM, gdb_f2_mips64), + DEFINE_FPR (fp_reg[3], f3, NULL, gcc_dwarf_f3_mips64, gcc_dwarf_f3_mips64, LLDB_INVALID_REGNUM, gdb_f3_mips64), + DEFINE_FPR (fp_reg[4], f4, NULL, gcc_dwarf_f4_mips64, gcc_dwarf_f4_mips64, LLDB_INVALID_REGNUM, gdb_f4_mips64), + DEFINE_FPR (fp_reg[5], f5, NULL, gcc_dwarf_f5_mips64, gcc_dwarf_f5_mips64, LLDB_INVALID_REGNUM, gdb_f5_mips64), + DEFINE_FPR (fp_reg[6], f6, NULL, gcc_dwarf_f6_mips64, gcc_dwarf_f6_mips64, LLDB_INVALID_REGNUM, gdb_f6_mips64), + DEFINE_FPR (fp_reg[7], f7, NULL, gcc_dwarf_f7_mips64, gcc_dwarf_f7_mips64, LLDB_INVALID_REGNUM, gdb_f7_mips64), + DEFINE_FPR (fp_reg[8], f8, NULL, gcc_dwarf_f8_mips64, gcc_dwarf_f8_mips64, LLDB_INVALID_REGNUM, gdb_f8_mips64), + DEFINE_FPR (fp_reg[9], f9, NULL, gcc_dwarf_f9_mips64, gcc_dwarf_f9_mips64, LLDB_INVALID_REGNUM, gdb_f9_mips64), + DEFINE_FPR (fp_reg[10], f10, NULL, gcc_dwarf_f10_mips64, gcc_dwarf_f10_mips64, LLDB_INVALID_REGNUM, gdb_f10_mips64), + DEFINE_FPR (fp_reg[11], f11, NULL, gcc_dwarf_f11_mips64, gcc_dwarf_f11_mips64, LLDB_INVALID_REGNUM, gdb_f11_mips64), + DEFINE_FPR (fp_reg[12], f12, NULL, gcc_dwarf_f12_mips64, gcc_dwarf_f12_mips64, LLDB_INVALID_REGNUM, gdb_f12_mips64), + DEFINE_FPR (fp_reg[13], f13, NULL, gcc_dwarf_f13_mips64, gcc_dwarf_f13_mips64, LLDB_INVALID_REGNUM, gdb_f13_mips64), + DEFINE_FPR (fp_reg[14], f14, NULL, gcc_dwarf_f14_mips64, gcc_dwarf_f14_mips64, LLDB_INVALID_REGNUM, gdb_f14_mips64), + DEFINE_FPR (fp_reg[15], f15, NULL, gcc_dwarf_f15_mips64, gcc_dwarf_f15_mips64, LLDB_INVALID_REGNUM, gdb_f15_mips64), + DEFINE_FPR (fp_reg[16], f16, NULL, gcc_dwarf_f16_mips64, gcc_dwarf_f16_mips64, LLDB_INVALID_REGNUM, gdb_f16_mips64), + DEFINE_FPR (fp_reg[17], f17, NULL, gcc_dwarf_f17_mips64, gcc_dwarf_f17_mips64, LLDB_INVALID_REGNUM, gdb_f17_mips64), + DEFINE_FPR (fp_reg[18], f18, NULL, gcc_dwarf_f18_mips64, gcc_dwarf_f18_mips64, LLDB_INVALID_REGNUM, gdb_f18_mips64), + DEFINE_FPR (fp_reg[19], f19, NULL, gcc_dwarf_f19_mips64, gcc_dwarf_f19_mips64, LLDB_INVALID_REGNUM, gdb_f19_mips64), + DEFINE_FPR (fp_reg[20], f20, NULL, gcc_dwarf_f20_mips64, gcc_dwarf_f20_mips64, LLDB_INVALID_REGNUM, gdb_f20_mips64), + DEFINE_FPR (fp_reg[21], f21, NULL, gcc_dwarf_f21_mips64, gcc_dwarf_f21_mips64, LLDB_INVALID_REGNUM, gdb_f21_mips64), + DEFINE_FPR (fp_reg[22], f22, NULL, gcc_dwarf_f22_mips64, gcc_dwarf_f22_mips64, LLDB_INVALID_REGNUM, gdb_f22_mips64), + DEFINE_FPR (fp_reg[23], f23, NULL, gcc_dwarf_f23_mips64, gcc_dwarf_f23_mips64, LLDB_INVALID_REGNUM, gdb_f23_mips64), + DEFINE_FPR (fp_reg[24], f24, NULL, gcc_dwarf_f24_mips64, gcc_dwarf_f24_mips64, LLDB_INVALID_REGNUM, gdb_f24_mips64), + DEFINE_FPR (fp_reg[25], f25, NULL, gcc_dwarf_f25_mips64, gcc_dwarf_f25_mips64, LLDB_INVALID_REGNUM, gdb_f25_mips64), + DEFINE_FPR (fp_reg[26], f26, NULL, gcc_dwarf_f26_mips64, gcc_dwarf_f26_mips64, LLDB_INVALID_REGNUM, gdb_f26_mips64), + DEFINE_FPR (fp_reg[27], f27, NULL, gcc_dwarf_f27_mips64, gcc_dwarf_f27_mips64, LLDB_INVALID_REGNUM, gdb_f27_mips64), + DEFINE_FPR (fp_reg[28], f28, NULL, gcc_dwarf_f28_mips64, gcc_dwarf_f28_mips64, LLDB_INVALID_REGNUM, gdb_f28_mips64), + DEFINE_FPR (fp_reg[29], f29, NULL, gcc_dwarf_f29_mips64, gcc_dwarf_f29_mips64, LLDB_INVALID_REGNUM, gdb_f29_mips64), + DEFINE_FPR (fp_reg[30], f30, NULL, gcc_dwarf_f30_mips64, gcc_dwarf_f30_mips64, LLDB_INVALID_REGNUM, gdb_f30_mips64), + DEFINE_FPR (fp_reg[31], f31, NULL, gcc_dwarf_f31_mips64, gcc_dwarf_f31_mips64, LLDB_INVALID_REGNUM, gdb_f31_mips64), + DEFINE_FPR (fcsr, fcsr, NULL, gcc_dwarf_fcsr_mips64, gcc_dwarf_fcsr_mips64, LLDB_INVALID_REGNUM, gdb_fcsr_mips64), + DEFINE_FPR (fir, fir, NULL, gcc_dwarf_fir_mips64, gcc_dwarf_fir_mips64, LLDB_INVALID_REGNUM, gdb_fir_mips64) }; - static_assert((sizeof(g_register_infos_mips64) / sizeof(g_register_infos_mips64[0])) == k_num_registers_mips64, "g_register_infos_mips64 has wrong number of register infos"); #undef DEFINE_GPR -#undef DEFINE_GPR_INFO #undef DEFINE_FPR -#undef DEFINE_MSA -#undef DEFINE_MSA_INFO #undef GPR_OFFSET #undef FPR_OFFSET -#undef MSA_OFFSET #endif // DECLARE_REGISTER_INFOS_MIPS64_STRUCT diff --git a/lldb/source/Plugins/Process/Utility/lldb-mips-freebsd-register-enums.h b/lldb/source/Plugins/Process/Utility/lldb-mips-freebsd-register-enums.h deleted file mode 100644 index 69dc9ef..0000000 --- a/lldb/source/Plugins/Process/Utility/lldb-mips-freebsd-register-enums.h +++ /dev/null @@ -1,70 +0,0 @@ -//===-- lldb-mips-frebsd-register-enums.h -------------------------------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#ifndef lldb_mips_freebsd_register_enums_h -#define lldb_mips_freebsd_register_enums_h - -namespace lldb_private -{ - // LLDB register codes (e.g. RegisterKind == eRegisterKindLLDB) - - //--------------------------------------------------------------------------- - // Internal codes for all mips registers. - //--------------------------------------------------------------------------- - enum - { - k_first_gpr_mips64, - gpr_zero_mips64 = k_first_gpr_mips64, - gpr_r1_mips64, - gpr_r2_mips64, - gpr_r3_mips64, - gpr_r4_mips64, - gpr_r5_mips64, - gpr_r6_mips64, - gpr_r7_mips64, - gpr_r8_mips64, - gpr_r9_mips64, - gpr_r10_mips64, - gpr_r11_mips64, - gpr_r12_mips64, - gpr_r13_mips64, - gpr_r14_mips64, - gpr_r15_mips64, - gpr_r16_mips64, - gpr_r17_mips64, - gpr_r18_mips64, - gpr_r19_mips64, - gpr_r20_mips64, - gpr_r21_mips64, - gpr_r22_mips64, - gpr_r23_mips64, - gpr_r24_mips64, - gpr_r25_mips64, - gpr_r26_mips64, - gpr_r27_mips64, - gpr_gp_mips64, - gpr_sp_mips64, - gpr_r30_mips64, - gpr_ra_mips64, - gpr_sr_mips64, - gpr_mullo_mips64, - gpr_mulhi_mips64, - gpr_badvaddr_mips64, - gpr_cause_mips64, - gpr_pc_mips64, - gpr_ic_mips64, - gpr_dummy_mips64, - k_last_gpr_mips64 = gpr_dummy_mips64, - - k_num_registers_mips64, - - k_num_gpr_registers_mips64 = k_last_gpr_mips64 - k_first_gpr_mips64 + 1 - }; -} -#endif // #ifndef lldb_mips_freebsd_register_enums_h diff --git a/lldb/source/Plugins/Process/Utility/lldb-mips-linux-register-enums.h b/lldb/source/Plugins/Process/Utility/lldb-mips64-register-enums.h similarity index 63% rename from lldb/source/Plugins/Process/Utility/lldb-mips-linux-register-enums.h rename to lldb/source/Plugins/Process/Utility/lldb-mips64-register-enums.h index 6c00025..e8c93a6 100644 --- a/lldb/source/Plugins/Process/Utility/lldb-mips-linux-register-enums.h +++ b/lldb/source/Plugins/Process/Utility/lldb-mips64-register-enums.h @@ -1,4 +1,4 @@ -//===-- lldb-mips-linux-register-enums.h -------------------------------*- C++ -*-===// +//===-- lldb-mips64-register-enums.h -------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -7,8 +7,8 @@ // //===----------------------------------------------------------------------===// -#ifndef lldb_mips_linux_register_enums_h -#define lldb_mips_linux_register_enums_h +#ifndef lldb_mips64_register_enums_h +#define lldb_mips64_register_enums_h namespace lldb_private { @@ -52,15 +52,14 @@ namespace lldb_private gpr_sp_mips, gpr_r30_mips, gpr_ra_mips, - gpr_sr_mips, gpr_mullo_mips, gpr_mulhi_mips, + gpr_pc_mips, gpr_badvaddr_mips, + gpr_sr_mips, gpr_cause_mips, - gpr_pc_mips, - gpr_config5_mips, - k_last_gpr_mips = gpr_config5_mips, + k_last_gpr_mips = gpr_cause_mips, k_first_fpr_mips, fpr_f0_mips = k_first_fpr_mips, @@ -97,55 +96,12 @@ namespace lldb_private fpr_f31_mips, fpr_fcsr_mips, fpr_fir_mips, - fpr_config5_mips, - k_last_fpr_mips = fpr_config5_mips, - - k_first_msa_mips, - msa_w0_mips = k_first_msa_mips, - msa_w1_mips, - msa_w2_mips, - msa_w3_mips, - msa_w4_mips, - msa_w5_mips, - msa_w6_mips, - msa_w7_mips, - msa_w8_mips, - msa_w9_mips, - msa_w10_mips, - msa_w11_mips, - msa_w12_mips, - msa_w13_mips, - msa_w14_mips, - msa_w15_mips, - msa_w16_mips, - msa_w17_mips, - msa_w18_mips, - msa_w19_mips, - msa_w20_mips, - msa_w21_mips, - msa_w22_mips, - msa_w23_mips, - msa_w24_mips, - msa_w25_mips, - msa_w26_mips, - msa_w27_mips, - msa_w28_mips, - msa_w29_mips, - msa_w30_mips, - msa_w31_mips, - msa_fcsr_mips, - msa_fir_mips, - msa_mcsr_mips, - msa_mir_mips, - msa_config5_mips, - k_last_msa_mips = msa_config5_mips, + k_last_fpr_mips = fpr_fir_mips, k_num_registers_mips, - k_num_gpr_registers_mips = k_last_gpr_mips - k_first_gpr_mips + 1, k_num_fpr_registers_mips = k_last_fpr_mips - k_first_fpr_mips + 1, - k_num_msa_registers_mips = k_last_msa_mips - k_first_msa_mips + 1, - k_num_user_registers_mips = k_num_gpr_registers_mips + k_num_fpr_registers_mips + k_num_msa_registers_mips + k_num_user_registers_mips = k_num_gpr_registers_mips + k_num_fpr_registers_mips, }; //--------------------------------------------------------------------------- @@ -186,14 +142,16 @@ namespace lldb_private gpr_sp_mips64, gpr_r30_mips64, gpr_ra_mips64, - gpr_sr_mips64, gpr_mullo_mips64, gpr_mulhi_mips64, + gpr_pc_mips64, gpr_badvaddr_mips64, + gpr_sr_mips64, gpr_cause_mips64, - gpr_pc_mips64, - gpr_config5_mips64, - k_last_gpr_mips64 = gpr_config5_mips64, + gpr_ic_mips64, + gpr_dummy_mips64, + + k_last_gpr_mips64 = gpr_dummy_mips64, k_first_fpr_mips64, fpr_f0_mips64 = k_first_fpr_mips64, @@ -230,56 +188,12 @@ namespace lldb_private fpr_f31_mips64, fpr_fcsr_mips64, fpr_fir_mips64, - fpr_config5_mips64, - k_last_fpr_mips64 = fpr_config5_mips64, - - k_first_msa_mips64, - msa_w0_mips64 = k_first_msa_mips64, - msa_w1_mips64, - msa_w2_mips64, - msa_w3_mips64, - msa_w4_mips64, - msa_w5_mips64, - msa_w6_mips64, - msa_w7_mips64, - msa_w8_mips64, - msa_w9_mips64, - msa_w10_mips64, - msa_w11_mips64, - msa_w12_mips64, - msa_w13_mips64, - msa_w14_mips64, - msa_w15_mips64, - msa_w16_mips64, - msa_w17_mips64, - msa_w18_mips64, - msa_w19_mips64, - msa_w20_mips64, - msa_w21_mips64, - msa_w22_mips64, - msa_w23_mips64, - msa_w24_mips64, - msa_w25_mips64, - msa_w26_mips64, - msa_w27_mips64, - msa_w28_mips64, - msa_w29_mips64, - msa_w30_mips64, - msa_w31_mips64, - msa_fcsr_mips64, - msa_fir_mips64, - msa_mcsr_mips64, - msa_mir_mips64, - msa_config5_mips64, - k_last_msa_mips64 = msa_config5_mips64, + k_last_fpr_mips64 = fpr_fir_mips64, k_num_registers_mips64, - k_num_gpr_registers_mips64 = k_last_gpr_mips64 - k_first_gpr_mips64 + 1, k_num_fpr_registers_mips64 = k_last_fpr_mips64 - k_first_fpr_mips64 + 1, - k_num_msa_registers_mips64 = k_last_msa_mips64 - k_first_msa_mips64 + 1, - k_num_user_registers_mips64 = k_num_gpr_registers_mips64 + k_num_fpr_registers_mips64 + k_num_msa_registers_mips64 }; } -#endif // #ifndef lldb_mips_linux_register_enums_h +#endif // #ifndef fpr_mips64_register_enums_h -- 2.7.4