[Lldb-commits] [lldb] r244514 - Revert r244308 since it's introducing test regressions on Linux:
Oleksiy Vyalov via lldb-commits
lldb-commits at lists.llvm.org
Mon Aug 10 14:49:51 PDT 2015
Author: ovyalov
Date: Mon Aug 10 16:49:50 2015
New Revision: 244514
URL: http://llvm.org/viewvc/llvm-project?rev=244514&view=rev
Log:
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
Added:
lldb/trunk/source/Plugins/Process/Utility/RegisterContext_mips64.h
- copied unchanged from r244307, lldb/trunk/source/Plugins/Process/Utility/RegisterContext_mips64.h
lldb/trunk/source/Plugins/Process/Utility/lldb-mips64-register-enums.h
- copied unchanged from r244307, lldb/trunk/source/Plugins/Process/Utility/lldb-mips64-register-enums.h
Removed:
lldb/trunk/source/Plugins/Process/Utility/RegisterContext_mips.h
lldb/trunk/source/Plugins/Process/Utility/lldb-mips-freebsd-register-enums.h
lldb/trunk/source/Plugins/Process/Utility/lldb-mips-linux-register-enums.h
Modified:
lldb/trunk/include/lldb/Core/RegisterValue.h
lldb/trunk/include/lldb/Core/Scalar.h
lldb/trunk/include/lldb/Core/Value.h
lldb/trunk/include/lldb/lldb-private-types.h
lldb/trunk/source/Core/RegisterValue.cpp
lldb/trunk/source/Core/Scalar.cpp
lldb/trunk/source/Core/ValueObject.cpp
lldb/trunk/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp
lldb/trunk/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp
lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp
lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp
lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h
lldb/trunk/source/Plugins/Process/Utility/RegisterContextFreeBSD_mips64.cpp
lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips.cpp
lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips.h
lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips64.cpp
lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips64.h
lldb/trunk/source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.h
lldb/trunk/source/Plugins/Process/Utility/RegisterInfos_mips.h
lldb/trunk/source/Plugins/Process/Utility/RegisterInfos_mips64.h
Modified: lldb/trunk/include/lldb/Core/RegisterValue.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/RegisterValue.h?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Core/RegisterValue.h (original)
+++ lldb/trunk/include/lldb/Core/RegisterValue.h Mon Aug 10 16:49:50 2015
@@ -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
+ union
{
- 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;
+ 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
Modified: lldb/trunk/include/lldb/Core/Scalar.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/Scalar.h?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Core/Scalar.h (original)
+++ lldb/trunk/include/lldb/Core/Scalar.h Mon Aug 10 16:49:50 2015
@@ -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);
Modified: lldb/trunk/include/lldb/Core/Value.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/Value.h?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Core/Value.h (original)
+++ lldb/trunk/include/lldb/Core/Value.h Mon Aug 10 16:49:50 2015
@@ -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;
}
Modified: lldb/trunk/include/lldb/lldb-private-types.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/lldb-private-types.h?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/include/lldb/lldb-private-types.h (original)
+++ lldb/trunk/include/lldb/lldb-private-types.h Mon Aug 10 16:49:50 2015
@@ -102,8 +102,6 @@ namespace lldb_private
// pass it.
};
- typedef struct type128 { uint64_t x[2]; } type128;
-
} // namespace lldb_private
#endif // #if defined(__cplusplus)
Modified: lldb/trunk/source/Core/RegisterValue.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Core/RegisterValue.cpp?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/source/Core/RegisterValue.cpp (original)
+++ lldb/trunk/source/Core/RegisterValue.cpp Mon Aug 10 16:49:50 2015
@@ -215,10 +215,10 @@ RegisterValue::SetFromMemoryData (const
}
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 &s
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 RegisterIn
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 R
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 R
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 (cons
}
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 (cons
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
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 Register
{
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 fai
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 fai
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 fai
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 fai
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
*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_va
{
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_
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 dou
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, u
{
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 Regist
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 Regist
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;
}
}
Modified: lldb/trunk/source/Core/Scalar.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Core/Scalar.cpp?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/source/Core/Scalar.cpp (original)
+++ lldb/trunk/source/Core/Scalar.cpp Mon Aug 10 16:49:50 2015
@@ -11,7 +11,6 @@
#include <math.h>
#include <inttypes.h>
-#include <stdio.h>
#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, si
// 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, si
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_t
{
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::T
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::T
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::T
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::GetValueTypeForSignedIntegerWith
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)
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
{
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)
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 fai
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_valu
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&
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&
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& l
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& l
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& l
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& l
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& l
{
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& l
{
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& l
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& l
{
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&
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
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
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
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
{
Error error;
- type128 int128;
switch (encoding)
{
case lldb::eEncodingInvalid:
@@ -3183,25 +1904,10 @@ Scalar::SetValueFromData (DataExtractor
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
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_po
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_si
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&
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&
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& l
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&
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& l
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&
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;
-}
+
+
Modified: lldb/trunk/source/Core/ValueObject.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Core/ValueObject.cpp?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/source/Core/ValueObject.cpp (original)
+++ lldb/trunk/source/Core/ValueObject.cpp Mon Aug 10 16:49:50 2015
@@ -1897,7 +1897,7 @@ ValueObject::SetValueFromCString (const
// 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.
Modified: lldb/trunk/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp (original)
+++ lldb/trunk/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp Mon Aug 10 16:49:50 2015
@@ -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
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";
}
Modified: lldb/trunk/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp (original)
+++ lldb/trunk/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp Mon Aug 10 16:49:50 2015
@@ -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::GetRegisterNam
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";
}
Modified: lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp (original)
+++ lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp Mon Aug 10 16:49:50 2015
@@ -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);
Modified: lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp (original)
+++ lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp Mon Aug 10 16:49:50 2015
@@ -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 <sys/ptrace.h>
#include <asm/ptrace.h>
@@ -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::CreateHostNa
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::Nativ
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::Nativ
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::ReadR
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::ReadR
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::Write
if (reg_index == LLDB_INVALID_REGNUM)
return Error ("no lldb regnum for %s", reg_info && reg_info->name ? reg_info->name : "<unknown register>");
- 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::Write
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::ReadA
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::ReadA
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::Write
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::Write
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::Write
}
Error
-NativeRegisterContextLinux_mips64::ReadCP1()
+NativeRegisterContextLinux_mips64::ReadFPR()
{
- Error error;
+ void* buf = GetFPRBuffer();
+ if (!buf)
+ return Error("FPR buffer is NULL");
- uint8_t *src, *dst;
+ Error error = NativeRegisterContextLinux::ReadFPR();
- lldb::ByteOrder byte_order = GetByteOrder();
-
- uint32_t IsBigEndian = (byte_order == lldb::eByteOrderBig);
-
- if (IsMSAAvailable())
- {
- 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
+ if (IsFR0())
{
- 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::ReadC
}
Error
-NativeRegisterContextLinux_mips64::WriteCP1()
+NativeRegisterContextLinux_mips64::WriteFPR()
{
- Error error;
-
- uint8_t *src, *dst;
-
- lldb::ByteOrder byte_order = GetByteOrder();
+ void* buf = GetFPRBuffer();
+ if (!buf)
+ return Error("FPR buffer is NULL");
- uint32_t IsBigEndian = (byte_order == lldb::eByteOrderBig);
-
- 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_reg
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::DoRea
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");
}
Modified: lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h (original)
+++ lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h Mon Aug 10 16:49:50 2015
@@ -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
Modified: lldb/trunk/source/Plugins/Process/Utility/RegisterContextFreeBSD_mips64.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/Utility/RegisterContextFreeBSD_mips64.cpp?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Process/Utility/RegisterContextFreeBSD_mips64.cpp (original)
+++ lldb/trunk/source/Plugins/Process/Utility/RegisterContextFreeBSD_mips64.cpp Mon Aug 10 16:49:50 2015
@@ -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::RegisterC
size_t
RegisterContextFreeBSD_mips64::GetGPRSize() const
{
- return sizeof(GPR_freebsd_mips);
+ return sizeof(GPR);
}
const RegisterInfo *
Modified: lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips.cpp?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips.cpp (original)
+++ lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips.cpp Mon Aug 10 16:49:50 2015
@@ -10,17 +10,59 @@
#include <vector>
#include <stddef.h>
+// 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::RegisterConte
size_t
RegisterContextLinux_mips::GetGPRSize() const
{
- return sizeof(GPR_linux_mips);
+ return sizeof(GPR);
}
const RegisterInfo *
@@ -58,9 +100,3 @@ RegisterContextLinux_mips::GetRegisterCo
{
return static_cast<uint32_t> (sizeof (g_register_infos_mips) / sizeof (g_register_infos_mips [0]));
}
-
-uint32_t
-RegisterContextLinux_mips::GetUserRegisterCount () const
-{
- return static_cast<uint32_t> (k_num_user_registers_mips);
-}
Modified: lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips.h?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips.h (original)
+++ lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips.h Mon Aug 10 16:49:50 2015
@@ -27,9 +27,6 @@ public:
uint32_t
GetRegisterCount () const override;
-
- uint32_t
- GetUserRegisterCount () const override;
};
#endif
Modified: lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips64.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips64.cpp?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips64.cpp (original)
+++ lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips64.cpp Mon Aug 10 16:49:50 2015
@@ -12,24 +12,66 @@
#include <vector>
#include <stddef.h>
+// 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 &ta
}
}
-uint32_t
-GetUserRegisterInfoCount (const ArchSpec &target_arch)
-{
- switch (target_arch.GetMachine())
- {
- case llvm::Triple::mips:
- case llvm::Triple::mipsel:
- return static_cast<uint32_t> (k_num_user_registers_mips);
- case llvm::Triple::mips64el:
- case llvm::Triple::mips64:
- return static_cast<uint32_t> (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::GetRegister
return m_register_info_count;
}
-uint32_t
-RegisterContextLinux_mips64::GetUserRegisterCount () const
-{
- return m_user_register_count;
-}
-
#endif
Modified: lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips64.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips64.h?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips64.h (original)
+++ lldb/trunk/source/Plugins/Process/Utility/RegisterContextLinux_mips64.h Mon Aug 10 16:49:50 2015
@@ -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
Modified: lldb/trunk/source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.h?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.h (original)
+++ lldb/trunk/source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.h Mon Aug 10 16:49:50 2015
@@ -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;
Removed: lldb/trunk/source/Plugins/Process/Utility/RegisterContext_mips.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/Utility/RegisterContext_mips.h?rev=244513&view=auto
==============================================================================
--- lldb/trunk/source/Plugins/Process/Utility/RegisterContext_mips.h (original)
+++ lldb/trunk/source/Plugins/Process/Utility/RegisterContext_mips.h (removed)
@@ -1,614 +0,0 @@
-//===-- RegisterContext_mips.h --------------------------------*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#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
-{
- // GP Registers
- gcc_dwarf_zero_mips = 0,
- gcc_dwarf_r1_mips,
- gcc_dwarf_r2_mips,
- gcc_dwarf_r3_mips,
- gcc_dwarf_r4_mips,
- gcc_dwarf_r5_mips,
- gcc_dwarf_r6_mips,
- gcc_dwarf_r7_mips,
- gcc_dwarf_r8_mips,
- gcc_dwarf_r9_mips,
- gcc_dwarf_r10_mips,
- gcc_dwarf_r11_mips,
- gcc_dwarf_r12_mips,
- gcc_dwarf_r13_mips,
- gcc_dwarf_r14_mips,
- gcc_dwarf_r15_mips,
- gcc_dwarf_r16_mips,
- gcc_dwarf_r17_mips,
- gcc_dwarf_r18_mips,
- gcc_dwarf_r19_mips,
- gcc_dwarf_r20_mips,
- gcc_dwarf_r21_mips,
- gcc_dwarf_r22_mips,
- gcc_dwarf_r23_mips,
- gcc_dwarf_r24_mips,
- gcc_dwarf_r25_mips,
- gcc_dwarf_r26_mips,
- gcc_dwarf_r27_mips,
- gcc_dwarf_gp_mips,
- 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_bad_mips,
- gcc_dwarf_cause_mips,
- gcc_dwarf_pc_mips,
- gcc_dwarf_f0_mips,
- gcc_dwarf_f1_mips,
- gcc_dwarf_f2_mips,
- gcc_dwarf_f3_mips,
- gcc_dwarf_f4_mips,
- gcc_dwarf_f5_mips,
- gcc_dwarf_f6_mips,
- gcc_dwarf_f7_mips,
- gcc_dwarf_f8_mips,
- gcc_dwarf_f9_mips,
- gcc_dwarf_f10_mips,
- gcc_dwarf_f11_mips,
- gcc_dwarf_f12_mips,
- gcc_dwarf_f13_mips,
- gcc_dwarf_f14_mips,
- gcc_dwarf_f15_mips,
- gcc_dwarf_f16_mips,
- gcc_dwarf_f17_mips,
- gcc_dwarf_f18_mips,
- gcc_dwarf_f19_mips,
- gcc_dwarf_f20_mips,
- gcc_dwarf_f21_mips,
- gcc_dwarf_f22_mips,
- gcc_dwarf_f23_mips,
- gcc_dwarf_f24_mips,
- gcc_dwarf_f25_mips,
- gcc_dwarf_f26_mips,
- gcc_dwarf_f27_mips,
- gcc_dwarf_f28_mips,
- gcc_dwarf_f29_mips,
- gcc_dwarf_f30_mips,
- 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
-};
-
-enum
-{
- gcc_dwarf_zero_mips64 = 0,
- gcc_dwarf_r1_mips64,
- gcc_dwarf_r2_mips64,
- gcc_dwarf_r3_mips64,
- gcc_dwarf_r4_mips64,
- gcc_dwarf_r5_mips64,
- gcc_dwarf_r6_mips64,
- gcc_dwarf_r7_mips64,
- gcc_dwarf_r8_mips64,
- gcc_dwarf_r9_mips64,
- gcc_dwarf_r10_mips64,
- gcc_dwarf_r11_mips64,
- gcc_dwarf_r12_mips64,
- gcc_dwarf_r13_mips64,
- gcc_dwarf_r14_mips64,
- gcc_dwarf_r15_mips64,
- gcc_dwarf_r16_mips64,
- gcc_dwarf_r17_mips64,
- gcc_dwarf_r18_mips64,
- gcc_dwarf_r19_mips64,
- gcc_dwarf_r20_mips64,
- gcc_dwarf_r21_mips64,
- gcc_dwarf_r22_mips64,
- gcc_dwarf_r23_mips64,
- gcc_dwarf_r24_mips64,
- gcc_dwarf_r25_mips64,
- gcc_dwarf_r26_mips64,
- gcc_dwarf_r27_mips64,
- gcc_dwarf_gp_mips64,
- gcc_dwarf_sp_mips64,
- gcc_dwarf_r30_mips64,
- gcc_dwarf_ra_mips64,
- gcc_dwarf_sr_mips64,
- gcc_dwarf_lo_mips64,
- gcc_dwarf_hi_mips64,
- gcc_dwarf_bad_mips64,
- gcc_dwarf_cause_mips64,
- gcc_dwarf_pc_mips64,
- gcc_dwarf_f0_mips64,
- gcc_dwarf_f1_mips64,
- gcc_dwarf_f2_mips64,
- gcc_dwarf_f3_mips64,
- gcc_dwarf_f4_mips64,
- gcc_dwarf_f5_mips64,
- gcc_dwarf_f6_mips64,
- gcc_dwarf_f7_mips64,
- gcc_dwarf_f8_mips64,
- gcc_dwarf_f9_mips64,
- gcc_dwarf_f10_mips64,
- gcc_dwarf_f11_mips64,
- gcc_dwarf_f12_mips64,
- gcc_dwarf_f13_mips64,
- gcc_dwarf_f14_mips64,
- gcc_dwarf_f15_mips64,
- gcc_dwarf_f16_mips64,
- gcc_dwarf_f17_mips64,
- gcc_dwarf_f18_mips64,
- gcc_dwarf_f19_mips64,
- gcc_dwarf_f20_mips64,
- gcc_dwarf_f21_mips64,
- gcc_dwarf_f22_mips64,
- gcc_dwarf_f23_mips64,
- gcc_dwarf_f24_mips64,
- gcc_dwarf_f25_mips64,
- gcc_dwarf_f26_mips64,
- gcc_dwarf_f27_mips64,
- gcc_dwarf_f28_mips64,
- gcc_dwarf_f29_mips64,
- gcc_dwarf_f30_mips64,
- gcc_dwarf_f31_mips64,
- 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,
-};
-
-// GDB Register numbers (eRegisterKindGDB)
-enum
-{
- gdb_zero_mips = 0,
- gdb_r1_mips,
- gdb_r2_mips,
- gdb_r3_mips,
- gdb_r4_mips,
- gdb_r5_mips,
- gdb_r6_mips,
- gdb_r7_mips,
- gdb_r8_mips,
- gdb_r9_mips,
- gdb_r10_mips,
- gdb_r11_mips,
- gdb_r12_mips,
- gdb_r13_mips,
- gdb_r14_mips,
- gdb_r15_mips,
- gdb_r16_mips,
- gdb_r17_mips,
- gdb_r18_mips,
- gdb_r19_mips,
- gdb_r20_mips,
- gdb_r21_mips,
- gdb_r22_mips,
- gdb_r23_mips,
- gdb_r24_mips,
- gdb_r25_mips,
- gdb_r26_mips,
- gdb_r27_mips,
- gdb_gp_mips,
- gdb_sp_mips,
- gdb_r30_mips,
- gdb_ra_mips,
- gdb_sr_mips,
- gdb_lo_mips,
- gdb_hi_mips,
- gdb_bad_mips,
- gdb_cause_mips,
- gdb_pc_mips,
- gdb_f0_mips,
- gdb_f1_mips,
- gdb_f2_mips,
- gdb_f3_mips,
- gdb_f4_mips,
- gdb_f5_mips,
- gdb_f6_mips,
- gdb_f7_mips,
- gdb_f8_mips,
- gdb_f9_mips,
- gdb_f10_mips,
- gdb_f11_mips,
- gdb_f12_mips,
- gdb_f13_mips,
- gdb_f14_mips,
- gdb_f15_mips,
- gdb_f16_mips,
- gdb_f17_mips,
- gdb_f18_mips,
- gdb_f19_mips,
- gdb_f20_mips,
- gdb_f21_mips,
- gdb_f22_mips,
- gdb_f23_mips,
- gdb_f24_mips,
- gdb_f25_mips,
- gdb_f26_mips,
- gdb_f27_mips,
- gdb_f28_mips,
- gdb_f29_mips,
- gdb_f30_mips,
- 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
-};
-
-enum
-{
- gdb_zero_mips64 = 0,
- gdb_r1_mips64,
- gdb_r2_mips64,
- gdb_r3_mips64,
- gdb_r4_mips64,
- gdb_r5_mips64,
- gdb_r6_mips64,
- gdb_r7_mips64,
- gdb_r8_mips64,
- gdb_r9_mips64,
- gdb_r10_mips64,
- gdb_r11_mips64,
- gdb_r12_mips64,
- gdb_r13_mips64,
- gdb_r14_mips64,
- gdb_r15_mips64,
- gdb_r16_mips64,
- gdb_r17_mips64,
- gdb_r18_mips64,
- gdb_r19_mips64,
- gdb_r20_mips64,
- gdb_r21_mips64,
- gdb_r22_mips64,
- gdb_r23_mips64,
- gdb_r24_mips64,
- gdb_r25_mips64,
- gdb_r26_mips64,
- gdb_r27_mips64,
- gdb_gp_mips64,
- gdb_sp_mips64,
- gdb_r30_mips64,
- gdb_ra_mips64,
- gdb_sr_mips64,
- gdb_lo_mips64,
- gdb_hi_mips64,
- gdb_bad_mips64,
- gdb_cause_mips64,
- gdb_pc_mips64,
- gdb_f0_mips64,
- gdb_f1_mips64,
- gdb_f2_mips64,
- gdb_f3_mips64,
- gdb_f4_mips64,
- gdb_f5_mips64,
- gdb_f6_mips64,
- gdb_f7_mips64,
- gdb_f8_mips64,
- gdb_f9_mips64,
- gdb_f10_mips64,
- gdb_f11_mips64,
- gdb_f12_mips64,
- gdb_f13_mips64,
- gdb_f14_mips64,
- gdb_f15_mips64,
- gdb_f16_mips64,
- gdb_f17_mips64,
- gdb_f18_mips64,
- gdb_f19_mips64,
- gdb_f20_mips64,
- gdb_f21_mips64,
- gdb_f22_mips64,
- gdb_f23_mips64,
- gdb_f24_mips64,
- gdb_f25_mips64,
- gdb_f26_mips64,
- gdb_f27_mips64,
- gdb_f28_mips64,
- gdb_f29_mips64,
- gdb_f30_mips64,
- gdb_f31_mips64,
- 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 */
-};
-
-struct UserArea
-{
- GPR_linux_mips gpr; // General purpose registers.
- FPR_linux_mips fpr; // Floating point registers.
- MSA_linux_mips msa; // MSA registers.
-};
-
-#endif // liblldb_RegisterContext_mips64_H_
Modified: lldb/trunk/source/Plugins/Process/Utility/RegisterInfos_mips.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/Utility/RegisterInfos_mips.h?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Process/Utility/RegisterInfos_mips.h (original)
+++ lldb/trunk/source/Plugins/Process/Utility/RegisterInfos_mips.h Mon Aug 10 16:49:50 2015
@@ -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
Modified: lldb/trunk/source/Plugins/Process/Utility/RegisterInfos_mips64.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/Utility/RegisterInfos_mips64.h?rev=244514&r1=244513&r2=244514&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Process/Utility/RegisterInfos_mips64.h (original)
+++ lldb/trunk/source/Plugins/Process/Utility/RegisterInfos_mips64.h Mon Aug 10 16:49:50 2015
@@ -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
Removed: lldb/trunk/source/Plugins/Process/Utility/lldb-mips-freebsd-register-enums.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/Utility/lldb-mips-freebsd-register-enums.h?rev=244513&view=auto
==============================================================================
--- lldb/trunk/source/Plugins/Process/Utility/lldb-mips-freebsd-register-enums.h (original)
+++ lldb/trunk/source/Plugins/Process/Utility/lldb-mips-freebsd-register-enums.h (removed)
@@ -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
Removed: lldb/trunk/source/Plugins/Process/Utility/lldb-mips-linux-register-enums.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/Utility/lldb-mips-linux-register-enums.h?rev=244513&view=auto
==============================================================================
--- lldb/trunk/source/Plugins/Process/Utility/lldb-mips-linux-register-enums.h (original)
+++ lldb/trunk/source/Plugins/Process/Utility/lldb-mips-linux-register-enums.h (removed)
@@ -1,285 +0,0 @@
-//===-- lldb-mips-linux-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_linux_register_enums_h
-#define lldb_mips_linux_register_enums_h
-
-namespace lldb_private
-{
- // LLDB register codes (e.g. RegisterKind == eRegisterKindLLDB)
-
- //---------------------------------------------------------------------------
- // Internal codes for all mips registers.
- //---------------------------------------------------------------------------
- enum
- {
- k_first_gpr_mips,
- gpr_zero_mips = k_first_gpr_mips,
- gpr_r1_mips,
- gpr_r2_mips,
- gpr_r3_mips,
- gpr_r4_mips,
- gpr_r5_mips,
- gpr_r6_mips,
- gpr_r7_mips,
- gpr_r8_mips,
- gpr_r9_mips,
- gpr_r10_mips,
- gpr_r11_mips,
- gpr_r12_mips,
- gpr_r13_mips,
- gpr_r14_mips,
- gpr_r15_mips,
- gpr_r16_mips,
- gpr_r17_mips,
- gpr_r18_mips,
- gpr_r19_mips,
- gpr_r20_mips,
- gpr_r21_mips,
- gpr_r22_mips,
- gpr_r23_mips,
- gpr_r24_mips,
- gpr_r25_mips,
- gpr_r26_mips,
- gpr_r27_mips,
- gpr_gp_mips,
- gpr_sp_mips,
- gpr_r30_mips,
- gpr_ra_mips,
- gpr_sr_mips,
- gpr_mullo_mips,
- gpr_mulhi_mips,
- gpr_badvaddr_mips,
- gpr_cause_mips,
- gpr_pc_mips,
- gpr_config5_mips,
-
- k_last_gpr_mips = gpr_config5_mips,
-
- k_first_fpr_mips,
- fpr_f0_mips = k_first_fpr_mips,
- fpr_f1_mips,
- fpr_f2_mips,
- fpr_f3_mips,
- fpr_f4_mips,
- fpr_f5_mips,
- fpr_f6_mips,
- fpr_f7_mips,
- fpr_f8_mips,
- fpr_f9_mips,
- fpr_f10_mips,
- fpr_f11_mips,
- fpr_f12_mips,
- fpr_f13_mips,
- fpr_f14_mips,
- fpr_f15_mips,
- fpr_f16_mips,
- fpr_f17_mips,
- fpr_f18_mips,
- fpr_f19_mips,
- fpr_f20_mips,
- fpr_f21_mips,
- fpr_f22_mips,
- fpr_f23_mips,
- fpr_f24_mips,
- fpr_f25_mips,
- fpr_f26_mips,
- fpr_f27_mips,
- fpr_f28_mips,
- fpr_f29_mips,
- fpr_f30_mips,
- 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_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
- };
-
- //---------------------------------------------------------------------------
- // Internal codes for all mips64 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_config5_mips64,
- k_last_gpr_mips64 = gpr_config5_mips64,
-
- k_first_fpr_mips64,
- fpr_f0_mips64 = k_first_fpr_mips64,
- fpr_f1_mips64,
- fpr_f2_mips64,
- fpr_f3_mips64,
- fpr_f4_mips64,
- fpr_f5_mips64,
- fpr_f6_mips64,
- fpr_f7_mips64,
- fpr_f8_mips64,
- fpr_f9_mips64,
- fpr_f10_mips64,
- fpr_f11_mips64,
- fpr_f12_mips64,
- fpr_f13_mips64,
- fpr_f14_mips64,
- fpr_f15_mips64,
- fpr_f16_mips64,
- fpr_f17_mips64,
- fpr_f18_mips64,
- fpr_f19_mips64,
- fpr_f20_mips64,
- fpr_f21_mips64,
- fpr_f22_mips64,
- fpr_f23_mips64,
- fpr_f24_mips64,
- fpr_f25_mips64,
- fpr_f26_mips64,
- fpr_f27_mips64,
- fpr_f28_mips64,
- fpr_f29_mips64,
- fpr_f30_mips64,
- 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_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
More information about the lldb-commits
mailing list