Fix usage of APInt.getRawData for big-endian systems

[uweigand]

Summary

The Scalar implementation and a few other places in LLDB directly
access the internal implementation of APInt values using the
getRawData method. Unfortunately, pretty much all of these places
do not handle big-endian systems correctly. While on little-endian
machines, the pointer returned by getRawData can simply be used as
a pointer to the integer value in its natural format, no matter
what size, this is not true on big-endian systems: getRawData
actually points to an array of type uint64_t, with the first element
of the array always containing the least-significant word of the
integer. This means that if the bitsize of that integer is smaller
than 64, we need to add an offset to the pointer returned by
getRawData in order to access the value in its natural type, and
if the bitsize is *larger* than 64, we actually have to swap the
constituent words before we can access the value in its natural type.

This patch fixes every incorrect use of getRawData in the code base.
For the most part, this is done by simply removing uses of getRawData
in the first place, and using other APInt member functions to operate
on the integer data.

This can be done in many member functions of Scalar itself, as well
as in Symbol/Type.h and in IRInterpreter::Interpret. For the latter,
I've had to add a Scalar::MakeUnsigned routine to parallel the existing
Scalar::MakeSigned, e.g. in order to implement an unsigned divide.

The Scalar::RawUInt, Scalar::RawULong, and Scalar::RawULongLong
were already unused and can be simply removed. I've also removed
the Scalar::GetRawBits64 function and its few users.

The one remaining user of getRawData in Scalar.cpp is GetBytes.
I've implemented all the cases described above to correctly
implement access to the underlying integer data on big-endian
systems. GetData now simply calls GetBytes instead of reimplementing
its contents.

Finally, two places in the clang interface code were also accessing
APInt.getRawData in order to actually construct a byte representation
of an integer. I've changes those to make use of a Scalar instead,
to avoid having to re-implement the logic there.

[clayborg]

Looks good.

[labath]

It would be great if you could add a some unit tests for your modifications to the Scalar class. You don't have to be too exhaustive, but a couple of tests would go a long way.

[uweigand]

This adds some unit tests verifying correct operation of the GetBytes routine as well as the conversions (SChar, UChar, ...). Those tests actually exposed more problems in the original Scalar code: the SetValueFromData routine didn't work correctly for 128- and 256-bit data types, and the SChar routine should have an explicit "signed char" return type to work correctly on platforms where char defaults to unsigned.

Regression testing on Intel revealed a bug in my original patch: since Scalar only accepts APInt initializers with a bit size that is a power of 2, we may need to extend some values before converting them to Scalar. This occured for values representing 10-byte Intel long double data.

Tested on System z and Intel.

[labath]

I am glad that the unit tests are finding real problems and not just being a nuisance. Thanks a lot.

source/Core/Scalar.cpp

2655 ↗

(On Diff #53622)

:D

lldb/trunk/include/lldb/Core/Scalar.h

public:
     Promote(Scalar::Type type);
 
     bool
     Cast (Scalar::Type type);
     
     bool
     MakeSigned ();
 
+    bool
+    MakeUnsigned ();
+
     static const char *
     GetValueTypeAsCString (Scalar::Type value_type);
 
     static Scalar::Type
     GetValueTypeForSignedIntegerWithByteSize (size_t byte_size);
 
     static Scalar::Type
     GetValueTypeForUnsignedIntegerWithByteSize (size_t byte_size);
public:
     //----------------------------------------------------------------------
     // Returns a casted value of the current contained data without
     // modifying the current value. FAIL_VALUE will be returned if the type
     // of the value is void or invalid.
     //----------------------------------------------------------------------
     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;
 
-    char
+    signed char
     SChar(char fail_value = 0) const;
 
     unsigned short
     UShort(unsigned short fail_value = 0) const;
 
     short
     SShort(short fail_value = 0) const;
 
public:
     Float(float fail_value = 0.0f) const;
 
     double
     Double(double fail_value = 0.0) const;
 
     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);
     
     Error
     SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t byte_size);
 
     static bool
     UIntValueIsValidForSize (uint64_t uval64, size_t total_byte_size)

lldb/trunk/include/lldb/Symbol/Type.h

public:
     GetIntegerType () const
     {
         return m_integer_type_sp;
     }
 
     uint64_t
     GetValueAsUnsigned () const
     {
-        return *m_value.getRawData();
+        return m_value.getZExtValue();
     }
 
     int64_t
     GetValueAsSigned () const
     {
-        return (int64_t) *m_value.getRawData();
+        return m_value.getSExtValue();
     }
 
 protected:
     lldb::TypeImplSP m_integer_type_sp;
     ConstString m_name;
     llvm::APSInt m_value;
     bool m_valid;
 };

lldb/trunk/source/Core/Scalar.cpp

 
 // C Includes
 // C++ Includes
 #include <cinttypes>
 #include <cmath>
 #include <cstdio>
 
 // Other libraries and framework includes
+#include "llvm/ADT/SmallString.h"
+
 // Project includes
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Host/StringConvert.h"
 

 //      break;
 //  }
 //}
 
 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)
             {
                 // On little endian systems if we want fewer bytes from the
                 // current type we just specify fewer bytes since the LSByte
                 // is first...
-                switch(m_type)
-                {
-                case e_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;
-                }
+                byte_size = limit_byte_size;
             }
             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
-                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;
+                bytes += byte_size - limit_byte_size;
+                byte_size = limit_byte_size;
             }
         }
+
+        data.SetData(bytes, byte_size, endian::InlHostByteOrder());
         return true;
     }
     data.Clear();
     return false;
 }
 
 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:
         break;
     case e_sint:
     case e_uint:
     case e_slong:
     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:
-        return reinterpret_cast<const void *>(m_integer.getRawData());
+        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);
     case e_float:
         flt_val = m_float.convertToFloat();
         return reinterpret_cast<const void *>(&flt_val);
     case e_double:
         dbl_val = m_float.convertToDouble();
         return reinterpret_cast<const void *>(&dbl_val);
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return reinterpret_cast<const void *>(ldbl_val.getRawData());
+        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 nullptr;
 }
 
 size_t
 Scalar::GetByteSize() const
 {
     switch (m_type)
case e_long_double:
         return m_float.isZero();
     }
     return false;
 }
 
 void
 Scalar::GetValue (Stream *s, bool show_type) const
 {
-    const uint64_t *src;
     if (show_type)
         s->Printf("(%s) ", GetTypeAsCString());
 
     switch (m_type)
     {
     case e_void:
         break;
-    case e_sint:        s->Printf("%i", *(const sint_t *) m_integer.getRawData());                        break;
-    case e_uint:        s->Printf("0x%8.8x", *(const uint_t *) m_integer.getRawData());           break;
-    case e_slong:       s->Printf("%li", *(const slong_t *) m_integer.getRawData());                       break;
-    case e_ulong:       s->Printf("0x%8.8lx", *(const ulong_t *) m_integer.getRawData());         break;
-    case e_slonglong:   s->Printf("%lli", *(const slonglong_t *) m_integer.getRawData());                  break;
-    case e_ulonglong:   s->Printf("0x%16.16llx", *(const ulonglong_t *) m_integer.getRawData()); break;
+    case e_sint:
+    case e_ulong:
+    case e_slonglong:
     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:       s->Printf("%f", m_float.convertToFloat());                break;
-    case e_double:      s->Printf("%g", m_float.convertToDouble());                break;
+    case e_float:
+    case e_double:
     case e_long_double:
-        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        s->Printf("%Lg", *(const long_double_t *)ldbl_val.getRawData());
+        llvm::SmallString<24> string;
+        m_float.toString(string);
+        s->Printf("%s", string.c_str());
         break;
     }
 }
 
 const char *
 Scalar::GetTypeAsCString() const
 {
     switch (m_type)
case e_void:
         break;
 
     case e_sint:
         switch (type)
         {
             case e_void: break;
             case e_sint: success = true; break;
             case e_uint:
-                m_integer = llvm::APInt(sizeof(uint_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
+                m_integer = m_integer.zextOrTrunc(sizeof(uint_t) * 8);
                 success = true;
                 break;
 
             case e_slong:
-                m_integer = llvm::APInt(sizeof(slong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
+                m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
                 success = true;
                 break;
 
             case e_ulong:
-                m_integer = llvm::APInt(sizeof(ulong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
+                m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8);
                 success = true;
                 break;
 
             case e_slonglong:
-                m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
+                m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
                 success = true;
                 break;
 
             case e_ulonglong:
-                m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
+                m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
                 success = true;
                 break;
 
             case e_sint128:
+                m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
+                success = true;
+                break;
+
             case e_uint128:
-                m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
+                m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
                 success = true;
                 break;
 
             case e_sint256:
+                m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
+                success = true;
+                break;
+
             case e_uint256:
-                m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData()));
+                m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
                 success = true;
                 break;
 
             case e_float:
                 m_float = llvm::APFloat(m_integer.bitsToFloat());
                 success = true;
                 break;
 
Scalar::Promote(Scalar::Type type)
 
     case e_uint:
         switch (type)
         {
              case e_void:
              case e_sint:     break;
              case e_uint:     success = true; break;
              case e_slong:
-                 m_integer = llvm::APInt(sizeof(slong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
+                 m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
                  success = true;
                  break;
 
              case e_ulong:
-                 m_integer = llvm::APInt(sizeof(ulong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
+                 m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8);
                  success = true;
                  break;
 
              case e_slonglong:
-                 m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
+                 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
                  success = true;
                  break;
 
              case e_ulonglong:
-                 m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
+                 m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
                  success = true;
                  break;
 
              case e_sint128:
+                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
+                 success = true;
+                 break;
+
              case e_uint128:
-                 m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
+                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
                  success = true;
                  break;
 
             case e_sint256:
+                m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
+                success = true;
+                break;
+
             case e_uint256:
-                m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData()));
+                m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
                 success = true;
                 break;
 
             case e_float:
                  m_float = llvm::APFloat(m_integer.bitsToFloat());
                  success = true;
                  break;
 
Scalar::Promote(Scalar::Type type)
     case e_slong:
         switch (type)
         {
              case e_void:
              case e_sint:
              case e_uint:    break;
              case e_slong:   success = true; break;
              case e_ulong:
-                 m_integer = llvm::APInt(sizeof(ulong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
+                 m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8);
                  success = true;
                  break;
 
              case e_slonglong:
-                 m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
+                 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
                  success = true;
                  break;
 
              case e_ulonglong:
-                 m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
+                 m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
                  success = true;
                  break;
 
              case e_sint128:
+                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
+                 success = true;
+                 break;
+
              case e_uint128:
-                 m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
+                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
                  success = true;
                  break;
 
              case e_sint256:
+                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
+                 success = true;
+                 break;
+
              case e_uint256:
-                 m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData()));
+                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
                  success = true;
                  break;
 
              case e_float:
                  m_float = llvm::APFloat(m_integer.bitsToFloat());
                  success = true;
                  break;
 
case e_ulong:
         switch (type)
         {
              case e_void:
              case e_sint:
              case e_uint:
              case e_slong:    break;
              case e_ulong:    success = true; break;
              case e_slonglong:
-                 m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
+                 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
                  success = true;
                  break;
 
              case e_ulonglong:
-                 m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
+                 m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
                  success = true;
                  break;
 
              case e_sint128:
+                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
+                 success = true;
+                 break;
+
              case e_uint128:
-                 m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
+                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
                  success = true;
                  break;
 
              case e_sint256:
+                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
+                 success = true;
+                 break;
+
              case e_uint256:
-                 m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData()));
+                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
                  success = true;
                  break;
 
              case e_float:
                  m_float = llvm::APFloat(m_integer.bitsToFloat());
                  success = true;
                  break;
 
case e_slonglong:
         {
              case e_void:
              case e_sint:
              case e_uint:
              case e_slong:
              case e_ulong:        break;
              case e_slonglong:    success = true; break;
              case e_ulonglong:
-                 m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
+                 m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
                  success = true;
                  break;
 
              case e_sint128:
+                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
+                 success = true;
+                 break;
+
              case e_uint128:
-                 m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
+                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
                  success = true;
                  break;
 
              case e_sint256:
+                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
+                 success = true;
+                 break;
+
              case e_uint256:
-                 m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData()));
+                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
                  success = true;
                  break;
 
              case e_float:
                  m_float = llvm::APFloat(m_integer.bitsToFloat());
                  success = true;
                  break;
 
case e_ulonglong:
              case e_void:
              case e_sint:
              case e_uint:
              case e_slong:
              case e_ulong:
              case e_slonglong:    break;
              case e_ulonglong:    success = true; break;
              case e_sint128:
+                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
+                 success = true;
+                 break;
+
              case e_uint128:
-                 m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
+                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
                  success = true;
                  break;
 
              case e_sint256:
+                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
+                 success = true;
+                 break;
+
              case e_uint256:
-                 m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData()));
+                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
                  success = true;
                  break;
 
              case e_float:
                  m_float = llvm::APFloat(m_integer.bitsToFloat());
                  success = true;
                  break;
 
case e_sint128:
              case e_sint:
              case e_uint:
              case e_slong:
              case e_ulong:
              case e_slonglong:
              case e_ulonglong:   break;
              case e_sint128:     success = true; break;
              case e_uint128:
-                 m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
+                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
                  success = true;
                  break;
 
              case e_sint256:
+                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
+                 success = true;
+                 break;
+
              case e_uint256:
-                 m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData()));
+                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
                  success = true;
                  break;
 
              case e_float:
                  m_float = llvm::APFloat(m_integer.bitsToFloat());
                  success = true;
                  break;
 
case e_uint128:
              case e_uint:
              case e_slong:
              case e_ulong:
              case e_slonglong:
              case e_ulonglong:
              case e_sint128:    break;
              case e_uint128:    success = true; break;
              case e_sint256:
+                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
+                 success = true;
+                 break;
+
              case e_uint256:
-                 m_integer = llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, ((const type256 *)m_integer.getRawData()));
+                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
                  success = true;
                  break;
 
              case e_float:
                  m_float = llvm::APFloat(m_integer.bitsToFloat());
                  success = true;
                  break;
 
case e_sint256:
             case e_slong:
             case e_ulong:
             case e_slonglong:
             case e_ulonglong:
             case e_sint128:
             case e_uint128: break;
             case e_sint256: success = true; break;
             case e_uint256:
-                m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
+                m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
                 success = true;
                 break;
 
             case e_float:
                 m_float = llvm::APFloat(m_integer.bitsToFloat());
                 success = true;
                 break;
 
Scalar::MakeSigned ()
     case e_void:                                break;
     case e_sint:                                success = true; break;
     case e_uint:        m_type = e_sint;        success = true; break;
     case e_slong:                               success = true; break;
     case e_ulong:       m_type = e_slong;       success = true; break;
     case e_slonglong:                           success = true; break;
     case e_ulonglong:   m_type = e_slonglong;   success = true; break;
     case e_sint128:                             success = true; break;
-    case e_uint128:     m_type = e_sint;        success = true; break;
+    case e_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_sint256:                             success = true; break;
-    case e_uint256:     m_type = e_sint;        success = true; break;
+    case e_uint256:     m_type = e_uint256;     success = true; break;
     case e_float:                               success = true; break;
     case e_double:                              success = true; break;
     case e_long_double:                         success = true; break;
     }
     
     return success;
 }
 
-char
+signed char
 Scalar::SChar(char 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 *(const schar_t *)(m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getRawData();
+        return (schar_t)(m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
     case e_float:
         return (schar_t)m_float.convertToFloat();
     case e_double:
         return (schar_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return (schar_t)*ldbl_val.getRawData();
+        return (schar_t)(ldbl_val.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
     }
     return fail_value;
 }
 
 unsigned char
 Scalar::UChar(unsigned char 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 *(const uchar_t *)m_integer.getRawData();
+        return (uchar_t)(m_integer.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
     case e_float:
         return (uchar_t)m_float.convertToFloat();
     case e_double:
         return (uchar_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return (uchar_t)*ldbl_val.getRawData();
+        return (uchar_t)(ldbl_val.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
     }
     return fail_value;
 }
 
 short
 Scalar::SShort(short 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 *(const sshort_t *)(m_integer.sextOrTrunc(sizeof(sshort_t) * 8)).getRawData();
+        return (sshort_t)(m_integer.sextOrTrunc(sizeof(sshort_t) * 8)).getSExtValue();
     case e_float:
         return (sshort_t)m_float.convertToFloat();
     case e_double:
         return (sshort_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return *(const sshort_t *)ldbl_val.getRawData();
+        return (sshort_t)(ldbl_val.sextOrTrunc(sizeof(sshort_t) * 8)).getSExtValue();
     }
     return fail_value;
 }
 
 unsigned short
 Scalar::UShort(unsigned short 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 *(const ushort_t *)m_integer.getRawData();
+        return (ushort_t)(m_integer.zextOrTrunc(sizeof(ushort_t) * 8)).getZExtValue();
     case e_float:
         return (ushort_t)m_float.convertToFloat();
     case e_double:
         return (ushort_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return *(const ushort_t *)ldbl_val.getRawData();;
+        return (ushort_t)(ldbl_val.zextOrTrunc(sizeof(ushort_t) * 8)).getZExtValue();
     }
     return fail_value;
 }
 
 int
 Scalar::SInt(int 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 *(const sint_t *)(m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getRawData();
+        return (sint_t)(m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
     case e_float:
         return (sint_t)m_float.convertToFloat();
     case e_double:
         return (sint_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return *(const sint_t *)ldbl_val.getRawData();
+        return (sint_t)(ldbl_val.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
     }
     return fail_value;
 }
 
 unsigned int
 Scalar::UInt(unsigned int 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 *(const uint_t *)m_integer.getRawData();
+        return (uint_t)(m_integer.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
     case e_float:
         return (uint_t)m_float.convertToFloat();
     case e_double:
         return (uint_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return *(const uint_t *)ldbl_val.getRawData();
+        return (uint_t)(ldbl_val.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
     }
     return fail_value;
 }
 
 long
 Scalar::SLong(long fail_value) const
 {
     switch (m_type)
     {
     case e_void:        break;
     case e_sint:
     case e_uint:
     case e_slong:
     case e_ulong:
     case e_slonglong:
     case e_ulonglong:
     case e_sint128:
     case e_uint128:
     case e_sint256:
     case e_uint256:
-        return *(const slong_t *)(m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getRawData();
+        return (slong_t)(m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
     case e_float:
         return (slong_t)m_float.convertToFloat();
     case e_double:
         return (slong_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return *(const slong_t *)ldbl_val.getRawData();
+        return (slong_t)(ldbl_val.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
     }
     return fail_value;
 }
 
 unsigned long
 Scalar::ULong(unsigned long 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 *(const ulong_t *)m_integer.getRawData();
+        return (ulong_t)(m_integer.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
     case e_float:
         return (ulong_t)m_float.convertToFloat();
     case e_double:
         return (ulong_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return *(const ulong_t *)ldbl_val.getRawData();
-    }
-    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 (ulong_t)(ldbl_val.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
     }
     return fail_value;
 }
 
 long long
 Scalar::SLongLong(long long 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 *(const slonglong_t *)(m_integer.sextOrTrunc(sizeof(slonglong_t) * 8)).getRawData();
+        return (slonglong_t)(m_integer.sextOrTrunc(sizeof(slonglong_t) * 8)).getSExtValue();
     case e_float:
         return (slonglong_t)m_float.convertToFloat();
     case e_double:
         return (slonglong_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return *(const slonglong_t *)ldbl_val.getRawData();
+        return (slonglong_t)(ldbl_val.sextOrTrunc(sizeof(slonglong_t) * 8)).getSExtValue();
     }
     return fail_value;
 }
 
 unsigned long long
 Scalar::ULongLong(unsigned long long 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 *(const ulonglong_t *)m_integer.getRawData();
+        return (ulonglong_t)(m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue();
     case e_float:
         return (ulonglong_t)m_float.convertToFloat();
     case e_double:
         return (ulonglong_t)m_float.convertToDouble();
     case e_long_double:
         llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return *(const ulonglong_t *)ldbl_val.getRawData();
+        return (ulonglong_t)(ldbl_val.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue();
     }
     return fail_value;
 }
 
 llvm::APInt
 Scalar::SInt128(llvm::APInt& fail_value) const
 {
     switch (m_type)
case e_uint256:
              case e_slong:
              case e_ulong:
              case e_slonglong:
              case e_ulonglong:
              case e_sint128:
              case e_uint128:
              case e_sint256:
              case e_uint256:
-                 m_integer <<= *rhs.m_integer.getRawData();
+                 m_integer = m_integer << rhs.m_integer;
                  break;
         }
         break;
     }
     return *this;
 }
 
 bool
case e_uint256:
         case e_slong:
         case e_ulong:
         case e_slonglong:
         case e_ulonglong:
         case e_sint128:
         case e_uint128:
         case e_sint256:
         case e_uint256:
-            m_integer = m_integer.lshr(*(const uint_t *) rhs.m_integer.getRawData());   break;
+            m_integer = m_integer.lshr(rhs.m_integer);
+            break;
         }
         break;
     }
     return m_type != e_void;
 }
 
 Scalar&
 Scalar::operator>>= (const Scalar& rhs)
case e_uint256:
         case e_slong:
         case e_ulong:
         case e_slonglong:
         case e_ulonglong:
         case e_sint128:
         case e_uint128:
         case e_sint256:
         case e_uint256:
-            m_integer = m_integer.ashr(*(const uint_t *)rhs.m_integer.getRawData());
+            m_integer = m_integer.ashr(rhs.m_integer);
             break;
         }
         break;
     }
     return *this;
 }
 
 Scalar&
lldb_private::operator/ (const Scalar& lhs, const Scalar& rhs)
     const Scalar* a;
     const Scalar* b;
     if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
     {
         switch (result.m_type)
         {
         case Scalar::e_void:            break;
         case Scalar::e_sint:
-        case Scalar::e_uint:
         case Scalar::e_slong:
-        case Scalar::e_ulong:
         case Scalar::e_slonglong:
-        case Scalar::e_ulonglong:
         case Scalar::e_sint128:
-        case Scalar::e_uint128:
         case Scalar::e_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_ulong:
+        case Scalar::e_ulonglong:
+        case Scalar::e_uint128:
         case Scalar::e_uint256:
             if (b->m_integer != 0)
             {
-                result.m_integer = *a->m_integer.getRawData() / *b->m_integer.getRawData();
+                result.m_integer = a->m_integer.udiv(b->m_integer);
                 return result;
             }
             break;
         case Scalar::e_float:
         case Scalar::e_double:
         case Scalar::e_long_double:
             if (b->m_float.isZero())
             {
lldb_private::operator% (const Scalar& lhs, const Scalar& rhs)
     const Scalar* b;
     if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
     {
         switch (result.m_type)
         {
         default:                    break;
              case Scalar::e_void:            break;
              case Scalar::e_sint:
-             case Scalar::e_uint:
              case Scalar::e_slong:
-             case Scalar::e_ulong:
              case Scalar::e_slonglong:
-             case Scalar::e_ulonglong:
              case Scalar::e_sint128:
-             case Scalar::e_uint128:
              case Scalar::e_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_ulong:
+             case Scalar::e_ulonglong:
+             case Scalar::e_uint128:
              case Scalar::e_uint256:
                  if (b->m_integer != 0)
                  {
-                     result.m_integer = *a->m_integer.getRawData() % *b->m_integer.getRawData();
+                     result.m_integer = a->m_integer.urem(b->m_integer);
                      return result;
                  }
                  break;
         }
     }
     result.m_type = Scalar::e_void;
     return result;
 }

 const Scalar
 lldb_private::operator>> (const Scalar& lhs, const Scalar &rhs)
 {
     Scalar result = lhs;
     result >>= 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)
 {
     Error error;
     if (value_str == nullptr || value_str[0] == '\0')
     {
         error.SetErrorString ("Invalid c-string value string.");
         return error;
case lldb::eEncodingUint:
             case 1:  operator=((uint8_t)data.GetU8(&offset)); break;
             case 2:  operator=((uint16_t)data.GetU16(&offset)); break;
             case 4:  operator=((uint32_t)data.GetU32(&offset)); break;
             case 8:  operator=((uint64_t)data.GetU64(&offset)); break;
             case 16:
                 if (data.GetByteOrder() == eByteOrderBig)
                 {
                     int128.x[1] = (uint64_t)data.GetU64 (&offset);
-                    int128.x[0] = (uint64_t)data.GetU64 (&offset + 1);
+                    int128.x[0] = (uint64_t)data.GetU64 (&offset);
                 }
                 else
                 {
                     int128.x[0] = (uint64_t)data.GetU64 (&offset);
-                    int128.x[1] = (uint64_t)data.GetU64 (&offset + 1);
+                    int128.x[1] = (uint64_t)data.GetU64 (&offset);
                 }
                 operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
                 break;
             case 32:
                 if (data.GetByteOrder() == eByteOrderBig)
                 {
                     int256.x[3] = (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);
+                    int256.x[2] = (uint64_t)data.GetU64 (&offset);
+                    int256.x[1] = (uint64_t)data.GetU64 (&offset);
+                    int256.x[0] = (uint64_t)data.GetU64 (&offset);
                 }
                 else
                 {
                     int256.x[0] = (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);
+                    int256.x[1] = (uint64_t)data.GetU64 (&offset);
+                    int256.x[2] = (uint64_t)data.GetU64 (&offset);
+                    int256.x[3] = (uint64_t)data.GetU64 (&offset);
                 }
                 operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
                 break;
             default:
                 error.SetErrorStringWithFormat("unsupported unsigned integer byte size: %" PRIu64 "", (uint64_t)byte_size);
                 break;
             }
         }
         break;
     case lldb::eEncodingSint:
         {
             lldb::offset_t offset = 0;
             
             switch (byte_size)
             {
             case 1: operator=((int8_t)data.GetU8(&offset)); break;
             case 2: operator=((int16_t)data.GetU16(&offset)); break;
             case 4: operator=((int32_t)data.GetU32(&offset)); break;
             case 8: operator=((int64_t)data.GetU64(&offset)); break;
             case 16:
                 if (data.GetByteOrder() == eByteOrderBig)
                 {
                     int128.x[1] = (uint64_t)data.GetU64 (&offset);
-                    int128.x[0] = (uint64_t)data.GetU64 (&offset + 1);
+                    int128.x[0] = (uint64_t)data.GetU64 (&offset);
                 }
                 else
                 {
                     int128.x[0] = (uint64_t)data.GetU64 (&offset);
-                    int128.x[1] = (uint64_t)data.GetU64 (&offset + 1);
+                    int128.x[1] = (uint64_t)data.GetU64 (&offset);
                 }
                 operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
                 break;
             case 32:
                 if (data.GetByteOrder() == eByteOrderBig)
                 {
                     int256.x[3] = (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);
+                    int256.x[2] = (uint64_t)data.GetU64 (&offset);
+                    int256.x[1] = (uint64_t)data.GetU64 (&offset);
+                    int256.x[0] = (uint64_t)data.GetU64 (&offset);
                 }
                 else
                 {
                     int256.x[0] = (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);
+                    int256.x[1] = (uint64_t)data.GetU64 (&offset);
+                    int256.x[2] = (uint64_t)data.GetU64 (&offset);
+                    int256.x[3] = (uint64_t)data.GetU64 (&offset);
                 }
                 operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
                 break;
             default:
                 error.SetErrorStringWithFormat("unsupported signed integer byte size: %" PRIu64 "", (uint64_t)byte_size);
                 break;
             }
         }

 
 bool
 Scalar::ExtractBitfield (uint32_t bit_size, 
                          uint32_t bit_offset)
 {
     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 = SignedBits (*m_integer.getRawData(), msbit, lsbit);
+            m_integer = m_integer.ashr(bit_offset).trunc(bit_size).sext(8 * GetByteSize());
             return true;
 
         case Scalar::e_uint:
         case Scalar::e_ulong:
         case Scalar::e_ulonglong:
         case Scalar::e_uint128:
         case Scalar::e_uint256:
-            m_integer = UnsignedBits (*m_integer.getRawData(), msbit, lsbit);
+            m_integer = m_integer.lshr(bit_offset).trunc(bit_size).zext(8 * GetByteSize());
             return true;
     }
     return false;
 }
 
 bool
 lldb_private::operator== (const Scalar& lhs, const Scalar& rhs)
 {

lldb/trunk/source/Expression/IRInterpreter.cpp

public:
     {
         lldb::addr_t process_address = ResolveValue (value, module);
 
         if (process_address == LLDB_INVALID_ADDRESS)
             return false;
 
         lldb_private::Scalar cast_scalar;
 
-        if (!AssignToMatchType(cast_scalar, scalar.GetRawBits64(0), value->getType()))
+        if (!AssignToMatchType(cast_scalar, scalar.ULongLong(), value->getType()))
             return false;
 
         size_t value_byte_size = m_target_data.getTypeStoreSize(value->getType());
 
         lldb_private::DataBufferHeap buf(value_byte_size, 0);
 
         lldb_private::Error get_data_error;
 
public:
 
     bool ResolveConstant (lldb::addr_t process_address, const Constant *constant)
     {
         APInt resolved_value;
 
         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);
 
-        const uint64_t *raw_data = resolved_value.getRawData();
+        lldb_private::Error get_data_error;
 
-        buffer.PutRawBytes(raw_data, constant_size, lldb_private::endian::InlHostByteOrder());
+        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;
 
         lldb_private::Error write_error;
 
-        m_execution_unit.WriteMemory(process_address, (const uint8_t*)buffer.GetData(), constant_size, write_error);
+        m_execution_unit.WriteMemory(process_address, buf.GetBytes(), buf.GetByteSize(), write_error);
 
         return write_error.Success();
     }
 
     lldb::addr_t Malloc (size_t size, uint8_t byte_alignment)
     {
         lldb::addr_t ret = m_stack_pointer;
 
while (frame.m_ii != frame.m_ie && (++num_insts < 4096))
                         result = L - R;
                         break;
                     case Instruction::SDiv:
                         L.MakeSigned();
                         R.MakeSigned();
                         result = L / R;
                         break;
                     case Instruction::UDiv:
-                        result = L.GetRawBits64(0) / R.GetRawBits64(1);
+                        L.MakeUnsigned();
+                        R.MakeUnsigned();
+                        result = L / R;
                         break;
                     case Instruction::SRem:
                         L.MakeSigned();
                         R.MakeSigned();
                         result = L % R;
                         break;
                     case Instruction::URem:
-                        result = L.GetRawBits64(0) % R.GetRawBits64(1);
+                        L.MakeUnsigned();
+                        R.MakeUnsigned();
+                        result = L % R;
                         break;
                     case Instruction::Shl:
                         result = L << R;
                         break;
                     case Instruction::AShr:
                         result = L >> R;
                         break;
                     case Instruction::LShr:
while (frame.m_ii != frame.m_ie && (++num_insts < 4096))
                     {
                         if (log)
                             log->Printf("Couldn't evaluate %s", PrintValue(condition).c_str());
                         error.SetErrorToGenericError();
                         error.SetErrorString(bad_value_error);
                         return false;
                     }
 
-                    if (C.GetRawBits64(0))
+                    if (!C.IsZero())
                         frame.Jump(br_inst->getSuccessor(0));
                     else
                         frame.Jump(br_inst->getSuccessor(1));
 
                     if (log)
                     {
                         log->Printf("Interpreted a BrInst with a condition");
                         log->Printf("  cond : %s", frame.SummarizeValue(condition).c_str());
while (frame.m_ii != frame.m_ie && (++num_insts < 4096))
                         return false;
                     case CmpInst::ICMP_EQ:
                         result = (L == R);
                         break;
                     case CmpInst::ICMP_NE:
                         result = (L != R);
                         break;
                     case CmpInst::ICMP_UGT:
-                        result = (L.GetRawBits64(0) > R.GetRawBits64(0));
+                        L.MakeUnsigned();
+                        R.MakeUnsigned();
+                        result = (L > R);
                         break;
                     case CmpInst::ICMP_UGE:
-                        result = (L.GetRawBits64(0) >= R.GetRawBits64(0));
+                        L.MakeUnsigned();
+                        R.MakeUnsigned();
+                        result = (L >= R);
                         break;
                     case CmpInst::ICMP_ULT:
-                        result = (L.GetRawBits64(0) < R.GetRawBits64(0));
+                        L.MakeUnsigned();
+                        R.MakeUnsigned();
+                        result = (L < R);
                         break;
                     case CmpInst::ICMP_ULE:
-                        result = (L.GetRawBits64(0) <= R.GetRawBits64(0));
+                        L.MakeUnsigned();
+                        R.MakeUnsigned();
+                        result = (L <= R);
                         break;
                     case CmpInst::ICMP_SGT:
                         L.MakeSigned();
                         R.MakeSigned();
                         result = (L > R);
                         break;
                     case CmpInst::ICMP_SGE:
                         L.MakeSigned();

lldb/trunk/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

IRForTarget::MaterializeInitializer (uint8_t *data, Constant *initializer)
 
     if (log && log->GetVerbose())
         log->Printf("  MaterializeInitializer(%p, %s)", (void *)data, PrintValue(initializer).c_str());
 
     Type *initializer_type = initializer->getType();
 
     if (ConstantInt *int_initializer = dyn_cast<ConstantInt>(initializer))
     {
-        memcpy (data, int_initializer->getValue().getRawData(), m_target_data->getTypeStoreSize(initializer_type));
+        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;
+
         return true;
     }
     else if (ConstantDataArray *array_initializer = dyn_cast<ConstantDataArray>(initializer))
     {
         if (array_initializer->isString())
         {
             std::string array_initializer_string = array_initializer->getAsString();
             memcpy (data, array_initializer_string.c_str(), m_target_data->getTypeStoreSize(initializer_type));

lldb/trunk/source/Symbol/ClangASTContext.cpp

 #include "Plugins/ExpressionParser/Clang/ClangUserExpression.h"
 #include "Plugins/ExpressionParser/Clang/ClangUtilityFunction.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Flags.h"
 #include "lldb/Core/Log.h"
 #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"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangASTImporter.h"
 #include "lldb/Symbol/ClangExternalASTSourceCallbacks.h"
 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
 #include "lldb/Symbol/ClangUtil.h"
if (type)
             
             llvm::StringRef s_sref(s);
             llvm::APFloat ap_float(getASTContext()->getFloatTypeSemantics(qual_type), s_sref);
             
             const uint64_t bit_size = getASTContext()->getTypeSize (qual_type);
             const uint64_t byte_size = bit_size / 8;
             if (dst_size >= byte_size)
             {
-                if (bit_size == sizeof(float)*8)
-                {
-                    float float32 = ap_float.convertToFloat();
-                    ::memcpy (dst, &float32, 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))
                     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;
-                }
-            }
         }
     }
     return 0;
 }
 
 
 
 //----------------------------------------------------------------------

lldb/trunk/unittests/Core/ScalarTest.cpp

 #if defined(_MSC_VER) && (_HAS_EXCEPTIONS == 0)
 // Workaround for MSVC standard library bug, which fails to include <thread> when
 // exceptions are disabled.
 #include <eh.h>
 #endif
 
 #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;
 
 TEST(ScalarTest, RightShiftOperator)
 {
     int a = 0x00001000;
     int b = 0xFFFFFFFF;
     int c = 4;
     Scalar a_scalar(a);
     Scalar b_scalar(b);
     Scalar c_scalar(c);
     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());
+}
+