Revert r266311 - Fix usage of APInt.getRawData for big-endian systems

Try to get 32-bit build bots running again.

llvm-svn: 266341

diff --git a/lldb/include/lldb/Core/Scalar.h b/lldb/include/lldb/Core/Scalar.h
index be2176e..db103ff 100644 (file)
--- a/lldb/include/lldb/Core/Scalar.h
+++ b/lldb/include/lldb/Core/Scalar.h
@@ -162,9 +162,6 @@ public:
     bool
     MakeSigned ();
 
-    bool
-    MakeUnsigned ();
-
     static const char *
     GetValueTypeAsCString (Scalar::Type value_type);
 
@@ -242,10 +239,22 @@ public:
     int
     SInt(int fail_value = 0) const;
 
+    // Return the raw unsigned integer without any casting or conversion
+    unsigned int
+    RawUInt () const;
+
+    // Return the raw unsigned long without any casting or conversion
+    unsigned long
+    RawULong () const;
+
+    // Return the raw unsigned long long without any casting or conversion
+    unsigned long long
+    RawULongLong () const;
+
     unsigned char
     UChar(unsigned char fail_value = 0) const;
 
-    signed char
+    char
     SChar(char fail_value = 0) const;
 
     unsigned short
@@ -290,6 +299,9 @@ public:
     long double
     LongDouble(long double fail_value = 0.0) const;
 
+    uint64_t
+    GetRawBits64 (uint64_t fail_value) const;
+
     Error
     SetValueFromCString (const char *s, lldb::Encoding encoding, size_t byte_size);
     

diff --git a/lldb/include/lldb/Symbol/Type.h b/lldb/include/lldb/Symbol/Type.h
index 9158f28..5524cea 100644 (file)
--- a/lldb/include/lldb/Symbol/Type.h
+++ b/lldb/include/lldb/Symbol/Type.h
@@ -958,13 +958,13 @@ public:
     uint64_t
     GetValueAsUnsigned () const
     {
-        return m_value.getZExtValue();
+        return *m_value.getRawData();
     }
 
     int64_t
     GetValueAsSigned () const
     {
-        return m_value.getSExtValue();
+        return (int64_t) *m_value.getRawData();
     }
 
 protected:

diff --git a/lldb/source/Core/Scalar.cpp b/lldb/source/Core/Scalar.cpp
index 919b70b..85c37bc 100644 (file)
--- a/lldb/source/Core/Scalar.cpp
+++ b/lldb/source/Core/Scalar.cpp
@@ -16,8 +16,6 @@
 #include <cstdio>
 
 // Other libraries and framework includes
-#include "llvm/ADT/SmallString.h"
-
 // Project includes
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Core/Error.h"
@@ -136,10 +134,10 @@ bool
 Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const
 {
     size_t byte_size = GetByteSize();
+    static float f_val;
+    static double d_val;
     if (byte_size > 0)
     {
-        const uint8_t *bytes = reinterpret_cast<const uint8_t *>(GetBytes());
-
         if (limit_byte_size < byte_size)
         {
             if (endian::InlHostByteOrder() == eByteOrderLittle)
@@ -147,19 +145,105 @@ Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const
                 // On little endian systems if we want fewer bytes from the
                 // current type we just specify fewer bytes since the LSByte
                 // is first...
-                byte_size = limit_byte_size;
+                switch(m_type)
+                {
+                case e_void:
+                    break;
+                case e_sint:
+                case e_uint:
+                case e_slong:
+                case e_ulong:
+                case e_slonglong:
+                case e_ulonglong:
+                case e_sint128:
+                case e_uint128:
+                case e_sint256:
+                case e_uint256:
+                    data.SetData((const uint8_t *)m_integer.getRawData(), limit_byte_size, endian::InlHostByteOrder());
+                    return true;
+                case e_float:
+                    f_val = m_float.convertToFloat();
+                    data.SetData((uint8_t *)&f_val, limit_byte_size, endian::InlHostByteOrder());
+                    return true;
+                case e_double:
+                    d_val = m_float.convertToDouble();
+                    data.SetData((uint8_t *)&d_val, limit_byte_size, endian::InlHostByteOrder());
+                    return true;
+                case e_long_double:
+                    static llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+                    data.SetData((const uint8_t *)ldbl_val.getRawData(), limit_byte_size, endian::InlHostByteOrder());
+                    return true;
+                }
             }
             else if (endian::InlHostByteOrder() == eByteOrderBig)
             {
                 // On big endian systems if we want fewer bytes from the
                 // current type have to advance our initial byte pointer and
                 // trim down the number of bytes since the MSByte is first
-                bytes += byte_size - limit_byte_size;
-                byte_size = limit_byte_size;
+                switch(m_type)
+                {
+                case e_void:
+                    break;
+                case e_sint:
+                case e_uint:
+                case e_slong:
+                case e_ulong:
+                case e_slonglong:
+                case e_ulonglong:
+                case e_sint128:
+                case e_uint128:
+                case e_sint256:
+                case e_uint256:
+                    data.SetData((const uint8_t *)m_integer.getRawData() + byte_size - limit_byte_size, limit_byte_size, endian::InlHostByteOrder());
+                    return true;
+                case e_float:
+                    f_val = m_float.convertToFloat();
+                    data.SetData((uint8_t *)&f_val + byte_size - limit_byte_size, limit_byte_size, endian::InlHostByteOrder());
+                    return true;
+                case e_double:
+                    d_val = m_float.convertToDouble();
+                    data.SetData((uint8_t *)&d_val + byte_size - limit_byte_size, limit_byte_size, endian::InlHostByteOrder());
+                    return true;
+                case e_long_double:
+                    static llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+                    data.SetData((const uint8_t *)ldbl_val.getRawData() + byte_size - limit_byte_size, limit_byte_size, endian::InlHostByteOrder());
+                    return true;
+                }
+            }
+        }
+        else
+        {
+            // We want all of the data
+            switch(m_type)
+            {
+            case e_void:
+                break;
+            case e_sint:
+            case e_uint:
+            case e_slong:
+            case e_ulong:
+            case e_slonglong:
+            case e_ulonglong:
+            case e_sint128:
+            case e_uint128:
+            case e_sint256:
+            case e_uint256:
+                data.SetData((const uint8_t *)m_integer.getRawData(), byte_size, endian::InlHostByteOrder());
+                return true;
+            case e_float:
+                f_val = m_float.convertToFloat();
+                data.SetData((uint8_t *)&f_val, byte_size, endian::InlHostByteOrder());
+                return true;
+            case e_double:
+                d_val = m_float.convertToDouble();
+                data.SetData((uint8_t *)&d_val, byte_size, endian::InlHostByteOrder());
+                return true;
+            case e_long_double:
+                static llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+                data.SetData((const uint8_t *)ldbl_val.getRawData(), byte_size, endian::InlHostByteOrder());
+                return true;
             }
         }
-
-        data.SetData(bytes, byte_size, endian::InlHostByteOrder());
         return true;
     }
     data.Clear();
@@ -169,11 +253,8 @@ Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const
 const void *
 Scalar::GetBytes() const
 {
-    const uint64_t *apint_words;
-    const uint8_t *bytes;
     static float_t flt_val;
     static double_t dbl_val;
-    static uint64_t swapped_words[4];
     switch (m_type)
     {
     case e_void:
@@ -184,44 +265,11 @@ Scalar::GetBytes() const
     case e_ulong:
     case e_slonglong:
     case e_ulonglong:
-        bytes = reinterpret_cast<const uint8_t *>(m_integer.getRawData());
-        // getRawData always returns a pointer to an uint64_t.  If we have a smaller type,
-        // we need to update the pointer on big-endian systems.
-        if (endian::InlHostByteOrder() == eByteOrderBig)
-        {
-            size_t byte_size = m_integer.getBitWidth() / 8;
-            if (byte_size < 8)
-                bytes += 8 - byte_size;
-        }
-        return bytes;
     case e_sint128:
     case e_uint128:
-        apint_words = m_integer.getRawData();
-        // getRawData always returns a pointer to an array of two uint64_t values,
-        // where the least-significant word always comes first.  On big-endian
-        // systems we need to swap the two words.
-        if (endian::InlHostByteOrder() == eByteOrderBig)
-        {
-            swapped_words[0] = apint_words[1];
-            swapped_words[1] = apint_words[0];
-            apint_words = swapped_words;
-        }
-        return reinterpret_cast<const void *>(apint_words);
     case e_sint256:
     case e_uint256:
-        apint_words = m_integer.getRawData();
-        // getRawData always returns a pointer to an array of four uint64_t values,
-        // where the least-significant word always comes first.  On big-endian
-        // systems we need to swap the four words.
-        if (endian::InlHostByteOrder() == eByteOrderBig)
-        {
-            swapped_words[0] = apint_words[3];
-            swapped_words[1] = apint_words[2];
-            swapped_words[2] = apint_words[1];
-            swapped_words[3] = apint_words[0];
-            apint_words = swapped_words;
-        }
-        return reinterpret_cast<const void *>(apint_words);
+        return reinterpret_cast<const void *>(m_integer.getRawData());
     case e_float:
         flt_val = m_float.convertToFloat();
         return reinterpret_cast<const void *>(&flt_val);
@@ -230,17 +278,7 @@ Scalar::GetBytes() const
         return reinterpret_cast<const void *>(&dbl_val);
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        apint_words = ldbl_val.getRawData();
-        // getRawData always returns a pointer to an array of two uint64_t values,
-        // where the least-significant word always comes first.  On big-endian
-        // systems we need to swap the two words.
-        if (endian::InlHostByteOrder() == eByteOrderBig)
-        {
-            swapped_words[0] = apint_words[1];
-            swapped_words[1] = apint_words[0];
-            apint_words = swapped_words;
-        }
-        return reinterpret_cast<const void *>(apint_words);
+        return reinterpret_cast<const void *>(ldbl_val.getRawData());
     }
     return nullptr;
 }
@@ -300,6 +338,7 @@ Scalar::IsZero() const
 void
 Scalar::GetValue (Stream *s, bool show_type) const
 {
+    const uint64_t *src;
     if (show_type)
         s->Printf("(%s) ", GetTypeAsCString());
 
@@ -307,26 +346,28 @@ Scalar::GetValue (Stream *s, bool show_type) const
     {
     case e_void:
         break;
-    case e_sint:
-    case e_ulong:
-    case e_slonglong:
+    case e_sint:        s->Printf("%i", *(const sint_t *) m_integer.getRawData());                        break;
+    case e_uint:        s->Printf("0x%8.8x", *(const uint_t *) m_integer.getRawData());           break;
+    case e_slong:       s->Printf("%li", *(const slong_t *) m_integer.getRawData());                       break;
+    case e_ulong:       s->Printf("0x%8.8lx", *(const ulong_t *) m_integer.getRawData());         break;
+    case e_slonglong:   s->Printf("%lli", *(const slonglong_t *) m_integer.getRawData());                  break;
+    case e_ulonglong:   s->Printf("0x%16.16llx", *(const ulonglong_t *) m_integer.getRawData()); break;
     case e_sint128:
     case e_sint256:
         s->Printf("%s",m_integer.toString(10,true).c_str());
         break;
-    case e_uint:
-    case e_slong:
-    case e_ulonglong:
     case e_uint128:
+        src = m_integer.getRawData();
+        s->Printf("0x%16.16llx%16.16llx", *(const ulonglong_t *)src, *(const ulonglong_t *)(src + 1));
+        break;
     case e_uint256:
         s->Printf("%s",m_integer.toString(16,false).c_str());
         break;
-    case e_float:
-    case e_double:
+    case e_float:       s->Printf("%f", m_float.convertToFloat());                break;
+    case e_double:      s->Printf("%g", m_float.convertToDouble());                break;
     case e_long_double:
-        llvm::SmallString<24> string;
-        m_float.toString(string);
-        s->Printf("%s", string.c_str());
+        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+        s->Printf("%Lg", *(const long_double_t *)ldbl_val.getRawData());
         break;
     }
 }
@@ -494,47 +535,39 @@ Scalar::Promote(Scalar::Type type)
             case e_void: break;
             case e_sint: success = true; break;
             case e_uint:
-                m_integer = m_integer.zextOrTrunc(sizeof(uint_t) * 8);
+                m_integer = llvm::APInt(sizeof(uint_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
                 success = true;
                 break;
 
             case e_slong:
-                m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
+                m_integer = llvm::APInt(sizeof(slong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
                 success = true;
                 break;
 
             case e_ulong:
-                m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8);
+                m_integer = llvm::APInt(sizeof(ulong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
                 success = true;
                 break;
 
             case e_slonglong:
-                m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
+                m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
                 success = true;
                 break;
 
             case e_ulonglong:
-                m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
+                m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
                 success = true;
                 break;
 
             case e_sint128:
-                m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
-                success = true;
-                break;
-
             case e_uint128:
-                m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
+                m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
                 success = true;
                 break;
 
             case e_sint256:
-                m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
-                success = true;
-                break;
-
             case e_uint256:
-                m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
+                m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData()));
                 success = true;
                 break;
 
@@ -565,42 +598,34 @@ Scalar::Promote(Scalar::Type type)
              case e_sint:     break;
              case e_uint:     success = true; break;
              case e_slong:
-                 m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
+                 m_integer = llvm::APInt(sizeof(slong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
                  success = true;
                  break;
 
              case e_ulong:
-                 m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8);
+                 m_integer = llvm::APInt(sizeof(ulong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
                  success = true;
                  break;
 
              case e_slonglong:
-                 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
+                 m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
                  success = true;
                  break;
 
              case e_ulonglong:
-                 m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
+                 m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
                  success = true;
                  break;
 
              case e_sint128:
-                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
-                 success = true;
-                 break;
-
              case e_uint128:
-                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
+                 m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
                  success = true;
                  break;
 
             case e_sint256:
-                m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
-                success = true;
-                break;
-
             case e_uint256:
-                m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
+                m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData()));
                 success = true;
                 break;
 
@@ -632,37 +657,29 @@ Scalar::Promote(Scalar::Type type)
              case e_uint:    break;
              case e_slong:   success = true; break;
              case e_ulong:
-                 m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8);
+                 m_integer = llvm::APInt(sizeof(ulong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
                  success = true;
                  break;
 
              case e_slonglong:
-                 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
+                 m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
                  success = true;
                  break;
 
              case e_ulonglong:
-                 m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
+                 m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
                  success = true;
                  break;
 
              case e_sint128:
-                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
-                 success = true;
-                 break;
-
              case e_uint128:
-                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
+                 m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
                  success = true;
                  break;
 
              case e_sint256:
-                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
-                 success = true;
-                 break;
-
              case e_uint256:
-                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
+                 m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData()));
                  success = true;
                  break;
 
@@ -695,32 +712,24 @@ Scalar::Promote(Scalar::Type type)
              case e_slong:    break;
              case e_ulong:    success = true; break;
              case e_slonglong:
-                 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
+                 m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
                  success = true;
                  break;
 
              case e_ulonglong:
-                 m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
+                 m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
                  success = true;
                  break;
 
              case e_sint128:
-                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
-                 success = true;
-                 break;
-
              case e_uint128:
-                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
+                 m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
                  success = true;
                  break;
 
              case e_sint256:
-                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
-                 success = true;
-                 break;
-
              case e_uint256:
-                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
+                 m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData()));
                  success = true;
                  break;
 
@@ -754,27 +763,19 @@ Scalar::Promote(Scalar::Type type)
              case e_ulong:        break;
              case e_slonglong:    success = true; break;
              case e_ulonglong:
-                 m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
+                 m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
                  success = true;
                  break;
 
              case e_sint128:
-                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
-                 success = true;
-                 break;
-
              case e_uint128:
-                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
+                 m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
                  success = true;
                  break;
 
              case e_sint256:
-                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
-                 success = true;
-                 break;
-
              case e_uint256:
-                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
+                 m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData()));
                  success = true;
                  break;
 
@@ -809,22 +810,14 @@ Scalar::Promote(Scalar::Type type)
              case e_slonglong:    break;
              case e_ulonglong:    success = true; break;
              case e_sint128:
-                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
-                 success = true;
-                 break;
-
              case e_uint128:
-                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
+                 m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
                  success = true;
                  break;
 
              case e_sint256:
-                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
-                 success = true;
-                 break;
-
              case e_uint256:
-                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
+                 m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData()));
                  success = true;
                  break;
 
@@ -860,17 +853,13 @@ Scalar::Promote(Scalar::Type type)
              case e_ulonglong:   break;
              case e_sint128:     success = true; break;
              case e_uint128:
-                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
+                 m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
                  success = true;
                  break;
 
              case e_sint256:
-                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
-                 success = true;
-                 break;
-
              case e_uint256:
-                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
+                 m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData()));
                  success = true;
                  break;
 
@@ -907,12 +896,8 @@ Scalar::Promote(Scalar::Type type)
              case e_sint128:    break;
              case e_uint128:    success = true; break;
              case e_sint256:
-                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
-                 success = true;
-                 break;
-
              case e_uint256:
-                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
+                 m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData()));
                  success = true;
                  break;
 
@@ -950,7 +935,7 @@ Scalar::Promote(Scalar::Type type)
             case e_uint128: break;
             case e_sint256: success = true; break;
             case e_uint256:
-                m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
+                m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
                 success = true;
                 break;
 
@@ -1384,35 +1369,9 @@ Scalar::MakeSigned ()
     case e_slonglong:                           success = true; break;
     case e_ulonglong:   m_type = e_slonglong;   success = true; break;
     case e_sint128:                             success = true; break;
-    case e_uint128:     m_type = e_sint128;     success = true; break;
-    case e_sint256:                             success = true; break;
-    case e_uint256:     m_type = e_sint256;     success = true; break;
-    case e_float:                               success = true; break;
-    case e_double:                              success = true; break;
-    case e_long_double:                         success = true; break;
-    }
-
-    return success;
-}
-
-bool
-Scalar::MakeUnsigned ()
-{
-    bool success = false;
-
-    switch (m_type)
-    {
-    case e_void:                                break;
-    case e_sint:                                success = true; break;
-    case e_uint:        m_type = e_uint;        success = true; break;
-    case e_slong:                               success = true; break;
-    case e_ulong:       m_type = e_ulong;       success = true; break;
-    case e_slonglong:                           success = true; break;
-    case e_ulonglong:   m_type = e_ulonglong;   success = true; break;
-    case e_sint128:                             success = true; break;
-    case e_uint128:     m_type = e_uint128;     success = true; break;
+    case e_uint128:     m_type = e_sint;        success = true; break;
     case e_sint256:                             success = true; break;
-    case e_uint256:     m_type = e_uint256;     success = true; break;
+    case e_uint256:     m_type = e_sint;        success = true; break;
     case e_float:                               success = true; break;
     case e_double:                              success = true; break;
     case e_long_double:                         success = true; break;
@@ -1421,7 +1380,7 @@ Scalar::MakeUnsigned ()
     return success;
 }
 
-signed char
+char
 Scalar::SChar(char fail_value) const
 {
     switch (m_type)
@@ -1437,14 +1396,14 @@ Scalar::SChar(char fail_value) const
     case e_uint128:
     case e_sint256:
     case e_uint256:
-        return (schar_t)(m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
+        return *(const schar_t *)(m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getRawData();
     case e_float:
         return (schar_t)m_float.convertToFloat();
     case e_double:
         return (schar_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return (schar_t)(ldbl_val.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
+        return (schar_t)*ldbl_val.getRawData();
     }
     return fail_value;
 }
@@ -1465,14 +1424,14 @@ Scalar::UChar(unsigned char fail_value) const
     case e_uint128:
     case e_sint256:
     case e_uint256:
-        return (uchar_t)(m_integer.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
+        return *(const uchar_t *)m_integer.getRawData();
     case e_float:
         return (uchar_t)m_float.convertToFloat();
     case e_double:
         return (uchar_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return (uchar_t)(ldbl_val.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
+        return (uchar_t)*ldbl_val.getRawData();
     }
     return fail_value;
 }
@@ -1493,14 +1452,14 @@ Scalar::SShort(short fail_value) const
     case e_uint128:
     case e_sint256:
     case e_uint256:
-        return (sshort_t)(m_integer.sextOrTrunc(sizeof(sshort_t) * 8)).getSExtValue();
+        return *(const sshort_t *)(m_integer.sextOrTrunc(sizeof(sshort_t) * 8)).getRawData();
     case e_float:
         return (sshort_t)m_float.convertToFloat();
     case e_double:
         return (sshort_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return (sshort_t)(ldbl_val.sextOrTrunc(sizeof(sshort_t) * 8)).getSExtValue();
+        return *(const sshort_t *)ldbl_val.getRawData();
     }
     return fail_value;
 }
@@ -1521,14 +1480,14 @@ Scalar::UShort(unsigned short fail_value) const
     case e_uint128:
     case e_sint256:
     case e_uint256:
-        return (ushort_t)(m_integer.zextOrTrunc(sizeof(ushort_t) * 8)).getZExtValue();
+        return *(const ushort_t *)m_integer.getRawData();
     case e_float:
         return (ushort_t)m_float.convertToFloat();
     case e_double:
         return (ushort_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return (ushort_t)(ldbl_val.zextOrTrunc(sizeof(ushort_t) * 8)).getZExtValue();
+        return *(const ushort_t *)ldbl_val.getRawData();;
     }
     return fail_value;
 }
@@ -1549,14 +1508,14 @@ Scalar::SInt(int fail_value) const
     case e_uint128:
     case e_sint256:
     case e_uint256:
-        return (sint_t)(m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
+        return *(const sint_t *)(m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getRawData();
     case e_float:
         return (sint_t)m_float.convertToFloat();
     case e_double:
         return (sint_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return (sint_t)(ldbl_val.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
+        return *(const sint_t *)ldbl_val.getRawData();
     }
     return fail_value;
 }
@@ -1577,14 +1536,14 @@ Scalar::UInt(unsigned int fail_value) const
     case e_uint128:
     case e_sint256:
     case e_uint256:
-        return (uint_t)(m_integer.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
+        return *(const uint_t *)m_integer.getRawData();
     case e_float:
         return (uint_t)m_float.convertToFloat();
     case e_double:
         return (uint_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return (uint_t)(ldbl_val.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
+        return *(const uint_t *)ldbl_val.getRawData();
     }
     return fail_value;
 }
@@ -1605,14 +1564,14 @@ Scalar::SLong(long fail_value) const
     case e_uint128:
     case e_sint256:
     case e_uint256:
-        return (slong_t)(m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
+        return *(const slong_t *)(m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getRawData();
     case e_float:
         return (slong_t)m_float.convertToFloat();
     case e_double:
         return (slong_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return (slong_t)(ldbl_val.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
+        return *(const slong_t *)ldbl_val.getRawData();
     }
     return fail_value;
 }
@@ -1633,14 +1592,44 @@ Scalar::ULong(unsigned long fail_value) const
     case e_uint128:
     case e_sint256:
     case e_uint256:
-        return (ulong_t)(m_integer.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
+        return *(const ulong_t *)m_integer.getRawData();
     case e_float:
         return (ulong_t)m_float.convertToFloat();
     case e_double:
         return (ulong_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return (ulong_t)(ldbl_val.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
+        return *(const ulong_t *)ldbl_val.getRawData();
+    }
+    return fail_value;
+}
+
+uint64_t
+Scalar::GetRawBits64(uint64_t fail_value) const
+{
+    switch (m_type)
+    {
+    case e_void:
+        break;
+
+    case e_sint:
+    case e_uint:
+    case e_slong:
+    case e_ulong:
+    case e_slonglong:
+    case e_ulonglong:
+    case e_sint128:
+    case e_uint128:
+    case e_sint256:
+    case e_uint256:
+        return *m_integer.getRawData();
+    case e_float:
+        return (uint64_t)m_float.convertToFloat();
+    case e_double:
+        return (uint64_t)m_float.convertToDouble();
+    case e_long_double:
+        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+        return *ldbl_val.getRawData();
     }
     return fail_value;
 }
@@ -1661,14 +1650,14 @@ Scalar::SLongLong(long long fail_value) const
     case e_uint128:
     case e_sint256:
     case e_uint256:
-        return (slonglong_t)(m_integer.sextOrTrunc(sizeof(slonglong_t) * 8)).getSExtValue();
+        return *(const slonglong_t *)(m_integer.sextOrTrunc(sizeof(slonglong_t) * 8)).getRawData();
     case e_float:
         return (slonglong_t)m_float.convertToFloat();
     case e_double:
         return (slonglong_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return (slonglong_t)(ldbl_val.sextOrTrunc(sizeof(slonglong_t) * 8)).getSExtValue();
+        return *(const slonglong_t *)ldbl_val.getRawData();
     }
     return fail_value;
 }
@@ -1689,14 +1678,14 @@ Scalar::ULongLong(unsigned long long fail_value) const
     case e_uint128:
     case e_sint256:
     case e_uint256:
-        return (ulonglong_t)(m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue();
+        return *(const ulonglong_t *)m_integer.getRawData();
     case e_float:
         return (ulonglong_t)m_float.convertToFloat();
     case e_double:
         return (ulonglong_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return (ulonglong_t)(ldbl_val.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue();
+        return *(const ulonglong_t *)ldbl_val.getRawData();
     }
     return fail_value;
 }
@@ -1959,7 +1948,7 @@ Scalar::operator<<= (const Scalar& rhs)
              case e_uint128:
              case e_sint256:
              case e_uint256:
-                 m_integer = m_integer << rhs.m_integer;
+                 m_integer <<= *rhs.m_integer.getRawData();
                  break;
         }
         break;
@@ -2007,8 +1996,7 @@ Scalar::ShiftRightLogical(const Scalar& rhs)
         case e_uint128:
         case e_sint256:
         case e_uint256:
-            m_integer = m_integer.lshr(rhs.m_integer);
-            break;
+            m_integer = m_integer.lshr(*(const uint_t *) rhs.m_integer.getRawData());   break;
         }
         break;
     }
@@ -2055,7 +2043,7 @@ Scalar::operator>>= (const Scalar& rhs)
         case e_uint128:
         case e_sint256:
         case e_uint256:
-            m_integer = m_integer.ashr(rhs.m_integer);
+            m_integer = m_integer.ashr(*(const uint_t *)rhs.m_integer.getRawData());
             break;
         }
         break;
@@ -2270,24 +2258,18 @@ lldb_private::operator/ (const Scalar& lhs, const Scalar& rhs)
         {
         case Scalar::e_void:            break;
         case Scalar::e_sint:
-        case Scalar::e_slong:
-        case Scalar::e_slonglong:
-        case Scalar::e_sint128:
-        case Scalar::e_sint256:
-            if (b->m_integer != 0)
-            {
-                result.m_integer = a->m_integer.sdiv(b->m_integer);
-                return result;
-            }
-            break;
         case Scalar::e_uint:
+        case Scalar::e_slong:
         case Scalar::e_ulong:
+        case Scalar::e_slonglong:
         case Scalar::e_ulonglong:
+        case Scalar::e_sint128:
         case Scalar::e_uint128:
+        case Scalar::e_sint256:
         case Scalar::e_uint256:
             if (b->m_integer != 0)
             {
-                result.m_integer = a->m_integer.udiv(b->m_integer);
+                result.m_integer = *a->m_integer.getRawData() / *b->m_integer.getRawData();
                 return result;
             }
             break;
@@ -2423,23 +2405,18 @@ lldb_private::operator% (const Scalar& lhs, const Scalar& rhs)
         default:                    break;
              case Scalar::e_void:            break;
              case Scalar::e_sint:
-             case Scalar::e_slong:
-             case Scalar::e_slonglong:
-             case Scalar::e_sint128:
-             case Scalar::e_sint256:
-                 if (b->m_integer != 0)
-                 {
-                     result.m_integer = a->m_integer.srem(b->m_integer);
-                     return result;
-                 }
              case Scalar::e_uint:
+             case Scalar::e_slong:
              case Scalar::e_ulong:
+             case Scalar::e_slonglong:
              case Scalar::e_ulonglong:
+             case Scalar::e_sint128:
              case Scalar::e_uint128:
+             case Scalar::e_sint256:
              case Scalar::e_uint256:
                  if (b->m_integer != 0)
                  {
-                     result.m_integer = a->m_integer.urem(b->m_integer);
+                     result.m_integer = *a->m_integer.getRawData() % *b->m_integer.getRawData();
                      return result;
                  }
                  break;
@@ -2500,6 +2477,27 @@ lldb_private::operator>> (const Scalar& lhs, const Scalar &rhs)
     return result;
 }
 
+// Return the raw unsigned integer without any casting or conversion
+unsigned int
+Scalar::RawUInt () const
+{
+    return *(const uint_t *) m_integer.getRawData();
+}
+
+// Return the raw unsigned long without any casting or conversion
+unsigned long
+Scalar::RawULong () const
+{
+    return *(const ulong_t *) m_integer.getRawData();
+}
+
+// Return the raw unsigned long long without any casting or conversion
+unsigned long long
+Scalar::RawULongLong () const
+{
+    return *(const ulonglong_t *) m_integer.getRawData();
+}
+
 Error
 Scalar::SetValueFromCString (const char *value_str, Encoding encoding, size_t byte_size)
 {
@@ -2654,12 +2652,12 @@ Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t b
                 if (data.GetByteOrder() == eByteOrderBig)
                 {
                     int128.x[1] = (uint64_t)data.GetU64 (&offset);
-                    int128.x[0] = (uint64_t)data.GetU64 (&offset);
+                    int128.x[0] = (uint64_t)data.GetU64 (&offset + 1);
                 }
                 else
                 {
                     int128.x[0] = (uint64_t)data.GetU64 (&offset);
-                    int128.x[1] = (uint64_t)data.GetU64 (&offset);
+                    int128.x[1] = (uint64_t)data.GetU64 (&offset + 1);
                 }
                 operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
                 break;
@@ -2667,16 +2665,16 @@ Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t b
                 if (data.GetByteOrder() == eByteOrderBig)
                 {
                     int256.x[3] = (uint64_t)data.GetU64 (&offset);
-                    int256.x[2] = (uint64_t)data.GetU64 (&offset);
-                    int256.x[1] = (uint64_t)data.GetU64 (&offset);
-                    int256.x[0] = (uint64_t)data.GetU64 (&offset);
+                    int256.x[2] = (uint64_t)data.GetU64 (&offset + 1);
+                    int256.x[1] = (uint64_t)data.GetU64 (&offset + 1);
+                    int256.x[0] = (uint64_t)data.GetU64 (&offset + 1);
                 }
                 else
                 {
                     int256.x[0] = (uint64_t)data.GetU64 (&offset);
-                    int256.x[1] = (uint64_t)data.GetU64 (&offset);
-                    int256.x[2] = (uint64_t)data.GetU64 (&offset);
-                    int256.x[3] = (uint64_t)data.GetU64 (&offset);
+                    int256.x[1] = (uint64_t)data.GetU64 (&offset + 1);
+                    int256.x[2] = (uint64_t)data.GetU64 (&offset + 1);
+                    int256.x[3] = (uint64_t)data.GetU64 (&offset + 1);
                 }
                 operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
                 break;
@@ -2700,12 +2698,12 @@ Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t b
                 if (data.GetByteOrder() == eByteOrderBig)
                 {
                     int128.x[1] = (uint64_t)data.GetU64 (&offset);
-                    int128.x[0] = (uint64_t)data.GetU64 (&offset);
+                    int128.x[0] = (uint64_t)data.GetU64 (&offset + 1);
                 }
                 else
                 {
                     int128.x[0] = (uint64_t)data.GetU64 (&offset);
-                    int128.x[1] = (uint64_t)data.GetU64 (&offset);
+                    int128.x[1] = (uint64_t)data.GetU64 (&offset + 1);
                 }
                 operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
                 break;
@@ -2713,16 +2711,16 @@ Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t b
                 if (data.GetByteOrder() == eByteOrderBig)
                 {
                     int256.x[3] = (uint64_t)data.GetU64 (&offset);
-                    int256.x[2] = (uint64_t)data.GetU64 (&offset);
-                    int256.x[1] = (uint64_t)data.GetU64 (&offset);
-                    int256.x[0] = (uint64_t)data.GetU64 (&offset);
+                    int256.x[2] = (uint64_t)data.GetU64 (&offset + 1);
+                    int256.x[1] = (uint64_t)data.GetU64 (&offset + 1);
+                    int256.x[0] = (uint64_t)data.GetU64 (&offset + 1);
                 }
                 else
                 {
                     int256.x[0] = (uint64_t)data.GetU64 (&offset);
-                    int256.x[1] = (uint64_t)data.GetU64 (&offset);
-                    int256.x[2] = (uint64_t)data.GetU64 (&offset);
-                    int256.x[3] = (uint64_t)data.GetU64 (&offset);
+                    int256.x[1] = (uint64_t)data.GetU64 (&offset + 1);
+                    int256.x[2] = (uint64_t)data.GetU64 (&offset + 1);
+                    int256.x[3] = (uint64_t)data.GetU64 (&offset + 1);
                 }
                 operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
                 break;
@@ -2830,20 +2828,37 @@ Scalar::ExtractBitfield (uint32_t bit_size,
     if (bit_size == 0)
         return true;
 
+    uint32_t msbit = bit_offset + bit_size - 1;
+    uint32_t lsbit = bit_offset;
+    uint64_t result;
     switch (m_type)
     {
         case Scalar::e_void:
-        case Scalar::e_float:
-        case Scalar::e_double:
-        case Scalar::e_long_double:
             break;
             
+        case e_float:
+            result = SignedBits ((uint64_t )m_float.convertToFloat(), msbit, lsbit);
+            m_float = llvm::APFloat((float_t)result);
+            return true;
+        case e_double:
+            result = SignedBits ((uint64_t )m_float.convertToDouble(), msbit, lsbit);
+            m_float = llvm::APFloat((double_t)result);
+            return true;
+        case e_long_double:
+            m_integer = m_float.bitcastToAPInt();
+            result = SignedBits (*m_integer.getRawData(), msbit, lsbit);
+            if(m_ieee_quad)
+                m_float = llvm::APFloat(llvm::APFloat::IEEEquad, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&result)->x));
+            else
+                m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&result)->x));
+            return true;
+            
         case Scalar::e_sint:
         case Scalar::e_slong:
         case Scalar::e_slonglong:
         case Scalar::e_sint128:
         case Scalar::e_sint256:
-            m_integer = m_integer.ashr(bit_offset).trunc(bit_size).sext(8 * GetByteSize());
+            m_integer = SignedBits (*m_integer.getRawData(), msbit, lsbit);
             return true;
 
         case Scalar::e_uint:
@@ -2851,7 +2866,7 @@ Scalar::ExtractBitfield (uint32_t bit_size,
         case Scalar::e_ulonglong:
         case Scalar::e_uint128:
         case Scalar::e_uint256:
-            m_integer = m_integer.lshr(bit_offset).trunc(bit_size).zext(8 * GetByteSize());
+            m_integer = UnsignedBits (*m_integer.getRawData(), msbit, lsbit);
             return true;
     }
     return false;

diff --git a/lldb/source/Expression/IRInterpreter.cpp b/lldb/source/Expression/IRInterpreter.cpp
index 2871a06..a0d7a16 100644 (file)
--- a/lldb/source/Expression/IRInterpreter.cpp
+++ b/lldb/source/Expression/IRInterpreter.cpp
@@ -231,7 +231,7 @@ public:
 
         lldb_private::Scalar cast_scalar;
 
-        if (!AssignToMatchType(cast_scalar, scalar.ULongLong(), value->getType()))
+        if (!AssignToMatchType(cast_scalar, scalar.GetRawBits64(0), value->getType()))
             return false;
 
         size_t value_byte_size = m_target_data.getTypeStoreSize(value->getType());
@@ -373,18 +373,19 @@ public:
         if (!ResolveConstantValue(resolved_value, constant))
             return false;
 
+        lldb_private::StreamString buffer (lldb_private::Stream::eBinary,
+                                           m_execution_unit.GetAddressByteSize(),
+                                           m_execution_unit.GetByteOrder());
+
         size_t constant_size = m_target_data.getTypeStoreSize(constant->getType());
-        lldb_private::DataBufferHeap buf(constant_size, 0);
 
-        lldb_private::Error get_data_error;
+        const uint64_t *raw_data = resolved_value.getRawData();
 
-        lldb_private::Scalar resolved_scalar(resolved_value.zextOrTrunc(llvm::NextPowerOf2(constant_size) * 8));
-        if (!resolved_scalar.GetAsMemoryData(buf.GetBytes(), buf.GetByteSize(), m_byte_order, get_data_error))
-            return false;
+        buffer.PutRawBytes(raw_data, constant_size, lldb_private::endian::InlHostByteOrder());
 
         lldb_private::Error write_error;
 
-        m_execution_unit.WriteMemory(process_address, buf.GetBytes(), buf.GetByteSize(), write_error);
+        m_execution_unit.WriteMemory(process_address, (const uint8_t*)buffer.GetData(), constant_size, write_error);
 
         return write_error.Success();
     }
@@ -818,9 +819,7 @@ IRInterpreter::Interpret (llvm::Module &module,
                         result = L / R;
                         break;
                     case Instruction::UDiv:
-                        L.MakeUnsigned();
-                        R.MakeUnsigned();
-                        result = L / R;
+                        result = L.GetRawBits64(0) / R.GetRawBits64(1);
                         break;
                     case Instruction::SRem:
                         L.MakeSigned();
@@ -828,9 +827,7 @@ IRInterpreter::Interpret (llvm::Module &module,
                         result = L % R;
                         break;
                     case Instruction::URem:
-                        L.MakeUnsigned();
-                        R.MakeUnsigned();
-                        result = L % R;
+                        result = L.GetRawBits64(0) % R.GetRawBits64(1);
                         break;
                     case Instruction::Shl:
                         result = L << R;
@@ -1033,7 +1030,7 @@ IRInterpreter::Interpret (llvm::Module &module,
                         return false;
                     }
 
-                    if (!C.IsZero())
+                    if (C.GetRawBits64(0))
                         frame.Jump(br_inst->getSuccessor(0));
                     else
                         frame.Jump(br_inst->getSuccessor(1));
@@ -1184,24 +1181,16 @@ IRInterpreter::Interpret (llvm::Module &module,
                         result = (L != R);
                         break;
                     case CmpInst::ICMP_UGT:
-                        L.MakeUnsigned();
-                        R.MakeUnsigned();
-                        result = (L > R);
+                        result = (L.GetRawBits64(0) > R.GetRawBits64(0));
                         break;
                     case CmpInst::ICMP_UGE:
-                        L.MakeUnsigned();
-                        R.MakeUnsigned();
-                        result = (L >= R);
+                        result = (L.GetRawBits64(0) >= R.GetRawBits64(0));
                         break;
                     case CmpInst::ICMP_ULT:
-                        L.MakeUnsigned();
-                        R.MakeUnsigned();
-                        result = (L < R);
+                        result = (L.GetRawBits64(0) < R.GetRawBits64(0));
                         break;
                     case CmpInst::ICMP_ULE:
-                        L.MakeUnsigned();
-                        R.MakeUnsigned();
-                        result = (L <= R);
+                        result = (L.GetRawBits64(0) <= R.GetRawBits64(0));
                         break;
                     case CmpInst::ICMP_SGT:
                         L.MakeSigned();

diff --git a/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp b/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp
index 12ba7e3..62aa5b7 100644 (file)
--- a/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp
+++ b/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp
@@ -1105,13 +1105,7 @@ IRForTarget::MaterializeInitializer (uint8_t *data, Constant *initializer)
 
     if (ConstantInt *int_initializer = dyn_cast<ConstantInt>(initializer))
     {
-        size_t constant_size = m_target_data->getTypeStoreSize(initializer_type);
-        lldb_private::Scalar scalar = int_initializer->getValue().zextOrTrunc(llvm::NextPowerOf2(constant_size) * 8);
-
-        lldb_private::Error get_data_error;
-        if (!scalar.GetAsMemoryData(data, constant_size, lldb_private::endian::InlHostByteOrder(), get_data_error))
-            return false;
-
+        memcpy (data, int_initializer->getValue().getRawData(), m_target_data->getTypeStoreSize(initializer_type));
         return true;
     }
     else if (ConstantDataArray *array_initializer = dyn_cast<ConstantDataArray>(initializer))

diff --git a/lldb/source/Symbol/ClangASTContext.cpp b/lldb/source/Symbol/ClangASTContext.cpp
index 603beb9..7a62f82 100644 (file)
--- a/lldb/source/Symbol/ClangASTContext.cpp
+++ b/lldb/source/Symbol/ClangASTContext.cpp
@@ -72,7 +72,6 @@
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RegularExpression.h"
-#include "lldb/Core/Scalar.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ThreadSafeDenseMap.h"
 #include "lldb/Core/UniqueCStringMap.h"
@@ -8647,10 +8646,18 @@ ClangASTContext::ConvertStringToFloatValue (lldb::opaque_compiler_type_t type, c
             const uint64_t byte_size = bit_size / 8;
             if (dst_size >= byte_size)
             {
-                Scalar scalar = ap_float.bitcastToAPInt().zextOrTrunc(llvm::NextPowerOf2(byte_size) * 8);
-                lldb_private::Error get_data_error;
-                if (scalar.GetAsMemoryData(dst, byte_size, lldb_private::endian::InlHostByteOrder(), get_data_error))
+                if (bit_size == sizeof(float)*8)
+                {
+                    float float32 = ap_float.convertToFloat();
+                    ::memcpy (dst, &float32, byte_size);
                     return byte_size;
+                }
+                else if (bit_size >= 64)
+                {
+                    llvm::APInt ap_int(ap_float.bitcastToAPInt());
+                    ::memcpy (dst, ap_int.getRawData(), byte_size);
+                    return byte_size;
+                }
             }
         }
     }

diff --git a/lldb/unittests/Core/ScalarTest.cpp b/lldb/unittests/Core/ScalarTest.cpp
index 2a5643f..63c0daa 100644 (file)
--- a/lldb/unittests/Core/ScalarTest.cpp
+++ b/lldb/unittests/Core/ScalarTest.cpp
@@ -15,10 +15,7 @@
 
 #include "gtest/gtest.h"
 
-#include "lldb/Core/Error.h"
 #include "lldb/Core/Scalar.h"
-#include "lldb/Core/DataExtractor.h"
-#include "lldb/Host/Endian.h"
 
 using namespace lldb_private;
 
@@ -33,49 +30,3 @@ TEST(ScalarTest, RightShiftOperator)
     ASSERT_EQ(a >> c, a_scalar >> c_scalar);
     ASSERT_EQ(b >> c, b_scalar >> c_scalar);
 }
-
-TEST(ScalarTest, GetBytes)
-{
-    int a = 0x01020304;
-    long long b = 0x0102030405060708LL;
-    float c = 1234567.89e42;
-    double d = 1234567.89e42;
-    char e[16] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
-    char f[32] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-                   17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32 };
-    Scalar a_scalar(a);
-    Scalar b_scalar(b);
-    Scalar c_scalar(c);
-    Scalar d_scalar(d);
-    Scalar e_scalar;
-    Scalar f_scalar;
-    DataExtractor e_data(e, sizeof(e), endian::InlHostByteOrder(), sizeof(void *));
-    Error e_error = e_scalar.SetValueFromData(e_data, lldb::eEncodingUint, sizeof(e));
-    DataExtractor f_data(f, sizeof(f), endian::InlHostByteOrder(), sizeof(void *));
-    Error f_error = f_scalar.SetValueFromData(f_data, lldb::eEncodingUint, sizeof(f));
-    ASSERT_EQ(0, memcmp(&a, a_scalar.GetBytes(), sizeof(a)));
-    ASSERT_EQ(0, memcmp(&b, b_scalar.GetBytes(), sizeof(b)));
-    ASSERT_EQ(0, memcmp(&c, c_scalar.GetBytes(), sizeof(c)));
-    ASSERT_EQ(0, memcmp(&d, d_scalar.GetBytes(), sizeof(d)));
-    ASSERT_EQ(0, e_error.Fail());
-    ASSERT_EQ(0, memcmp(e, e_scalar.GetBytes(), sizeof(e)));
-    ASSERT_EQ(0, f_error.Fail());
-    ASSERT_EQ(0, memcmp(f, f_scalar.GetBytes(), sizeof(f)));
-}
-
-TEST(ScalarTest, CastOperations)
-{
-    long long a = 0xf1f2f3f4f5f6f7f8LL;
-    Scalar a_scalar(a);
-    ASSERT_EQ((signed char)a, a_scalar.SChar());
-    ASSERT_EQ((unsigned char)a, a_scalar.UChar());
-    ASSERT_EQ((signed short)a, a_scalar.SShort());
-    ASSERT_EQ((unsigned short)a, a_scalar.UShort());
-    ASSERT_EQ((signed int)a, a_scalar.SInt());
-    ASSERT_EQ((unsigned int)a, a_scalar.UInt());
-    ASSERT_EQ((signed long)a, a_scalar.SLong());
-    ASSERT_EQ((unsigned long)a, a_scalar.ULong());
-    ASSERT_EQ((signed long long)a, a_scalar.SLongLong());
-    ASSERT_EQ((unsigned long long)a, a_scalar.ULongLong());
-}
-