[Lldb-commits] [lldb] r245547 - [LLDB] Use llvm::APInt and llvm::APFloat in Scalar and RegisterValue
Tamas Berghammer via lldb-commits
lldb-commits at lists.llvm.org
Fri Aug 21 03:32:51 PDT 2015
I don't see where is the dependency between the 2 CL, but I understand that
you want to have r245240 in 3.7 to have better MIPS support. Personally I
would prefer to fix the compile issue at the release branch with a small
change if possible and then leave this CL out, but if you agree with Greg
that merging this CL is the good solution then I am fine with it. I won't
depend on the release branch, but still would like to see a fairly stable
version there.
Thanks,
Tamas
On Fri, Aug 21, 2015 at 11:23 AM <Sagar.Thakur at imgtec.com> wrote:
> Hi Tamas,
>
> The code in release branch will fail to compile on mips if we don’t merge
> this change because the commit r245240 in the release branch is dependant
> on this change. If we don't want to merge this change to the release
> branch then we will have to revert r245240 from the release branch so that
> the code from release branch can compile properly.
>
> Thanks,
> Sagar
>
>
> On Friday 21 August 2015 03:06 PM, Tamas Berghammer wrote:
>
> Hi Sagar,
>
> I don't really happy with merging a big change to the release branch at
> the last moment (after RC3) especially as this commit caused several issues
> in the past and I don't think we tested it extensively enough to be sure it
> is works as intended at the moment.
>
> Is there any reason you really want this change in LLDB 3.7 considering
> that we won't create a binary with the release as far as I know?
>
> Thanks,
> Tamas
>
> On Fri, Aug 21, 2015 at 10:20 AM via lldb-commits <
> lldb-commits at lists.llvm.org> wrote:
>
>> Hi Hans,
>>
>> Could you please merge r245547 to the release branch ?
>>
>> Thanks,
>> Sagar
>>
>> On Thursday 20 August 2015 02:42 PM, Sagar Thakur via lldb-commits wrote:
>> > Author: slthakur
>> > Date: Thu Aug 20 04:12:46 2015
>> > New Revision: 245547
>> >
>> > URL: http://llvm.org/viewvc/llvm-project?rev=245547&view=rev
>> > Log:
>> > [LLDB] Use llvm::APInt and llvm::APFloat in Scalar and RegisterValue
>> >
>> > Eliminated ENABLE_128_BIT_SUPPORT and union ValueData from Scalar.cpp
>> and use llvm::APInt and llvm::APFloat for all integer and floating point
>> types. Also used Scalar in RegisterValue.cpp
>> >
>> > Reviewers: tberghammer, ovyalov, clayborg, labath
>> > Subscribers: lldb-commits, nitesh.jain, jaydeep
>> > Differential: http://reviews.llvm.org/D12100
>> >
>> > 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
>> >
>> > Modified: lldb/trunk/include/lldb/Core/RegisterValue.h
>> > URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/RegisterValue.h?rev=245547&r1=245546&r2=245547&view=diff
>> >
>> ==============================================================================
>> > --- lldb/trunk/include/lldb/Core/RegisterValue.h (original)
>> > +++ lldb/trunk/include/lldb/Core/RegisterValue.h Thu Aug 20 04:12:46
>> 2015
>> > @@ -19,8 +19,9 @@
>> > #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
>> > @@ -37,9 +38,7 @@ namespace lldb_private {
>> > eTypeUInt16,
>> > eTypeUInt32,
>> > eTypeUInt64,
>> > -#if defined (ENABLE_128_BIT_SUPPORT)
>> > eTypeUInt128,
>> > -#endif
>> > eTypeFloat,
>> > eTypeDouble,
>> > eTypeLongDouble,
>> > @@ -47,7 +46,8 @@ namespace lldb_private {
>> > };
>> >
>> > RegisterValue () :
>> > - m_type (eTypeInvalid)
>> > + m_type (eTypeInvalid),
>> > + m_scalar ((unsigned long)0)
>> > {
>> > }
>> >
>> > @@ -55,57 +55,55 @@ namespace lldb_private {
>> > RegisterValue (uint8_t inst) :
>> > m_type (eTypeUInt8)
>> > {
>> > - m_data.uint8 = inst;
>> > + m_scalar = inst;
>> > }
>> >
>> > explicit
>> > RegisterValue (uint16_t inst) :
>> > m_type (eTypeUInt16)
>> > {
>> > - m_data.uint16 = inst;
>> > + m_scalar = inst;
>> > }
>> >
>> > explicit
>> > RegisterValue (uint32_t inst) :
>> > m_type (eTypeUInt32)
>> > {
>> > - m_data.uint32 = inst;
>> > + m_scalar = inst;
>> > }
>> >
>> > explicit
>> > RegisterValue (uint64_t inst) :
>> > m_type (eTypeUInt64)
>> > {
>> > - m_data.uint64 = inst;
>> > + m_scalar = inst;
>> > }
>> >
>> > -#if defined (ENABLE_128_BIT_SUPPORT)
>> > explicit
>> > - RegisterValue (__uint128_t inst) :
>> > + RegisterValue (llvm::APInt inst) :
>> > m_type (eTypeUInt128)
>> > {
>> > - m_data.uint128 = inst;
>> > + m_scalar = llvm::APInt(inst);
>> > }
>> > -#endif
>> > explicit
>> > RegisterValue (float value) :
>> > m_type (eTypeFloat)
>> > {
>> > - m_data.ieee_float = value;
>> > + m_scalar = value;
>> > }
>> >
>> > explicit
>> > RegisterValue (double value) :
>> > m_type (eTypeDouble)
>> > {
>> > - m_data.ieee_double = value;
>> > + m_scalar = value;
>> > }
>> >
>> > explicit
>> > RegisterValue (long double value) :
>> > m_type (eTypeLongDouble)
>> > {
>> > - m_data.ieee_long_double = value;
>> > + m_scalar = value;
>> > }
>> >
>> > explicit
>> > @@ -167,7 +165,7 @@ namespace lldb_private {
>> > {
>> > if (success_ptr)
>> > *success_ptr = true;
>> > - return m_data.uint8;
>> > + return m_scalar.UChar(fail_value);
>> > }
>> > if (success_ptr)
>> > *success_ptr = true;
>> > @@ -183,10 +181,8 @@ namespace lldb_private {
>> > uint64_t
>> > GetAsUInt64 (uint64_t fail_value = UINT64_MAX, 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
>> > + llvm::APInt
>> > + GetAsUInt128 (const llvm::APInt& fail_value, bool *success_ptr
>> = NULL) const;
>> >
>> > float
>> > GetAsFloat (float fail_value = 0.0f, bool *success_ptr =
>> NULL) const;
>> > @@ -219,95 +215,92 @@ namespace lldb_private {
>> > operator = (uint8_t uint)
>> > {
>> > m_type = eTypeUInt8;
>> > - m_data.uint8 = uint;
>> > + m_scalar = uint;
>> > }
>> >
>> > void
>> > operator = (uint16_t uint)
>> > {
>> > m_type = eTypeUInt16;
>> > - m_data.uint16 = uint;
>> > + m_scalar = uint;
>> > }
>> >
>> > void
>> > operator = (uint32_t uint)
>> > {
>> > m_type = eTypeUInt32;
>> > - m_data.uint32 = uint;
>> > + m_scalar = uint;
>> > }
>> >
>> > void
>> > operator = (uint64_t uint)
>> > {
>> > m_type = eTypeUInt64;
>> > - m_data.uint64 = uint;
>> > + m_scalar = uint;
>> > }
>> >
>> > -#if defined (ENABLE_128_BIT_SUPPORT)
>> > void
>> > - operator = (__uint128_t uint)
>> > + operator = (llvm::APInt uint)
>> > {
>> > m_type = eTypeUInt128;
>> > - m_data.uint128 = uint;
>> > + m_scalar = llvm::APInt(uint);
>> > }
>> > -#endif
>> > +
>> > void
>> > operator = (float f)
>> > {
>> > m_type = eTypeFloat;
>> > - m_data.ieee_float = f;
>> > + m_scalar = f;
>> > }
>> >
>> > void
>> > operator = (double f)
>> > {
>> > m_type = eTypeDouble;
>> > - m_data.ieee_double = f;
>> > + m_scalar = f;
>> > }
>> >
>> > void
>> > operator = (long double f)
>> > {
>> > m_type = eTypeLongDouble;
>> > - m_data.ieee_long_double = f;
>> > + m_scalar = f;
>> > }
>> >
>> > void
>> > SetUInt8 (uint8_t uint)
>> > {
>> > m_type = eTypeUInt8;
>> > - m_data.uint8 = uint;
>> > + m_scalar = uint;
>> > }
>> >
>> > void
>> > SetUInt16 (uint16_t uint)
>> > {
>> > m_type = eTypeUInt16;
>> > - m_data.uint16 = uint;
>> > + m_scalar = uint;
>> > }
>> >
>> > void
>> > SetUInt32 (uint32_t uint, Type t = eTypeUInt32)
>> > {
>> > m_type = t;
>> > - m_data.uint32 = uint;
>> > + m_scalar = uint;
>> > }
>> >
>> > void
>> > SetUInt64 (uint64_t uint, Type t = eTypeUInt64)
>> > {
>> > m_type = t;
>> > - m_data.uint64 = uint;
>> > + m_scalar = uint;
>> > }
>> >
>> > -#if defined (ENABLE_128_BIT_SUPPORT)
>> > void
>> > - SetUInt128 (__uint128_t uint)
>> > + SetUInt128 (llvm::APInt uint)
>> > {
>> > m_type = eTypeUInt128;
>> > - m_data.uint128 = uint;
>> > + m_scalar = llvm::APInt(uint);
>> > }
>> > -#endif
>> > bool
>> > SetUInt (uint64_t uint, uint32_t byte_size);
>> >
>> > @@ -315,21 +308,21 @@ namespace lldb_private {
>> > SetFloat (float f)
>> > {
>> > m_type = eTypeFloat;
>> > - m_data.ieee_float = f;
>> > + m_scalar = f;
>> > }
>> >
>> > void
>> > SetDouble (double f)
>> > {
>> > m_type = eTypeDouble;
>> > - m_data.ieee_double = f;
>> > + m_scalar = f;
>> > }
>> >
>> > void
>> > SetLongDouble (long double f)
>> > {
>> > m_type = eTypeLongDouble;
>> > - m_data.ieee_long_double = f;
>> > + m_scalar = f;
>> > }
>> >
>> > void
>> > @@ -367,7 +360,7 @@ namespace lldb_private {
>> > GetByteOrder () const
>> > {
>> > if (m_type == eTypeBytes)
>> > - return m_data.buffer.byte_order;
>> > + return buffer.byte_order;
>> > return lldb::endian::InlHostByteOrder();
>> > }
>> >
>> > @@ -386,25 +379,13 @@ namespace lldb_private {
>> > protected:
>> >
>> > RegisterValue::Type m_type;
>> > - union
>> > + Scalar m_scalar;
>> > + struct
>> > {
>> > - 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;
>> > + 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;
>> > };
>> >
>> > } // 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=245547&r1=245546&r2=245547&view=diff
>> >
>> ==============================================================================
>> > --- lldb/trunk/include/lldb/Core/Scalar.h (original)
>> > +++ lldb/trunk/include/lldb/Core/Scalar.h Thu Aug 20 04:12:46 2015
>> > @@ -11,6 +11,11 @@
>> > #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 {
>> >
>> > @@ -34,22 +39,60 @@ public:
>> > e_ulonglong,
>> > e_float,
>> > e_double,
>> > - e_long_double
>> > + e_long_double,
>> > + e_uint128,
>> > + e_sint128
>> > };
>> >
>> >
>> //------------------------------------------------------------------
>> > // Constructors and Destructors
>> >
>> //------------------------------------------------------------------
>> > Scalar();
>> > - 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(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:
>> > + case 16:
>> > + 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(const Scalar& rhs);
>> > //Scalar(const RegisterValue& reg_value);
>> > virtual ~Scalar();
>> > @@ -61,15 +104,18 @@ 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;
>> >
>> > @@ -83,7 +129,7 @@ public:
>> > IsZero() const;
>> >
>> > void
>> > - Clear() { m_type = e_void; m_data.ulonglong = 0; }
>> > + Clear() { m_type = e_void; m_integer.clearAllBits(); }
>> >
>> > const char *
>> > GetTypeAsCString() const;
>> > @@ -133,6 +179,7 @@ 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
>> > @@ -174,6 +221,9 @@ public:
>> > Scalar::Type
>> > GetType() const { return m_type; }
>> >
>> > + void
>> > + SetType(const RegisterInfo*);
>> > +
>> >
>> //----------------------------------------------------------------------
>> > // Returns a casted value of the current contained data without
>> > // modifying the current value. FAIL_VALUE will be returned if
>> the type
>> > @@ -194,6 +244,18 @@ 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;
>> >
>> > @@ -209,6 +271,12 @@ public:
>> > unsigned long long
>> > ULongLong(unsigned long long fail_value = 0) const;
>> >
>> > + llvm::APInt
>> > + SInt128(llvm::APInt& fail_value) const;
>> > +
>> > + llvm::APInt
>> > + UInt128(const llvm::APInt& fail_value) const;
>> > +
>> > float
>> > Float(float fail_value = 0.0f) const;
>> >
>> > @@ -255,6 +323,10 @@ 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;
>> > @@ -265,24 +337,13 @@ 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;
>> > - ValueData m_data;
>> > + llvm::APInt m_integer;
>> > + llvm::APFloat m_float;
>> > + bool m_ieee_quad = false;
>> >
>> > 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=245547&r1=245546&r2=245547&view=diff
>> >
>> ==============================================================================
>> > --- lldb/trunk/include/lldb/Core/Value.h (original)
>> > +++ lldb/trunk/include/lldb/Core/Value.h Thu Aug 20 04:12:46 2015
>> > @@ -101,6 +101,7 @@ 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
>> > {
>> > @@ -111,11 +112,7 @@ 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;
>> > -#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
>> > + else if (length >= 16) scalar = rhs;
>> > }
>> > 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=245547&r1=245546&r2=245547&view=diff
>> >
>> ==============================================================================
>> > --- lldb/trunk/include/lldb/lldb-private-types.h (original)
>> > +++ lldb/trunk/include/lldb/lldb-private-types.h Thu Aug 20 04:12:46
>> 2015
>> > @@ -102,6 +102,8 @@ 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=245547&r1=245546&r2=245547&view=diff
>> >
>> ==============================================================================
>> > --- lldb/trunk/source/Core/RegisterValue.cpp (original)
>> > +++ lldb/trunk/source/Core/RegisterValue.cpp Thu Aug 20 04:12:46 2015
>> > @@ -215,10 +215,10 @@ RegisterValue::SetFromMemoryData (const
>> > }
>> > else if (value_type == eTypeBytes)
>> > {
>> > - m_data.buffer.byte_order = src_byte_order;
>> > + buffer.byte_order = src_byte_order;
>> > // Make sure to set the buffer length of the destination
>> buffer to avoid
>> > - // problems due to uninitialized variables.
>> > - m_data.buffer.length = src_len;
>> > + // problems due to uninitalized variables.
>> > + buffer.length = src_len;
>> > }
>> >
>> > const uint32_t bytes_copied = src_data.CopyByteOrderedData (0,
>> // src offset
>> > @@ -240,25 +240,23 @@ RegisterValue::GetScalarValue (Scalar &s
>> > case eTypeInvalid: break;
>> > case eTypeBytes:
>> > {
>> > - switch (m_data.buffer.length)
>> > + switch (buffer.length)
>> > {
>> > default: break;
>> > - case 1: scalar = m_data.uint8; return true;
>> > - case 2: scalar = m_data.uint16; return true;
>> > - case 4: scalar = m_data.uint32; return true;
>> > - case 8: scalar = m_data.uint64; return true;
>> > + case 1: scalar = *(const uint8_t *)buffer.bytes;
>> return true;
>> > + case 2: scalar = *(const uint16_t *)buffer.bytes;
>> return true;
>> > + case 4: scalar = *(const uint32_t *)buffer.bytes;
>> return true;
>> > + case 8: scalar = *(const uint64_t *)buffer.bytes;
>> 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;
>> > + case eTypeUInt8:
>> > + case eTypeUInt16:
>> > + case eTypeUInt32:
>> > + case eTypeUInt64:
>> > + case eTypeUInt128:
>> > + case eTypeFloat:
>> > + case eTypeDouble:
>> > + case eTypeLongDouble: scalar = m_scalar; return true;
>> > }
>> > return false;
>> > }
>> > @@ -289,10 +287,8 @@ 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:
>> > @@ -308,6 +304,7 @@ RegisterValue::SetType (const RegisterIn
>> > m_type = eTypeBytes;
>> > break;
>> > }
>> > + m_scalar.SetType(reg_info);
>> > return m_type;
>> > }
>> >
>> > @@ -342,8 +339,9 @@ RegisterValue::SetValueFromData (const R
>> > src_len = reg_info->byte_size;
>> >
>> > // Zero out the value in case we get partial data...
>> > - memset (m_data.buffer.bytes, 0, sizeof (m_data.buffer.bytes));
>> > -
>> > + memset (buffer.bytes, 0, sizeof (buffer.bytes));
>> > +
>> > + type128 int128;
>> > switch (SetType (reg_info))
>> > {
>> > case eTypeInvalid:
>> > @@ -353,33 +351,38 @@ 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);
>> > + uint64_t data1 = src.GetU64 (&src_offset);
>> > + uint64_t data2 = src.GetU64 (&src_offset);
>> > if (src.GetByteSize() == eByteOrderBig)
>> > - SetUInt128 (data1 << 64 + data2);
>> > + {
>> > + int128.x[0] = data1;
>> > + int128.x[1] = data2;
>> > + }
>> > else
>> > - SetUInt128 (data2 << 64 + data1);
>> > + {
>> > + int128.x[0] = data2;
>> > + int128.x[1] = data1;
>> > + }
>> > + SetUInt128 (llvm::APInt(128, 2, int128.x));
>> > }
>> > break;
>> > -#endif
>> > case eTypeFloat: SetFloat (src.GetFloat
>> (&src_offset)); break;
>> > case eTypeDouble: SetDouble(src.GetDouble
>> (&src_offset)); break;
>> > case eTypeLongDouble: SetFloat (src.GetLongDouble
>> (&src_offset)); break;
>> > case eTypeBytes:
>> > {
>> > - m_data.buffer.length = reg_info->byte_size;
>> > - m_data.buffer.byte_order = src.GetByteOrder();
>> > - assert (m_data.buffer.length <= kMaxRegisterByteSize);
>> > - if (m_data.buffer.length > kMaxRegisterByteSize)
>> > - m_data.buffer.length = kMaxRegisterByteSize;
>> > + buffer.length = reg_info->byte_size;
>> > + buffer.byte_order = src.GetByteOrder();
>> > + assert (buffer.length <= kMaxRegisterByteSize);
>> > + if (buffer.length > kMaxRegisterByteSize)
>> > + buffer.length = kMaxRegisterByteSize;
>> > if (src.CopyByteOrderedData (src_offset,
>> // offset within "src" to start extracting data
>> > src_len,
>> // src length
>> > - m_data.buffer.bytes,
>> // dst buffer
>> > - m_data.buffer.length,
>> // dst length
>> > - m_data.buffer.byte_order) ==
>> 0)// dst byte order
>> > + buffer.bytes, //
>> dst buffer
>> > + buffer.length, //
>> dst length
>> > + buffer.byte_order) == 0)//
>> dst byte order
>> > {
>> > error.SetErrorString ("data copy failed data.");
>> > return error;
>> > @@ -459,6 +462,9 @@ 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:
>> > @@ -510,22 +516,31 @@ RegisterValue::SetValueFromCString (cons
>> > case eEncodingIEEE754:
>> > if (byte_size == sizeof (float))
>> > {
>> > - if (::sscanf (value_str, "%f", &m_data.ieee_float) ==
>> 1)
>> > + if (::sscanf (value_str, "%f", &flt_val) == 1)
>> > + {
>> > + m_scalar = flt_val;
>> > m_type = eTypeFloat;
>> > + }
>> > else
>> > error.SetErrorStringWithFormat ("'%s' is not a
>> valid float string value", value_str);
>> > }
>> > else if (byte_size == sizeof (double))
>> > {
>> > - if (::sscanf (value_str, "%lf", &m_data.ieee_double)
>> == 1)
>> > + if (::sscanf (value_str, "%lf", &dbl_val) == 1)
>> > + {
>> > + m_scalar = dbl_val;
>> > m_type = eTypeDouble;
>> > + }
>> > else
>> > error.SetErrorStringWithFormat ("'%s' is not a
>> valid float string value", value_str);
>> > }
>> > else if (byte_size == sizeof (long double))
>> > {
>> > - if (::sscanf (value_str, "%Lf",
>> &m_data.ieee_long_double) == 1)
>> > + if (::sscanf (value_str, "%Lf", &ldbl_val) == 1)
>> > + {
>> > + m_scalar = ldbl_val;
>> > m_type = eTypeLongDouble;
>> > + }
>> > else
>> > error.SetErrorStringWithFormat ("'%s' is not a
>> valid float string value", value_str);
>> > }
>> > @@ -557,81 +572,11 @@ 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:
>> > - 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
>> > + return m_scalar.SignExtend(sign_bitpos);
>> > case eTypeFloat:
>> > case eTypeDouble:
>> > case eTypeLongDouble:
>> > @@ -649,21 +594,19 @@ RegisterValue::CopyValue (const Register
>> > {
>> > case eTypeInvalid:
>> > return false;
>> > - case eTypeUInt8: m_data.uint8 = rhs.m_data.uint8; break;
>> > - case eTypeUInt16: m_data.uint16 = rhs.m_data.uint16;
>> break;
>> > - case eTypeUInt32: m_data.uint32 = rhs.m_data.uint32;
>> break;
>> > - case eTypeUInt64: m_data.uint64 = rhs.m_data.uint64;
>> break;
>> > -#if defined (ENABLE_128_BIT_SUPPORT)
>> > - case eTypeUInt128: m_data.uint128 = rhs.m_data.uint128;
>> break;
>> > -#endif
>> > - case eTypeFloat: m_data.ieee_float =
>> rhs.m_data.ieee_float; break;
>> > - case eTypeDouble: m_data.ieee_double =
>> rhs.m_data.ieee_double; break;
>> > - case eTypeLongDouble: m_data.ieee_long_double =
>> rhs.m_data.ieee_long_double; break;
>> > + case eTypeUInt8:
>> > + case eTypeUInt16:
>> > + case eTypeUInt32:
>> > + case eTypeUInt64:
>> > + case eTypeUInt128:
>> > + case eTypeFloat:
>> > + case eTypeDouble:
>> > + case eTypeLongDouble: m_scalar = rhs.m_scalar; break;
>> > case eTypeBytes:
>> > - assert (rhs.m_data.buffer.length <= kMaxRegisterByteSize);
>> > - ::memcpy (m_data.buffer.bytes, rhs.m_data.buffer.bytes,
>> kMaxRegisterByteSize);
>> > - m_data.buffer.length = rhs.m_data.buffer.length;
>> > - m_data.buffer.byte_order = rhs.m_data.buffer.byte_order;
>> > + assert (rhs.buffer.length <= kMaxRegisterByteSize);
>> > + ::memcpy (buffer.bytes, rhs.buffer.bytes,
>> kMaxRegisterByteSize);
>> > + buffer.length = rhs.buffer.length;
>> > + buffer.byte_order = rhs.buffer.byte_order;
>> > break;
>> > }
>> > return true;
>> > @@ -678,15 +621,15 @@ RegisterValue::GetAsUInt16 (uint16_t fai
>> > switch (m_type)
>> > {
>> > default: break;
>> > - case eTypeUInt8: return m_data.uint8;
>> > - case eTypeUInt16: return m_data.uint16;
>> > + case eTypeUInt8:
>> > + case eTypeUInt16: return m_scalar.UShort(fail_value);
>> > case eTypeBytes:
>> > {
>> > - switch (m_data.buffer.length)
>> > + switch (buffer.length)
>> > {
>> > default: break;
>> > - case 1: return m_data.uint8;
>> > - case 2: return m_data.uint16;
>> > + case 1:
>> > + case 2: return *(const uint16_t *)buffer.bytes;
>> > }
>> > }
>> > break;
>> > @@ -704,29 +647,20 @@ RegisterValue::GetAsUInt32 (uint32_t fai
>> > switch (m_type)
>> > {
>> > default: break;
>> > - case eTypeUInt8: return m_data.uint8;
>> > - case eTypeUInt16: return m_data.uint16;
>> > - case eTypeUInt32: return m_data.uint32;
>> > + case eTypeUInt8:
>> > + case eTypeUInt16:
>> > + case eTypeUInt32:
>> > case eTypeFloat:
>> > - if (sizeof(float) == sizeof(uint32_t))
>> > - return m_data.uint32;
>> > - break;
>> > case eTypeDouble:
>> > - if (sizeof(double) == sizeof(uint32_t))
>> > - return m_data.uint32;
>> > - break;
>> > - case eTypeLongDouble:
>> > - if (sizeof(long double) == sizeof(uint32_t))
>> > - return m_data.uint32;
>> > - break;
>> > + case eTypeLongDouble: return m_scalar.UInt(fail_value);
>> > case eTypeBytes:
>> > {
>> > - switch (m_data.buffer.length)
>> > + switch (buffer.length)
>> > {
>> > default: break;
>> > - case 1: return m_data.uint8;
>> > - case 2: return m_data.uint16;
>> > - case 4: return m_data.uint32;
>> > + case 1:
>> > + case 2:
>> > + case 4: return *(const uint32_t *)buffer.bytes;
>> > }
>> > }
>> > break;
>> > @@ -744,31 +678,22 @@ RegisterValue::GetAsUInt64 (uint64_t fai
>> > switch (m_type)
>> > {
>> > default: break;
>> > - case eTypeUInt8: return m_data.uint8;
>> > - case eTypeUInt16: return m_data.uint16;
>> > - case eTypeUInt32: return m_data.uint32;
>> > - case eTypeUInt64: return m_data.uint64;
>> > + case eTypeUInt8:
>> > + case eTypeUInt16:
>> > + case eTypeUInt32:
>> > + case eTypeUInt64:
>> > case eTypeFloat:
>> > - if (sizeof(float) == sizeof(uint64_t))
>> > - return m_data.uint64;
>> > - break;
>> > case eTypeDouble:
>> > - if (sizeof(double) == sizeof(uint64_t))
>> > - return m_data.uint64;
>> > - break;
>> > - case eTypeLongDouble:
>> > - if (sizeof(long double) == sizeof(uint64_t))
>> > - return m_data.uint64;
>> > - break;
>> > + case eTypeLongDouble: return m_scalar.ULongLong(fail_value);
>> > case eTypeBytes:
>> > {
>> > - switch (m_data.buffer.length)
>> > + switch (buffer.length)
>> > {
>> > default: break;
>> > - case 1: return m_data.uint8;
>> > - case 2: return m_data.uint16;
>> > - case 4: return m_data.uint32;
>> > - case 8: return m_data.uint64;
>> > + case 1:
>> > + case 2:
>> > + case 4:
>> > + case 8: return *(const uint64_t *)buffer.bytes;
>> > }
>> > }
>> > break;
>> > @@ -778,43 +703,36 @@ RegisterValue::GetAsUInt64 (uint64_t fai
>> > return fail_value;
>> > }
>> >
>> > -#if defined (ENABLE_128_BIT_SUPPORT)
>> > -__uint128_t
>> > -RegisterValue::GetAsUInt128 (__uint128_t fail_value, bool
>> *success_ptr) const
>> > +llvm::APInt
>> > +RegisterValue::GetAsUInt128 (const llvm::APInt& fail_value, bool
>> *success_ptr) const
>> > {
>> > if (success_ptr)
>> > *success_ptr = true;
>> > switch (m_type)
>> > {
>> > default: break;
>> > - case eTypeUInt8: return m_data.uint8;
>> > - case eTypeUInt16: return m_data.uint16;
>> > - case eTypeUInt32: return m_data.uint32;
>> > - case eTypeUInt64: return m_data.uint64;
>> > - case eTypeUInt128: return m_data.uint128;
>> > + case eTypeUInt8:
>> > + case eTypeUInt16:
>> > + case eTypeUInt32:
>> > + case eTypeUInt64:
>> > + case eTypeUInt128:
>> > case eTypeFloat:
>> > - if (sizeof(float) == sizeof(__uint128_t))
>> > - return m_data.uint128;
>> > - break;
>> > case eTypeDouble:
>> > - if (sizeof(double) == sizeof(__uint128_t))
>> > - return m_data.uint128;
>> > - break;
>> > - case eTypeLongDouble:
>> > - if (sizeof(long double) == sizeof(__uint128_t))
>> > - return m_data.uint128;
>> > - break;
>> > + case eTypeLongDouble: return m_scalar.UInt128(fail_value);
>> > case eTypeBytes:
>> > {
>> > - switch (m_data.buffer.length)
>> > + switch (buffer.length)
>> > {
>> > - default:
>> > - break;
>> > - case 1: return m_data.uint8;
>> > - case 2: return m_data.uint16;
>> > - case 4: return m_data.uint32;
>> > - case 8: return m_data.uint64;
>> > - case 16: return m_data.uint128;
>> > + default:
>> > + break;
>> > + case 1:
>> > + case 2:
>> > + case 4:
>> > + case 8:
>> > + case 16:
>> > + {
>> > + return llvm::APInt(BITWIDTH_INT128,
>> NUM_OF_WORDS_INT128, ((const type128 *)buffer.bytes)->x);
>> > + }
>> > }
>> > }
>> > break;
>> > @@ -823,7 +741,7 @@ RegisterValue::GetAsUInt128 (__uint128_t
>> > *success_ptr = false;
>> > return fail_value;
>> > }
>> > -#endif
>> > +
>> > float
>> > RegisterValue::GetAsFloat (float fail_value, bool *success_ptr) const
>> > {
>> > @@ -833,28 +751,12 @@ 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:
>> > - if (sizeof(float) == sizeof(m_data.uint128))
>> > - return m_data.ieee_float;
>> > - break;
>> > -#endif
>> > - case eTypeFloat: return m_data.ieee_float;
>> > + case eTypeFloat:
>> > case eTypeDouble:
>> > - if (sizeof(float) == sizeof(double))
>> > - return m_data.ieee_float;
>> > - break;
>> > case eTypeLongDouble:
>> > - if (sizeof(float) == sizeof(long double))
>> > - return m_data.ieee_float;
>> > - break;
>> > + return m_scalar.Float(fail_value);
>> > }
>> > if (success_ptr)
>> > *success_ptr = false;
>> > @@ -872,27 +774,12 @@ 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:
>> > - 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 eTypeFloat:
>> > + case eTypeDouble:
>> > case eTypeLongDouble:
>> > - if (sizeof(double) == sizeof(long double))
>> > - return m_data.ieee_double;
>> > - break;
>> > + return m_scalar.Double(fail_value);
>> > }
>> > if (success_ptr)
>> > *success_ptr = false;
>> > @@ -910,24 +797,12 @@ 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:
>> > - 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;
>> > + case eTypeFloat:
>> > + case eTypeDouble:
>> > + case eTypeLongDouble:
>> > + return m_scalar.LongDouble();
>> > }
>> > if (success_ptr)
>> > *success_ptr = false;
>> > @@ -940,17 +815,15 @@ RegisterValue::GetBytes () const
>> > switch (m_type)
>> > {
>> > case eTypeInvalid: break;
>> > - case eTypeUInt8: return &m_data.uint8;
>> > - case eTypeUInt16: return &m_data.uint16;
>> > - case eTypeUInt32: return &m_data.uint32;
>> > - case eTypeUInt64: return &m_data.uint64;
>> > -#if defined (ENABLE_128_BIT_SUPPORT)
>> > - case eTypeUInt128: return &m_data.uint128;
>> > -#endif
>> > - case eTypeFloat: return &m_data.ieee_float;
>> > - case eTypeDouble: return &m_data.ieee_double;
>> > - case eTypeLongDouble: return &m_data.ieee_long_double;
>> > - case eTypeBytes: return m_data.buffer.bytes;
>> > + 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;
>> > }
>> > return NULL;
>> > }
>> > @@ -961,17 +834,15 @@ RegisterValue::GetBytes ()
>> > switch (m_type)
>> > {
>> > case eTypeInvalid: break;
>> > - case eTypeUInt8: return &m_data.uint8;
>> > - case eTypeUInt16: return &m_data.uint16;
>> > - case eTypeUInt32: return &m_data.uint32;
>> > - case eTypeUInt64: return &m_data.uint64;
>> > -#if defined (ENABLE_128_BIT_SUPPORT)
>> > - case eTypeUInt128: return &m_data.uint128;
>> > -#endif
>> > - case eTypeFloat: return &m_data.ieee_float;
>> > - case eTypeDouble: return &m_data.ieee_double;
>> > - case eTypeLongDouble: return &m_data.ieee_long_double;
>> > - case eTypeBytes: return m_data.buffer.bytes;
>> > + 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;
>> > }
>> > return NULL;
>> > }
>> > @@ -982,17 +853,15 @@ RegisterValue::GetByteSize () const
>> > switch (m_type)
>> > {
>> > case eTypeInvalid: break;
>> > - case eTypeUInt8: return sizeof(m_data.uint8);
>> > - case eTypeUInt16: return sizeof(m_data.uint16);
>> > - case eTypeUInt32: return sizeof(m_data.uint32);
>> > - case eTypeUInt64: return sizeof(m_data.uint64);
>> > -#if defined (ENABLE_128_BIT_SUPPORT)
>> > - case eTypeUInt128: return sizeof(m_data.uint128);
>> > -#endif
>> > - case eTypeFloat: return sizeof(m_data.ieee_float);
>> > - case eTypeDouble: return sizeof(m_data.ieee_double);
>> > - case eTypeLongDouble: return sizeof(m_data.ieee_long_double);
>> > - case eTypeBytes: return m_data.buffer.length;
>> > + case eTypeUInt8: return 1;
>> > + case eTypeUInt16: return 2;
>> > + case eTypeUInt32:
>> > + case eTypeUInt64:
>> > + case eTypeUInt128:
>> > + case eTypeFloat:
>> > + case eTypeDouble:
>> > + case eTypeLongDouble: return m_scalar.GetByteSize();
>> > + case eTypeBytes: return buffer.length;
>> > }
>> > return 0;
>> > }
>> > @@ -1021,12 +890,10 @@ RegisterValue::SetUInt (uint64_t uint, u
>> > {
>> > SetUInt64 (uint);
>> > }
>> > -#if defined (ENABLE_128_BIT_SUPPORT)
>> > else if (byte_size <= 16)
>> > {
>> > - SetUInt128 (uint);
>> > + SetUInt128 (llvm::APInt(64, uint));
>> > }
>> > -#endif
>> > else
>> > return false;
>> > return true;
>> > @@ -1036,21 +903,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
>> > - // m_data.buffer.bytes, or make it something that is allocated on
>> > + // buffer.bytes, or make it something that is allocated on
>> > // the heap. Since the data buffer is in a union, we can't make it
>> > // a collection class like SmallVector...
>> > if (bytes && length > 0)
>> > {
>> > - assert (length <= sizeof (m_data.buffer.bytes) && "Storing too
>> many bytes in a RegisterValue.");
>> > + assert (length <= sizeof (buffer.bytes) && "Storing too many
>> bytes in a RegisterValue.");
>> > m_type = eTypeBytes;
>> > - m_data.buffer.length = length;
>> > - memcpy (m_data.buffer.bytes, bytes, length);
>> > - m_data.buffer.byte_order = byte_order;
>> > + buffer.length = length;
>> > + memcpy (buffer.bytes, bytes, length);
>> > + buffer.byte_order = byte_order;
>> > }
>> > else
>> > {
>> > m_type = eTypeInvalid;
>> > - m_data.buffer.length = 0;
>> > + buffer.length = 0;
>> > }
>> > }
>> >
>> > @@ -1063,25 +930,23 @@ RegisterValue::operator == (const Regist
>> > switch (m_type)
>> > {
>> > case eTypeInvalid: return true;
>> > - case eTypeUInt8: return m_data.uint8 ==
>> rhs.m_data.uint8;
>> > - case eTypeUInt16: return m_data.uint16 ==
>> rhs.m_data.uint16;
>> > - case eTypeUInt32: return m_data.uint32 ==
>> rhs.m_data.uint32;
>> > - case eTypeUInt64: return m_data.uint64 ==
>> rhs.m_data.uint64;
>> > -#if defined (ENABLE_128_BIT_SUPPORT)
>> > - case eTypeUInt128: return m_data.uint128 ==
>> rhs.m_data.uint128;
>> > -#endif
>> > - case eTypeFloat: return m_data.ieee_float ==
>> rhs.m_data.ieee_float;
>> > - case eTypeDouble: return m_data.ieee_double ==
>> rhs.m_data.ieee_double;
>> > - case eTypeLongDouble: return m_data.ieee_long_double ==
>> rhs.m_data.ieee_long_double;
>> > + case eTypeUInt8:
>> > + case eTypeUInt16:
>> > + case eTypeUInt32:
>> > + case eTypeUInt64:
>> > + case eTypeUInt128:
>> > + case eTypeFloat:
>> > + case eTypeDouble:
>> > + case eTypeLongDouble: return m_scalar == rhs.m_scalar;
>> > case eTypeBytes:
>> > - if (m_data.buffer.length != rhs.m_data.buffer.length)
>> > + if (buffer.length != rhs.buffer.length)
>> > return false;
>> > else
>> > {
>> > - uint8_t length = m_data.buffer.length;
>> > + uint8_t length = buffer.length;
>> > if (length > kMaxRegisterByteSize)
>> > length = kMaxRegisterByteSize;
>> > - return memcmp (m_data.buffer.bytes,
>> rhs.m_data.buffer.bytes, length) == 0;
>> > + return memcmp (buffer.bytes, rhs.buffer.bytes,
>> length) == 0;
>> > }
>> > break;
>> > }
>> > @@ -1097,27 +962,25 @@ RegisterValue::operator != (const Regist
>> > switch (m_type)
>> > {
>> > case eTypeInvalid: return false;
>> > - case eTypeUInt8: return m_data.uint8 !=
>> rhs.m_data.uint8;
>> > - case eTypeUInt16: return m_data.uint16 !=
>> rhs.m_data.uint16;
>> > - case eTypeUInt32: return m_data.uint32 !=
>> rhs.m_data.uint32;
>> > - case eTypeUInt64: return m_data.uint64 !=
>> rhs.m_data.uint64;
>> > -#if defined (ENABLE_128_BIT_SUPPORT)
>> > - case eTypeUInt128: return m_data.uint128 !=
>> rhs.m_data.uint128;
>> > -#endif
>> > - case eTypeFloat: return m_data.ieee_float !=
>> rhs.m_data.ieee_float;
>> > - case eTypeDouble: return m_data.ieee_double !=
>> rhs.m_data.ieee_double;
>> > - case eTypeLongDouble: return m_data.ieee_long_double !=
>> rhs.m_data.ieee_long_double;
>> > + case eTypeUInt8:
>> > + case eTypeUInt16:
>> > + case eTypeUInt32:
>> > + case eTypeUInt64:
>> > + case eTypeUInt128:
>> > + case eTypeFloat:
>> > + case eTypeDouble:
>> > + case eTypeLongDouble: return m_scalar != rhs.m_scalar;
>> > case eTypeBytes:
>> > - if (m_data.buffer.length != rhs.m_data.buffer.length)
>> > + if (buffer.length != rhs.buffer.length)
>> > {
>> > return true;
>> > }
>> > else
>> > {
>> > - uint8_t length = m_data.buffer.length;
>> > + uint8_t length = buffer.length;
>> > if (length > kMaxRegisterByteSize)
>> > length = kMaxRegisterByteSize;
>> > - return memcmp (m_data.buffer.bytes,
>> rhs.m_data.buffer.bytes, length) != 0;
>> > + return memcmp (buffer.bytes, rhs.buffer.bytes, length)
>> != 0;
>> > }
>> > break;
>> > }
>> > @@ -1132,63 +995,35 @@ RegisterValue::ClearBit (uint32_t bit)
>> > case eTypeInvalid:
>> > break;
>> >
>> > - case eTypeUInt8:
>> > - if (bit < 8)
>> > - {
>>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/lldb-commits/attachments/20150821/def2de8e/attachment-0001.html>
More information about the lldb-commits
mailing list