Revert "[LLDB] Use llvm::APInt and llvm::APFloat in Scalar and RegisterValue"

Reverting as this commit causes an infinite loop.

llvm-svn: 245222

7 files changed, 1393 insertions, 1928 deletions

diff --git a/lldb/include/lldb/Core/RegisterValue.h b/lldb/include/lldb/Core/RegisterValue.h
index 759422873a1..1b1a71a11c5 100644
--- a/lldb/include/lldb/Core/RegisterValue.h
+++ b/lldb/include/lldb/Core/RegisterValue.h
@@ -19,9 +19,8 @@
 #include "lldb/lldb-public.h"
 #include "lldb/lldb-private.h"
 #include "lldb/Host/Endian.h"
-#include "llvm/ADT/APInt.h"
-#include "lldb/Core/Scalar.h"
 
+//#define ENABLE_128_BIT_SUPPORT 1
 namespace lldb_private {
 
     class RegisterValue
@@ -38,7 +37,9 @@ namespace lldb_private {
             eTypeUInt16,
             eTypeUInt32,
             eTypeUInt64,
+#if defined (ENABLE_128_BIT_SUPPORT)
             eTypeUInt128,
+#endif
             eTypeFloat,
             eTypeDouble,
             eTypeLongDouble,
@@ -48,62 +49,63 @@ namespace lldb_private {
         RegisterValue () : 
             m_type (eTypeInvalid)
         {
-            m_scalar = (unsigned long)0;
         }
 
         explicit 
         RegisterValue (uint8_t inst) : 
             m_type (eTypeUInt8)
         {
-            m_scalar = inst;
+            m_data.uint8 = inst;
         }
 
         explicit 
         RegisterValue (uint16_t inst) : 
             m_type (eTypeUInt16)
         {
-            m_scalar = inst;
+            m_data.uint16 = inst;
         }
 
         explicit 
         RegisterValue (uint32_t inst) : 
             m_type (eTypeUInt32)
         {
-            m_scalar = inst;
+            m_data.uint32 = inst;
         }
 
         explicit 
         RegisterValue (uint64_t inst) : 
             m_type (eTypeUInt64)
         {
-            m_scalar = inst;
+            m_data.uint64 = inst;
         }
 
+#if defined (ENABLE_128_BIT_SUPPORT)
         explicit 
-        RegisterValue (llvm::APInt inst) :
+        RegisterValue (__uint128_t inst) : 
             m_type (eTypeUInt128)
         {
-            m_scalar = llvm::APInt(inst);
+            m_data.uint128 = inst;
         }
+#endif        
         explicit 
         RegisterValue (float value) : 
             m_type (eTypeFloat)
         {
-            m_scalar = value;
+            m_data.ieee_float = value;
         }
 
         explicit 
         RegisterValue (double value) : 
             m_type (eTypeDouble)
         {
-            m_scalar = value;
+            m_data.ieee_double = value;
         }
 
         explicit 
         RegisterValue (long double value) : 
             m_type (eTypeLongDouble)
         {
-            m_scalar = value;
+            m_data.ieee_long_double = value;
         }
 
         explicit 
@@ -165,7 +167,7 @@ namespace lldb_private {
             {
                 if (success_ptr)
                     *success_ptr = true;                
-                return m_scalar.UChar(fail_value);
+                return m_data.uint8;
             }
             if (success_ptr)
                 *success_ptr = true;
@@ -181,8 +183,10 @@ namespace lldb_private {
         uint64_t
         GetAsUInt64 (uint64_t fail_value = UINT64_MAX, bool *success_ptr = NULL) const;
 
-        llvm::APInt
-        GetAsUInt128 (llvm::APInt& fail_value, bool *success_ptr = NULL) const;
+#if defined (ENABLE_128_BIT_SUPPORT)
+        __uint128_t
+        GetAsUInt128 (__uint128_t fail_value = ~((__uint128_t)0), bool *success_ptr = NULL) const;
+#endif
 
         float
         GetAsFloat (float fail_value = 0.0f, bool *success_ptr = NULL) const;
@@ -215,92 +219,95 @@ namespace lldb_private {
         operator = (uint8_t uint)
         {
             m_type = eTypeUInt8;
-            m_scalar = uint;
+            m_data.uint8 = uint;
         }
 
         void
         operator = (uint16_t uint)
         {
             m_type = eTypeUInt16;
-            m_scalar = uint;
+            m_data.uint16 = uint;
         }
 
         void
         operator = (uint32_t uint)
         {
             m_type = eTypeUInt32;
-            m_scalar = uint;
+            m_data.uint32 = uint;
         }
 
         void
         operator = (uint64_t uint)
         {
             m_type = eTypeUInt64;
-            m_scalar = uint;
+            m_data.uint64 = uint;
         }
 
+#if defined (ENABLE_128_BIT_SUPPORT)
         void
-        operator = (llvm::APInt uint)
+        operator = (__uint128_t uint)
         {
             m_type = eTypeUInt128;
-            m_scalar = llvm::APInt(uint);
+            m_data.uint128 = uint;
         }
-
+#endif        
         void
         operator = (float f)
         {
             m_type = eTypeFloat;
-            m_scalar = f;
+            m_data.ieee_float = f;
         }
 
         void
         operator = (double f)
         {
             m_type = eTypeDouble;
-            m_scalar = f;
+            m_data.ieee_double = f;
         }
 
         void
         operator = (long double f)
         {
             m_type = eTypeLongDouble;
-            m_scalar = f;
+            m_data.ieee_long_double = f;
         }
 
         void
         SetUInt8 (uint8_t uint)
         {
             m_type = eTypeUInt8;
-            m_scalar = uint;
+            m_data.uint8 = uint;
         }
 
         void
         SetUInt16 (uint16_t uint)
         {
             m_type = eTypeUInt16;
-            m_scalar = uint;
+            m_data.uint16 = uint;
         }
 
         void
         SetUInt32 (uint32_t uint, Type t = eTypeUInt32)
         {
             m_type = t;
-            m_scalar = uint;
+            m_data.uint32 = uint;
         }
 
         void
         SetUInt64 (uint64_t uint, Type t = eTypeUInt64)
         {
             m_type = t;
-            m_scalar = uint;
+            m_data.uint64 = uint;
         }
 
+#if defined (ENABLE_128_BIT_SUPPORT)
         void
-        SetUInt128 (llvm::APInt uint)
+        SetUInt128 (__uint128_t uint)
         {
             m_type = eTypeUInt128;
-            m_scalar = llvm::APInt(uint);
+            m_data.uint128 = uint;
         }
+#endif
         bool
         SetUInt (uint64_t uint, uint32_t byte_size);
     
@@ -308,21 +315,21 @@ namespace lldb_private {
         SetFloat (float f)
         {
             m_type = eTypeFloat;
-            m_scalar = f;
+            m_data.ieee_float = f;
         }
 
         void
         SetDouble (double f)
         {
             m_type = eTypeDouble;
-            m_scalar = f;
+            m_data.ieee_double = f;
         }
 
         void
         SetLongDouble (long double f)
         {
             m_type = eTypeLongDouble;
-            m_scalar = f;
+            m_data.ieee_long_double = f;
         }
 
         void
@@ -360,7 +367,7 @@ namespace lldb_private {
         GetByteOrder () const
         {
             if (m_type == eTypeBytes)
-                return buffer.byte_order;
+                return m_data.buffer.byte_order;
             return lldb::endian::InlHostByteOrder();
         }
         
@@ -379,13 +386,25 @@ namespace lldb_private {
     protected:
 
         RegisterValue::Type m_type;
-        Scalar m_scalar;
-        struct
-        {
-            uint8_t bytes[kMaxRegisterByteSize]; // This must be big enough to hold any register for any supported target.
-            uint8_t length;
-            lldb::ByteOrder byte_order;
-        } buffer;
+        union
+        {
+            uint8_t  uint8;
+            uint16_t uint16;
+            uint32_t uint32;
+            uint64_t uint64;
+#if defined (ENABLE_128_BIT_SUPPORT)
+            __uint128_t uint128;
+#endif
+            float ieee_float;
+            double ieee_double;
+            long double ieee_long_double;
+            struct 
+            {
+                uint8_t bytes[kMaxRegisterByteSize]; // This must be big enough to hold any register for any supported target.
+                uint8_t length;
+                lldb::ByteOrder byte_order;
+            } buffer;
+        } m_data;
     };
 
 } // namespace lldb_private
diff --git a/lldb/include/lldb/Core/Scalar.h b/lldb/include/lldb/Core/Scalar.h
index f917ec89ebb..821a0fb1ae2 100644
--- a/lldb/include/lldb/Core/Scalar.h
+++ b/lldb/include/lldb/Core/Scalar.h
@@ -11,11 +11,6 @@
 #define liblldb_Scalar_h_
 
 #include "lldb/lldb-private.h"
-#include "llvm/ADT/APInt.h"
-#include "llvm/ADT/APFloat.h"
-
-#define NUM_OF_WORDS_INT128 2
-#define BITWIDTH_INT128 128
 
 namespace lldb_private {
 
@@ -39,60 +34,22 @@ public:
         e_ulonglong,
         e_float,
         e_double,
-        e_long_double,
-        e_uint128,
-        e_sint128
+        e_long_double
     };
 
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
     Scalar();
-    Scalar(int v)               : m_type(e_sint),        m_float((float)0) { m_integer = llvm::APInt(sizeof(int) * 8, v, true);}
-    Scalar(unsigned int v)      : m_type(e_uint),        m_float((float)0) { m_integer = llvm::APInt(sizeof(int) * 8, v);}
-    Scalar(long v)              : m_type(e_slong),       m_float((float)0) { m_integer = llvm::APInt(sizeof(long) * 8, v, true);}
-    Scalar(unsigned long v)     : m_type(e_ulong),       m_float((float)0) { m_integer = llvm::APInt(sizeof(long) * 8, v);}
-    Scalar(long long v)         : m_type(e_slonglong),   m_float((float)0) { m_integer = llvm::APInt(sizeof(long long) * 8, v, true);}
-    Scalar(unsigned long long v): m_type(e_ulonglong),   m_float((float)0) { m_integer = llvm::APInt(sizeof(long long) * 8, v);}
-    Scalar(float v)             : m_type(e_float),       m_float(v) { m_float   = llvm::APFloat(v); }
-    Scalar(double v)            : m_type(e_double),      m_float(v) { m_float   = llvm::APFloat(v); }
-    Scalar(long double v, bool ieee_quad)
-        : m_type(e_long_double), m_float((float)0), m_ieee_quad(ieee_quad)
-        {
-            if(ieee_quad)
-                m_float = llvm::APFloat(llvm::APFloat::IEEEquad, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
-            else
-                m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
-        }
-    Scalar(llvm::APInt v) :
-        m_type(),
-        m_float((float)0)
-        {
-            m_integer = llvm::APInt(v);
-            switch(m_integer.getBitWidth())
-            {
-            case 8:
-            case 16:
-            case 32:
-                if(m_integer.isSignedIntN(sizeof(sint_t) * 8))
-                    m_type = e_sint;
-                else
-                    m_type = e_uint;
-                break;
-            case 64:
-                if(m_integer.isSignedIntN(sizeof(slonglong_t) * 8))
-                    m_type = e_slonglong;
-                else
-                    m_type = e_ulonglong;
-                break;
-            case 128:
-                if(m_integer.isSignedIntN(BITWIDTH_INT128))
-                    m_type = e_sint128;
-                else
-                    m_type = e_uint128;
-                break;
-            }
-        }
+    Scalar(int v)               : m_type(e_sint),           m_data() { m_data.sint      = v; }
+    Scalar(unsigned int v)      : m_type(e_uint),           m_data() { m_data.uint      = v; }
+    Scalar(long v)              : m_type(e_slong),          m_data() { m_data.slong     = v; }
+    Scalar(unsigned long v)     : m_type(e_ulong),          m_data() { m_data.ulong     = v; }
+    Scalar(long long v)         : m_type(e_slonglong),      m_data() { m_data.slonglong = v; }
+    Scalar(unsigned long long v): m_type(e_ulonglong),      m_data() { m_data.ulonglong = v; }
+    Scalar(float v)             : m_type(e_float),          m_data() { m_data.flt       = v; }
+    Scalar(double v)            : m_type(e_double),         m_data() { m_data.dbl       = v; }
+    Scalar(long double v)       : m_type(e_long_double),    m_data() { m_data.ldbl      = v; }
     Scalar(const Scalar& rhs);
     //Scalar(const RegisterValue& reg_value);
     virtual ~Scalar();
@@ -104,18 +61,15 @@ public:
     ExtractBitfield (uint32_t bit_size, 
                      uint32_t bit_offset);
 
-    bool
-    SetBit(uint32_t bit);
-
-    bool
-    ClearBit(uint32_t bit);
-
-    void *
-    GetBytes() const;
-
     size_t
     GetByteSize() const;
 
+    static size_t
+    GetMaxByteSize()
+    {
+        return sizeof(ValueData);
+    }
+
     bool
     GetData (DataExtractor &data, size_t limit_byte_size = UINT32_MAX) const;
 
@@ -129,7 +83,7 @@ public:
     IsZero() const;
 
     void
-    Clear() { m_type = e_void; m_integer.clearAllBits(); }
+    Clear() { m_type = e_void; m_data.ulonglong = 0; }
 
     const char *
     GetTypeAsCString() const;
@@ -179,7 +133,6 @@ public:
     Scalar& operator= (float v);
     Scalar& operator= (double v);
     Scalar& operator= (long double v);
-    Scalar& operator= (llvm::APInt v);
     Scalar& operator= (const Scalar& rhs);      // Assignment operator
     Scalar& operator+= (const Scalar& rhs);
     Scalar& operator<<= (const Scalar& rhs);    // Shift left
@@ -221,9 +174,6 @@ public:
     Scalar::Type
     GetType() const { return m_type; }
 
-    void
-    SetType(const RegisterInfo*);
-
     //----------------------------------------------------------------------
     // Returns a casted value of the current contained data without
     // modifying the current value. FAIL_VALUE will be returned if the type
@@ -244,18 +194,6 @@ public:
     unsigned long long
     RawULongLong () const;
 
-    unsigned char
-    UChar(unsigned char fail_value = 0) const;
-
-    char
-    SChar(char fail_value = 0) const;
-
-    unsigned short
-    UShort(unsigned short fail_value = 0) const;
-
-    short
-    SShort(short fail_value = 0) const;
-
     unsigned int
     UInt(unsigned int fail_value = 0) const;
 
@@ -271,12 +209,6 @@ public:
     unsigned long long
     ULongLong(unsigned long long fail_value = 0) const;
 
-    llvm::APInt
-    SInt128(llvm::APInt& fail_value) const;
-
-    llvm::APInt
-    UInt128(llvm::APInt& fail_value) const;
-
     float
     Float(float fail_value = 0.0f) const;
 
@@ -323,10 +255,6 @@ public:
     }
 
 protected:
-    typedef char                schar_t;
-    typedef unsigned char       uchar_t;
-    typedef short               sshort_t;
-    typedef unsigned short      ushort_t;
     typedef int                 sint_t;
     typedef unsigned int        uint_t;
     typedef long                slong_t;
@@ -337,13 +265,24 @@ protected:
     typedef double              double_t;
     typedef long double         long_double_t;
     
+    union ValueData
+    {
+        int                 sint;
+        unsigned int        uint;
+        long                slong;
+        unsigned long       ulong;
+        long long           slonglong;
+        unsigned long long  ulonglong;
+        float               flt;
+        double              dbl;
+        long double         ldbl;
+    };
+
     //------------------------------------------------------------------
     // Classes that inherit from Scalar can see and modify these
     //------------------------------------------------------------------
     Scalar::Type m_type;
-    llvm::APInt m_integer;
-    llvm::APFloat m_float;
-    bool m_ieee_quad = false;
+    ValueData m_data;
 
 private:
     friend const Scalar operator+   (const Scalar& lhs, const Scalar& rhs);
diff --git a/lldb/include/lldb/Core/Value.h b/lldb/include/lldb/Core/Value.h
index 57f8de4348a..99cd50b26b6 100644
--- a/lldb/include/lldb/Core/Value.h
+++ b/lldb/include/lldb/Core/Value.h
@@ -101,7 +101,6 @@ public:
         // Casts a vector, if valid, to an unsigned int of matching or largest supported size.
         // Truncates to the beginning of the vector if required.
         // Returns a default constructed Scalar if the Vector data is internally inconsistent.
-        llvm::APInt rhs = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)bytes)->x);
         Scalar 
 		GetAsScalar() const 
 		{
@@ -112,7 +111,11 @@ public:
                 else if (length == 2) scalar = *(const uint16_t *)bytes;
                 else if (length == 4) scalar = *(const uint32_t *)bytes;
                 else if (length == 8) scalar = *(const uint64_t *)bytes;
-                else if (length >= 16) scalar = rhs;
+#if defined (ENABLE_128_BIT_SUPPORT)
+                else if (length >= 16) scalar = *(const __uint128_t *)bytes;
+#else
+                else if (length >= 16) scalar = *(const uint64_t *)bytes;
+#endif
             }
             return scalar;
         }
diff --git a/lldb/include/lldb/lldb-private-types.h b/lldb/include/lldb/lldb-private-types.h
index 21811c315ad..cce637fce27 100644
--- a/lldb/include/lldb/lldb-private-types.h
+++ b/lldb/include/lldb/lldb-private-types.h
@@ -102,8 +102,6 @@ namespace lldb_private
                                                  // pass it.
     };
 
-    typedef struct type128 { uint64_t x[2]; } type128;
-
 } // namespace lldb_private
 
 #endif  // #if defined(__cplusplus)
diff --git a/lldb/source/Core/RegisterValue.cpp b/lldb/source/Core/RegisterValue.cpp
index 87e463d194b..a1e9e4e92b5 100644
--- a/lldb/source/Core/RegisterValue.cpp
+++ b/lldb/source/Core/RegisterValue.cpp
@@ -215,10 +215,10 @@ RegisterValue::SetFromMemoryData (const RegisterInfo *reg_info,
     }
     else if (value_type == eTypeBytes)
     {
-        buffer.byte_order = src_byte_order;
+        m_data.buffer.byte_order = src_byte_order;
         // Make sure to set the buffer length of the destination buffer to avoid
-        // problems due to uninitalized variables.
-        buffer.length = src_len;
+        // problems due to uninitialized variables.
+        m_data.buffer.length = src_len;
     }
 
     const uint32_t bytes_copied = src_data.CopyByteOrderedData (0,               // src offset
@@ -240,23 +240,25 @@ RegisterValue::GetScalarValue (Scalar &scalar) const
         case eTypeInvalid:      break;
         case eTypeBytes:
         {
-            switch (buffer.length)
+            switch (m_data.buffer.length)
             {
             default:    break;
-            case 1:     scalar = *(const uint8_t *)buffer.bytes; return true;
-            case 2:     scalar = *(const uint16_t *)buffer.bytes; return true;
-            case 4:     scalar = *(const uint32_t *)buffer.bytes; return true;
-            case 8:     scalar = *(const uint64_t *)buffer.bytes; return true;
+            case 1:     scalar = m_data.uint8; return true;
+            case 2:     scalar = m_data.uint16; return true;
+            case 4:     scalar = m_data.uint32; return true;
+            case 8:     scalar = m_data.uint64; return true;
             }
         }
-        case eTypeUInt8:
-        case eTypeUInt16:
-        case eTypeUInt32:
-        case eTypeUInt64:
-        case eTypeUInt128:
-        case eTypeFloat:
-        case eTypeDouble:
-        case eTypeLongDouble:   scalar = m_scalar; return true;
+        case eTypeUInt8:        scalar = m_data.uint8; return true;
+        case eTypeUInt16:       scalar = m_data.uint16; return true;
+        case eTypeUInt32:       scalar = m_data.uint32; return true;
+        case eTypeUInt64:       scalar = m_data.uint64; return true;
+#if defined (ENABLE_128_BIT_SUPPORT)
+        case eTypeUInt128:      break;
+#endif
+        case eTypeFloat:        scalar = m_data.ieee_float; return true;
+        case eTypeDouble:       scalar = m_data.ieee_double; return true;
+        case eTypeLongDouble:   scalar = m_data.ieee_long_double; return true;
     }
     return false;
 }
@@ -287,8 +289,10 @@ RegisterValue::SetType (const RegisterInfo *reg_info)
                 m_type = eTypeUInt32;
             else if (byte_size <= 8)
                 m_type = eTypeUInt64;
+#if defined (ENABLE_128_BIT_SUPPORT)
             else if (byte_size <= 16)
                 m_type = eTypeUInt128;
+#endif
             break;
 
         case eEncodingIEEE754:
@@ -304,7 +308,6 @@ RegisterValue::SetType (const RegisterInfo *reg_info)
             m_type = eTypeBytes;
             break;
     }
-    m_scalar.SetType(reg_info);
     return m_type;
 }
 
@@ -339,9 +342,8 @@ RegisterValue::SetValueFromData (const RegisterInfo *reg_info, DataExtractor &sr
         src_len = reg_info->byte_size;
 
     // Zero out the value in case we get partial data...
-    memset (buffer.bytes, 0, sizeof (buffer.bytes));
-
-    type128 int128;
+    memset (m_data.buffer.bytes, 0, sizeof (m_data.buffer.bytes));
+    
     switch (SetType (reg_info))
     {
         case eTypeInvalid:
@@ -351,36 +353,33 @@ RegisterValue::SetValueFromData (const RegisterInfo *reg_info, DataExtractor &sr
         case eTypeUInt16:   SetUInt16 (src.GetMaxU32 (&src_offset, src_len)); break;
         case eTypeUInt32:   SetUInt32 (src.GetMaxU32 (&src_offset, src_len)); break;
         case eTypeUInt64:   SetUInt64 (src.GetMaxU64 (&src_offset, src_len)); break;
+#if defined (ENABLE_128_BIT_SUPPORT)
         case eTypeUInt128:
             {
+                __uint128_t data1 = src.GetU64 (&src_offset);
+                __uint128_t data2 = src.GetU64 (&src_offset);
                 if (src.GetByteSize() == eByteOrderBig)
-                {
-                    int128.x[1] = src.GetU64 (&src_offset + 1);
-                    int128.x[0] = src.GetU64 (&src_offset);
-                }
+                    SetUInt128 (data1 << 64 + data2);
                 else
-                {
-                    int128.x[0] = src.GetU64 (&src_offset);
-                    int128.x[1] = src.GetU64 (&src_offset + 1);
-                }
-                SetUInt128 (llvm::APInt(128, 2, int128.x));
+                    SetUInt128 (data2 << 64 + data1);
             }
             break;
+#endif
         case eTypeFloat:        SetFloat (src.GetFloat (&src_offset));      break;
         case eTypeDouble:       SetDouble(src.GetDouble (&src_offset));     break;
         case eTypeLongDouble:   SetFloat (src.GetLongDouble (&src_offset)); break;
         case eTypeBytes:
         {
-            buffer.length = reg_info->byte_size;
-            buffer.byte_order = src.GetByteOrder();
-            assert (buffer.length <= kMaxRegisterByteSize);
-            if (buffer.length > kMaxRegisterByteSize)
-                buffer.length = kMaxRegisterByteSize;
+            m_data.buffer.length = reg_info->byte_size;
+            m_data.buffer.byte_order = src.GetByteOrder();
+            assert (m_data.buffer.length <= kMaxRegisterByteSize);
+            if (m_data.buffer.length > kMaxRegisterByteSize)
+                m_data.buffer.length = kMaxRegisterByteSize;
             if (src.CopyByteOrderedData (src_offset,                    // offset within "src" to start extracting data
                                          src_len,                       // src length
-                                         buffer.bytes,           // dst buffer
-                                         buffer.length,          // dst length
-                                         buffer.byte_order) == 0)// dst byte order
+                                         m_data.buffer.bytes,           // dst buffer
+                                         m_data.buffer.length,          // dst length
+                                         m_data.buffer.byte_order) == 0)// dst byte order
             {
                 error.SetErrorString ("data copy failed data.");
                 return error;
@@ -460,9 +459,6 @@ RegisterValue::SetValueFromCString (const RegisterInfo *reg_info, const char *va
     }
     bool success = false;
     const uint32_t byte_size = reg_info->byte_size;
-    static float flt_val;
-    static double dbl_val;
-    static long double ldbl_val;
     switch (reg_info->encoding)
     {
         case eEncodingInvalid:
@@ -514,31 +510,22 @@ RegisterValue::SetValueFromCString (const RegisterInfo *reg_info, const char *va
         case eEncodingIEEE754:
             if (byte_size == sizeof (float))
             {
-                if (::sscanf (value_str, "%f", &flt_val) == 1)
-                {
-                    m_scalar = flt_val;
+                if (::sscanf (value_str, "%f", &m_data.ieee_float) == 1)
                     m_type = eTypeFloat;
-                }
                 else
                     error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
             }
             else if (byte_size == sizeof (double))
             {
-                if (::sscanf (value_str, "%lf", &dbl_val) == 1)
-                {
-                    m_scalar = dbl_val;
+                if (::sscanf (value_str, "%lf", &m_data.ieee_double) == 1)
                     m_type = eTypeDouble;
-                }
                 else
                     error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
             }
             else if (byte_size == sizeof (long double))
             {
-                if (::sscanf (value_str, "%Lf", &ldbl_val) == 1)
-                {
-                    m_scalar = ldbl_val;
+                if (::sscanf (value_str, "%Lf", &m_data.ieee_long_double) == 1)
                     m_type = eTypeLongDouble;
-                }
                 else
                     error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
             }
@@ -570,11 +557,81 @@ RegisterValue::SignExtend (uint32_t sign_bitpos)
             break;
 
         case eTypeUInt8:        
+            if (sign_bitpos == (8-1))
+                return true;
+            else if (sign_bitpos < (8-1))
+            {
+                uint8_t sign_bit = 1u << sign_bitpos;
+                if (m_data.uint8 & sign_bit)
+                {
+                    const uint8_t mask = ~(sign_bit) + 1u;
+                    m_data.uint8 |= mask;
+                }
+                return true;
+            }
+            break;
+
         case eTypeUInt16:
+            if (sign_bitpos == (16-1))
+                return true;
+            else if (sign_bitpos < (16-1))
+            {
+                uint16_t sign_bit = 1u << sign_bitpos;
+                if (m_data.uint16 & sign_bit)
+                {
+                    const uint16_t mask = ~(sign_bit) + 1u;
+                    m_data.uint16 |= mask;
+                }
+                return true;
+            }
+            break;
+        
         case eTypeUInt32:
+            if (sign_bitpos == (32-1))
+                return true;
+            else if (sign_bitpos < (32-1))
+            {
+                uint32_t sign_bit = 1u << sign_bitpos;
+                if (m_data.uint32 & sign_bit)
+                {
+                    const uint32_t mask = ~(sign_bit) + 1u;
+                    m_data.uint32 |= mask;
+                }
+                return true;
+            }
+            break;
+
         case eTypeUInt64:
+            if (sign_bitpos == (64-1))
+                return true;
+            else if (sign_bitpos < (64-1))
+            {
+                uint64_t sign_bit = 1ull << sign_bitpos;
+                if (m_data.uint64 & sign_bit)
+                {
+                    const uint64_t mask = ~(sign_bit) + 1ull;
+                    m_data.uint64 |= mask;
+                }
+                return true;
+            }
+            break;
+
+#if defined (ENABLE_128_BIT_SUPPORT)
         case eTypeUInt128:
-            return m_scalar.SignExtend(sign_bitpos);
+            if (sign_bitpos == (128-1))
+                return true;
+            else if (sign_bitpos < (128-1))
+            {
+                __uint128_t sign_bit = (__uint128_t)1u << sign_bitpos;
+                if (m_data.uint128 & sign_bit)
+                {
+                    const uint128_t mask = ~(sign_bit) + 1u;
+                    m_data.uint128 |= mask;
+                }
+                return true;
+            }
+            break;
+#endif
         case eTypeFloat:
         case eTypeDouble:
         case eTypeLongDouble:
@@ -592,19 +649,21 @@ RegisterValue::CopyValue (const RegisterValue &rhs)
     {
         case eTypeInvalid: 
             return false;
-        case eTypeUInt8:
-        case eTypeUInt16:
-        case eTypeUInt32:
-        case eTypeUInt64:
-        case eTypeUInt128:
-        case eTypeFloat:
-        case eTypeDouble:
-        case eTypeLongDouble:   m_scalar = rhs.m_scalar; break;
+        case eTypeUInt8:        m_data.uint8 = rhs.m_data.uint8; break;
+        case eTypeUInt16:       m_data.uint16 = rhs.m_data.uint16; break;
+        case eTypeUInt32:       m_data.uint32 = rhs.m_data.uint32; break;
+        case eTypeUInt64:       m_data.uint64 = rhs.m_data.uint64; break;
+#if defined (ENABLE_128_BIT_SUPPORT)
+        case eTypeUInt128:      m_data.uint128 = rhs.m_data.uint128; break;
+#endif
+        case eTypeFloat:        m_data.ieee_float = rhs.m_data.ieee_float; break;
+        case eTypeDouble:       m_data.ieee_double = rhs.m_data.ieee_double; break;
+        case eTypeLongDouble:   m_data.ieee_long_double = rhs.m_data.ieee_long_double; break;
         case eTypeBytes:        
-            assert (rhs.buffer.length <= kMaxRegisterByteSize);
-            ::memcpy (buffer.bytes, rhs.buffer.bytes, kMaxRegisterByteSize);
-            buffer.length = rhs.buffer.length;
-            buffer.byte_order = rhs.buffer.byte_order;
+            assert (rhs.m_data.buffer.length <= kMaxRegisterByteSize);
+            ::memcpy (m_data.buffer.bytes, rhs.m_data.buffer.bytes, kMaxRegisterByteSize);
+            m_data.buffer.length = rhs.m_data.buffer.length;
+            m_data.buffer.byte_order = rhs.m_data.buffer.byte_order;
             break;
     }
     return true;
@@ -619,15 +678,15 @@ RegisterValue::GetAsUInt16 (uint16_t fail_value, bool *success_ptr) const
     switch (m_type)
     {
         default:            break;
-        case eTypeUInt8:
-        case eTypeUInt16:   return m_scalar.UShort(fail_value);
+        case eTypeUInt8:    return m_data.uint8;
+        case eTypeUInt16:   return m_data.uint16;
         case eTypeBytes:
         {
-            switch (buffer.length)
+            switch (m_data.buffer.length)
             {
             default:    break;
-            case 1:
-            case 2:     return *(const uint16_t *)buffer.bytes;
+            case 1:     return m_data.uint8;
+            case 2:     return m_data.uint16;
             }
         }
         break;
@@ -645,20 +704,29 @@ RegisterValue::GetAsUInt32 (uint32_t fail_value, bool *success_ptr) const
     switch (m_type)
     {
         default:            break;
-        case eTypeUInt8:
-        case eTypeUInt16:
-        case eTypeUInt32:
+        case eTypeUInt8:    return m_data.uint8;
+        case eTypeUInt16:   return m_data.uint16;
+        case eTypeUInt32:   return m_data.uint32;
         case eTypeFloat:
+            if (sizeof(float) == sizeof(uint32_t))
+                return m_data.uint32;
+            break;
         case eTypeDouble:
-        case eTypeLongDouble:   return m_scalar.UInt(fail_value);
+            if (sizeof(double) == sizeof(uint32_t))
+                return m_data.uint32;
+            break;
+        case eTypeLongDouble:
+            if (sizeof(long double) == sizeof(uint32_t))
+                return m_data.uint32;
+            break;
         case eTypeBytes:
         {
-            switch (buffer.length)
+            switch (m_data.buffer.length)
             {
             default:    break;
-            case 1:
-            case 2:
-            case 4:     return *(const uint32_t *)buffer.bytes;
+            case 1:     return m_data.uint8;
+            case 2:     return m_data.uint16;
+            case 4:     return m_data.uint32;
             }
         }
         break;
@@ -676,22 +744,31 @@ RegisterValue::GetAsUInt64 (uint64_t fail_value, bool *success_ptr) const
     switch (m_type)
     {
         default:            break;
-        case eTypeUInt8:
-        case eTypeUInt16:
-        case eTypeUInt32:
-        case eTypeUInt64:
+        case eTypeUInt8:    return m_data.uint8;
+        case eTypeUInt16:   return m_data.uint16;
+        case eTypeUInt32:   return m_data.uint32;
+        case eTypeUInt64:   return m_data.uint64;
         case eTypeFloat:
+            if (sizeof(float) == sizeof(uint64_t))
+                return m_data.uint64;
+            break;
         case eTypeDouble:
-        case eTypeLongDouble: return m_scalar.ULongLong(fail_value);
+            if (sizeof(double) == sizeof(uint64_t))
+                return m_data.uint64;
+            break;
+        case eTypeLongDouble:
+            if (sizeof(long double) == sizeof(uint64_t))
+                return m_data.uint64;
+            break;
         case eTypeBytes:
         {
-            switch (buffer.length)
+            switch (m_data.buffer.length)
             {
             default:    break;
-            case 1:
-            case 2:
-            case 4:
-            case 8:     return *(const uint64_t *)buffer.bytes;
+            case 1:     return m_data.uint8;
+            case 2:     return m_data.uint16;
+            case 4:     return m_data.uint32;
+            case 8:     return m_data.uint64;
             }
         }
         break;
@@ -701,36 +778,43 @@ RegisterValue::GetAsUInt64 (uint64_t fail_value, bool *success_ptr) const
     return fail_value;
 }
 
-llvm::APInt
-RegisterValue::GetAsUInt128 (llvm::APInt& fail_value, bool *success_ptr) const
+#if defined (ENABLE_128_BIT_SUPPORT)
+__uint128_t
+RegisterValue::GetAsUInt128 (__uint128_t fail_value, bool *success_ptr) const
 {
     if (success_ptr)
         *success_ptr = true;
     switch (m_type)
     {
         default:            break;
-        case eTypeUInt8:
-        case eTypeUInt16:
-        case eTypeUInt32:
-        case eTypeUInt64:
-        case eTypeUInt128:
+        case eTypeUInt8:    return m_data.uint8;
+        case eTypeUInt16:   return m_data.uint16;
+        case eTypeUInt32:   return m_data.uint32;
+        case eTypeUInt64:   return m_data.uint64;
+        case eTypeUInt128:  return m_data.uint128;
         case eTypeFloat:
+            if (sizeof(float) == sizeof(__uint128_t))
+                return m_data.uint128;
+            break;
         case eTypeDouble:
-        case eTypeLongDouble:  return m_scalar.UInt128(fail_value);
+            if (sizeof(double) == sizeof(__uint128_t))
+                return m_data.uint128;
+            break;
+        case eTypeLongDouble:
+            if (sizeof(long double) == sizeof(__uint128_t))
+                return m_data.uint128;
+            break;
         case eTypeBytes:
         {
-            switch (buffer.length)
+            switch (m_data.buffer.length)
             {
-                default:
-                    break;
-                case 1:
-                case 2:
-                case 4:
-                case 8:
-                case 16:
-                {
-                    return llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)buffer.bytes)->x);
-                }
+            default:
+                break;
+            case 1:     return m_data.uint8;
+            case 2:     return m_data.uint16;
+            case 4:     return m_data.uint32;
+            case 8:     return m_data.uint64;
+            case 16:    return m_data.uint128;
             }
         }
         break;
@@ -739,7 +823,7 @@ RegisterValue::GetAsUInt128 (llvm::APInt& fail_value, bool *success_ptr) const
         *success_ptr = false;
     return fail_value;
 }
-
+#endif
 float
 RegisterValue::GetAsFloat (float fail_value, bool *success_ptr) const
 {
@@ -749,12 +833,28 @@ RegisterValue::GetAsFloat (float fail_value, bool *success_ptr) const
     {
         default:            break;
         case eTypeUInt32:
+            if (sizeof(float) == sizeof(m_data.uint32))
+                return m_data.ieee_float;
+            break;
         case eTypeUInt64:
+            if (sizeof(float) == sizeof(m_data.uint64))
+                return m_data.ieee_float;
+            break;
+#if defined (ENABLE_128_BIT_SUPPORT)
         case eTypeUInt128:
-        case eTypeFloat:
+            if (sizeof(float) == sizeof(m_data.uint128))
+                return m_data.ieee_float;
+            break;
+#endif
+        case eTypeFloat:    return m_data.ieee_float;
         case eTypeDouble:
+            if (sizeof(float) == sizeof(double))
+                return m_data.ieee_float;
+            break;
         case eTypeLongDouble:
-            return m_scalar.Float(fail_value);
+            if (sizeof(float) == sizeof(long double))
+                return m_data.ieee_float;
+            break;
     }
     if (success_ptr)
         *success_ptr = false;
@@ -772,12 +872,27 @@ RegisterValue::GetAsDouble (double fail_value, bool *success_ptr) const
             break;
             
         case eTypeUInt32:
+            if (sizeof(double) == sizeof(m_data.uint32))
+                return m_data.ieee_double;
+            break;
+            
         case eTypeUInt64:
+            if (sizeof(double) == sizeof(m_data.uint64))
+                return m_data.ieee_double;
+            break;
+            
+#if defined (ENABLE_128_BIT_SUPPORT)
         case eTypeUInt128:
-        case eTypeFloat:
-        case eTypeDouble:
+            if (sizeof(double) == sizeof(m_data.uint128))
+                return m_data.ieee_double;
+#endif
+        case eTypeFloat:    return m_data.ieee_float;
+        case eTypeDouble:   return m_data.ieee_double;
+            
         case eTypeLongDouble:
-            return m_scalar.Double(fail_value);
+            if (sizeof(double) == sizeof(long double))
+                return m_data.ieee_double;
+            break;
     }
     if (success_ptr)
         *success_ptr = false;
@@ -795,12 +910,24 @@ RegisterValue::GetAsLongDouble (long double fail_value, bool *success_ptr) const
             break;
             
         case eTypeUInt32:
+            if (sizeof(long double) == sizeof(m_data.uint32))
+                return m_data.ieee_long_double;
+            break;
+            
         case eTypeUInt64:
+            if (sizeof(long double) == sizeof(m_data.uint64))
+                return m_data.ieee_long_double;
+            break;
+            
+#if defined (ENABLE_128_BIT_SUPPORT)
         case eTypeUInt128:
-        case eTypeFloat:
-        case eTypeDouble:
-        case eTypeLongDouble:
-            return m_scalar.LongDouble();
+            if (sizeof(long double) == sizeof(m_data.uint128))
+                return m_data.ieee_long_double;
+#endif
+        case eTypeFloat:        return m_data.ieee_float;
+        case eTypeDouble:       return m_data.ieee_double;
+        case eTypeLongDouble:   return m_data.ieee_long_double;
+            break;
     }
     if (success_ptr)
         *success_ptr = false;
@@ -813,15 +940,17 @@ RegisterValue::GetBytes () const
     switch (m_type)
     {
         case eTypeInvalid:      break;
-        case eTypeUInt8:
-        case eTypeUInt16:
-        case eTypeUInt32:
-        case eTypeUInt64:
-        case eTypeUInt128:
-        case eTypeFloat:
-        case eTypeDouble:
-        case eTypeLongDouble:   return m_scalar.GetBytes();
-        case eTypeBytes:        return buffer.bytes;
+        case eTypeUInt8:        return &m_data.uint8;
+        case eTypeUInt16:       return &m_data.uint16;
+        case eTypeUInt32:       return &m_data.uint32;
+        case eTypeUInt64:       return &m_data.uint64;
+#if defined (ENABLE_128_BIT_SUPPORT)
+        case eTypeUInt128:      return &m_data.uint128;
+#endif
+        case eTypeFloat:        return &m_data.ieee_float;
+        case eTypeDouble:       return &m_data.ieee_double;
+        case eTypeLongDouble:   return &m_data.ieee_long_double;
+        case eTypeBytes:        return m_data.buffer.bytes;
     }
     return NULL;
 }
@@ -832,15 +961,17 @@ RegisterValue::GetBytes ()
     switch (m_type)
     {
         case eTypeInvalid:      break;
-        case eTypeUInt8:
-        case eTypeUInt16:
-        case eTypeUInt32:
-        case eTypeUInt64:
-        case eTypeUInt128:
-        case eTypeFloat:
-        case eTypeDouble:
-        case eTypeLongDouble:   return m_scalar.GetBytes();
-        case eTypeBytes:        return buffer.bytes;
+        case eTypeUInt8:        return &m_data.uint8;
+        case eTypeUInt16:       return &m_data.uint16;
+        case eTypeUInt32:       return &m_data.uint32;
+        case eTypeUInt64:       return &m_data.uint64;
+#if defined (ENABLE_128_BIT_SUPPORT)
+        case eTypeUInt128:      return &m_data.uint128;
+#endif
+        case eTypeFloat:        return &m_data.ieee_float;
+        case eTypeDouble:       return &m_data.ieee_double;
+        case eTypeLongDouble:   return &m_data.ieee_long_double;
+        case eTypeBytes:        return m_data.buffer.bytes;
     }
     return NULL;
 }
@@ -851,15 +982,17 @@ RegisterValue::GetByteSize () const
     switch (m_type)
     {
         case eTypeInvalid: break;
-        case eTypeUInt8:   return 1;
-        case eTypeUInt16:  return 2;
-        case eTypeUInt32:
-        case eTypeUInt64:
-        case eTypeUInt128:
-        case eTypeFloat:
-        case eTypeDouble:
-        case eTypeLongDouble: return m_scalar.GetByteSize();
-        case eTypeBytes: return buffer.length;
+        case eTypeUInt8:        return sizeof(m_data.uint8);
+        case eTypeUInt16:       return sizeof(m_data.uint16);
+        case eTypeUInt32:       return sizeof(m_data.uint32);
+        case eTypeUInt64:       return sizeof(m_data.uint64);
+#if defined (ENABLE_128_BIT_SUPPORT)
+        case eTypeUInt128:      return sizeof(m_data.uint128);
+#endif
+        case eTypeFloat:        return sizeof(m_data.ieee_float);
+        case eTypeDouble:       return sizeof(m_data.ieee_double);
+        case eTypeLongDouble:   return sizeof(m_data.ieee_long_double);
+        case eTypeBytes: return m_data.buffer.length;
     }
     return 0;
 }
@@ -888,10 +1021,12 @@ RegisterValue::SetUInt (uint64_t uint, uint32_t byte_size)
     {
         SetUInt64 (uint);
     }
+#if defined (ENABLE_128_BIT_SUPPORT)
     else if (byte_size <= 16)
     {
-        SetUInt128 (llvm::APInt(64, uint));
+        SetUInt128 (uint);
     }
+#endif
     else
         return false;
     return true;
@@ -901,21 +1036,21 @@ void
 RegisterValue::SetBytes (const void *bytes, size_t length, lldb::ByteOrder byte_order)
 {
     // If this assertion fires off we need to increase the size of
-    // buffer.bytes, or make it something that is allocated on
+    // m_data.buffer.bytes, or make it something that is allocated on
     // the heap. Since the data buffer is in a union, we can't make it
     // a collection class like SmallVector...
     if (bytes && length > 0)
     {
-        assert (length <= sizeof (buffer.bytes) && "Storing too many bytes in a RegisterValue.");
+        assert (length <= sizeof (m_data.buffer.bytes) && "Storing too many bytes in a RegisterValue.");
         m_type = eTypeBytes;
-        buffer.length = length;
-        memcpy (buffer.bytes, bytes, length);
-        buffer.byte_order = byte_order;
+        m_data.buffer.length = length;
+        memcpy (m_data.buffer.bytes, bytes, length);
+        m_data.buffer.byte_order = byte_order;
     }
     else
     {
         m_type = eTypeInvalid;
-        buffer.length = 0;
+        m_data.buffer.length = 0;
     }
 }
 
@@ -928,23 +1063,25 @@ RegisterValue::operator == (const RegisterValue &rhs) const
         switch (m_type)
         {
             case eTypeInvalid:      return true;
-            case eTypeUInt8:
-            case eTypeUInt16:
-            case eTypeUInt32:
-            case eTypeUInt64:
-            case eTypeUInt128:
-            case eTypeFloat:
-            case eTypeDouble:
-            case eTypeLongDouble:   return m_scalar == rhs.m_scalar;
+            case eTypeUInt8:        return m_data.uint8 == rhs.m_data.uint8;
+            case eTypeUInt16:       return m_data.uint16 == rhs.m_data.uint16;
+            case eTypeUInt32:       return m_data.uint32 == rhs.m_data.uint32;
+            case eTypeUInt64:       return m_data.uint64 == rhs.m_data.uint64;
+#if defined (ENABLE_128_BIT_SUPPORT)
+            case eTypeUInt128:      return m_data.uint128 == rhs.m_data.uint128;
+#endif
+            case eTypeFloat:        return m_data.ieee_float == rhs.m_data.ieee_float;
+            case eTypeDouble:       return m_data.ieee_double == rhs.m_data.ieee_double;
+            case eTypeLongDouble:   return m_data.ieee_long_double == rhs.m_data.ieee_long_double;
             case eTypeBytes:        
-                if (buffer.length != rhs.buffer.length)
+                if (m_data.buffer.length != rhs.m_data.buffer.length)
                     return false;
                 else
                 {
-                    uint8_t length = buffer.length;
+                    uint8_t length = m_data.buffer.length;
                     if (length > kMaxRegisterByteSize)
                         length = kMaxRegisterByteSize;
-                    return memcmp (buffer.bytes, rhs.buffer.bytes, length) == 0;
+                    return memcmp (m_data.buffer.bytes, rhs.m_data.buffer.bytes, length) == 0;
                 }
                 break;
         }
@@ -960,25 +1097,27 @@ RegisterValue::operator != (const RegisterValue &rhs) const
     switch (m_type)
     {
         case eTypeInvalid:      return false;
-        case eTypeUInt8:
-        case eTypeUInt16:
-        case eTypeUInt32:
-        case eTypeUInt64:
-        case eTypeUInt128:
-        case eTypeFloat:
-        case eTypeDouble:
-        case eTypeLongDouble:   return m_scalar != rhs.m_scalar;
+        case eTypeUInt8:        return m_data.uint8 != rhs.m_data.uint8;
+        case eTypeUInt16:       return m_data.uint16 != rhs.m_data.uint16;
+        case eTypeUInt32:       return m_data.uint32 != rhs.m_data.uint32;
+        case eTypeUInt64:       return m_data.uint64 != rhs.m_data.uint64;
+#if defined (ENABLE_128_BIT_SUPPORT)
+        case eTypeUInt128:      return m_data.uint128 != rhs.m_data.uint128;
+#endif
+        case eTypeFloat:        return m_data.ieee_float != rhs.m_data.ieee_float;
+        case eTypeDouble:       return m_data.ieee_double != rhs.m_data.ieee_double;
+        case eTypeLongDouble:   return m_data.ieee_long_double != rhs.m_data.ieee_long_double;
         case eTypeBytes:        
-            if (buffer.length != rhs.buffer.length)
+            if (m_data.buffer.length != rhs.m_data.buffer.length)
             {
                 return true;
             }
             else
             {
-                uint8_t length = buffer.length;
+                uint8_t length = m_data.buffer.length;
                 if (length > kMaxRegisterByteSize)
                     length = kMaxRegisterByteSize;
-                return memcmp (buffer.bytes, rhs.buffer.bytes, length) != 0;
+                return memcmp (m_data.buffer.bytes, rhs.m_data.buffer.bytes, length) != 0;
             }
             break;
     }
@@ -993,35 +1132,63 @@ RegisterValue::ClearBit (uint32_t bit)
         case eTypeInvalid:
             break;
 
-        case eTypeUInt8:
+        case eTypeUInt8:        
+            if (bit < 8)
+            {
+                m_data.uint8 &= ~(1u << bit);
+                return true;
+            }
+            break;
+            
         case eTypeUInt16:
+            if (bit < 16)
+            {
+                m_data.uint16 &= ~(1u << bit);
+                return true;
+            }
+            break;
+
         case eTypeUInt32:
+            if (bit < 32)
+            {
+                m_data.uint32 &= ~(1u << bit);
+                return true;
+            }
+            break;
+            
         case eTypeUInt64:
-        case eTypeUInt128:
-            if (bit < (GetByteSize() * 8))
+            if (bit < 64)
             {
-                return m_scalar.ClearBit(bit);
+                m_data.uint64 &= ~(1ull << (uint64_t)bit);
+                return true;
             }
             break;
-
+#if defined (ENABLE_128_BIT_SUPPORT)
+        case eTypeUInt128:
+            if (bit < 64)
+            {
+                m_data.uint128 &= ~((__uint128_t)1ull << (__uint128_t)bit);
+                return true;
+            }
+#endif
         case eTypeFloat:
         case eTypeDouble:
         case eTypeLongDouble:
             break;
 
         case eTypeBytes:
-            if (buffer.byte_order == eByteOrderBig || buffer.byte_order == eByteOrderLittle)
+            if (m_data.buffer.byte_order == eByteOrderBig || m_data.buffer.byte_order == eByteOrderLittle)
             {
                 uint32_t byte_idx;
-                if (buffer.byte_order == eByteOrderBig)
-                    byte_idx = buffer.length - (bit / 8) - 1;
+                if (m_data.buffer.byte_order == eByteOrderBig)
+                    byte_idx = m_data.buffer.length - (bit / 8) - 1;
                 else
                     byte_idx = bit / 8;
 
                 const uint32_t byte_bit = bit % 8;
-                if (byte_idx < buffer.length)
+                if (byte_idx < m_data.buffer.length)
                 {
-                    buffer.bytes[byte_idx] &= ~(1u << byte_bit);
+                    m_data.buffer.bytes[byte_idx] &= ~(1u << byte_bit);
                     return true;
                 }
             }
@@ -1040,34 +1207,62 @@ RegisterValue::SetBit (uint32_t bit)
             break;
             
         case eTypeUInt8:        
+            if (bit < 8)
+            {
+                m_data.uint8 |= (1u << bit);
+                return true;
+            }
+            break;
+            
         case eTypeUInt16:
+            if (bit < 16)
+            {
+                m_data.uint16 |= (1u << bit);
+                return true;
+            }
+            break;
+            
         case eTypeUInt32:
+            if (bit < 32)
+            {
+                m_data.uint32 |= (1u << bit);
+                return true;
+            }
+            break;
+            
         case eTypeUInt64:
-        case eTypeUInt128:
-            if (bit < (GetByteSize() * 8))
+            if (bit < 64)
             {
-                return m_scalar.SetBit(bit);
+                m_data.uint64 |= (1ull << (uint64_t)bit);
+                return true;
             }
             break;
-
+#if defined (ENABLE_128_BIT_SUPPORT)
+        case eTypeUInt128:
+            if (bit < 64)
+            {
+                m_data.uint128 |= ((__uint128_t)1ull << (__uint128_t)bit);
+                return true;
+            }
+#endif
         case eTypeFloat:
         case eTypeDouble:
         case eTypeLongDouble:
             break;
             
         case eTypeBytes:
-            if (buffer.byte_order == eByteOrderBig || buffer.byte_order == eByteOrderLittle)
+            if (m_data.buffer.byte_order == eByteOrderBig || m_data.buffer.byte_order == eByteOrderLittle)
             {
                 uint32_t byte_idx;
-                if (buffer.byte_order == eByteOrderBig)
-                    byte_idx = buffer.length - (bit / 8) - 1;
+                if (m_data.buffer.byte_order == eByteOrderBig)
+                    byte_idx = m_data.buffer.length - (bit / 8) - 1;
                 else
                     byte_idx = bit / 8;
                 
                 const uint32_t byte_bit = bit % 8;
-                if (byte_idx < buffer.length)
+                if (byte_idx < m_data.buffer.length)
                 {
-                    buffer.bytes[byte_idx] |= (1u << byte_bit);
+                    m_data.buffer.bytes[byte_idx] |= (1u << byte_bit);
                     return true;
                 }
             }
diff --git a/lldb/source/Core/Scalar.cpp b/lldb/source/Core/Scalar.cpp
index 2b721ad2743..0022c348bfe 100644
--- a/lldb/source/Core/Scalar.cpp
+++ b/lldb/source/Core/Scalar.cpp
@@ -11,7 +11,6 @@
 
 #include <math.h>
 #include <inttypes.h>
-#include <stdio.h>
 
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Core/Error.h"
@@ -78,7 +77,7 @@ PromoteToMaxType
 //----------------------------------------------------------------------
 Scalar::Scalar() :
     m_type(e_void),
-    m_float((float)0)
+    m_data()
 {
 }
 
@@ -87,8 +86,7 @@ Scalar::Scalar() :
 //----------------------------------------------------------------------
 Scalar::Scalar(const Scalar& rhs) :
     m_type(rhs.m_type),
-    m_integer(rhs.m_integer),
-    m_float(rhs.m_float)
+    m_data(rhs.m_data)  // TODO: verify that for C++ this will correctly copy the union??
 {
 }
 
@@ -137,8 +135,6 @@ bool
 Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const
 {
     size_t byte_size = GetByteSize();
-    static float f_val;
-    static double d_val;
     if (byte_size > 0)
     {
         if (limit_byte_size < byte_size)
@@ -148,98 +144,20 @@ Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const
                 // On little endian systems if we want fewer bytes from the
                 // current type we just specify fewer bytes since the LSByte
                 // is first...
-                switch(m_type)
-                {
-                case e_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:
-                    data.SetData((const uint8_t *)m_integer.getRawData(), limit_byte_size, lldb::endian::InlHostByteOrder());
-                    return true;
-                case e_float:
-                    f_val = m_float.convertToFloat();
-                    data.SetData((uint8_t *)&f_val, limit_byte_size, lldb::endian::InlHostByteOrder());
-                    return true;
-                case e_double:
-                    d_val = m_float.convertToDouble();
-                    data.SetData((uint8_t *)&d_val, limit_byte_size, lldb::endian::InlHostByteOrder());
-                    return true;
-                case e_long_double:
-                    static llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-                    data.SetData((const uint8_t *)ldbl_val.getRawData(), limit_byte_size, lldb::endian::InlHostByteOrder());
-                    return true;
-                }
+                data.SetData((uint8_t*)&m_data, limit_byte_size, lldb::endian::InlHostByteOrder());
             }
             else if (lldb::endian::InlHostByteOrder() == eByteOrderBig)
             {
                 // On big endian systems if we want fewer bytes from the
                 // current type have to advance our initial byte pointer and
                 // trim down the number of bytes since the MSByte is first
-                switch(m_type)
-                {
-                case e_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:
-                    data.SetData((const uint8_t *)m_integer.getRawData() + byte_size - limit_byte_size, limit_byte_size, lldb::endian::InlHostByteOrder());
-                    return true;
-                case e_float:
-                    f_val = m_float.convertToFloat();
-                    data.SetData((uint8_t *)&f_val + byte_size - limit_byte_size, limit_byte_size, lldb::endian::InlHostByteOrder());
-                    return true;
-                case e_double:
-                    d_val = m_float.convertToDouble();
-                    data.SetData((uint8_t *)&d_val + byte_size - limit_byte_size, limit_byte_size, lldb::endian::InlHostByteOrder());
-                    return true;
-                case e_long_double:
-                    static llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-                    data.SetData((const uint8_t *)ldbl_val.getRawData() + byte_size - limit_byte_size, limit_byte_size, lldb::endian::InlHostByteOrder());
-                    return true;
-                }
+                data.SetData(((uint8_t*)&m_data) + byte_size - limit_byte_size, limit_byte_size, lldb::endian::InlHostByteOrder());
             }
         }
         else
         {
             // We want all of the data
-            switch(m_type)
-            {
-            case e_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:
-                data.SetData((const uint8_t *)m_integer.getRawData(), byte_size, lldb::endian::InlHostByteOrder());
-                return true;
-            case e_float:
-                f_val = m_float.convertToFloat();
-                data.SetData((uint8_t *)&f_val, byte_size, lldb::endian::InlHostByteOrder());
-                return true;
-            case e_double:
-                d_val = m_float.convertToDouble();
-                data.SetData((uint8_t *)&d_val, byte_size, lldb::endian::InlHostByteOrder());
-                return true;
-            case e_long_double:
-                static llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-                data.SetData((const uint8_t *)ldbl_val.getRawData(), byte_size, lldb::endian::InlHostByteOrder());
-                return true;
-            }
+            data.SetData((uint8_t*)&m_data, byte_size, lldb::endian::InlHostByteOrder());
         }
         return true;
     }
@@ -247,37 +165,6 @@ Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const
     return false;
 }
 
-void *
-Scalar::GetBytes() const
-{
-    static float_t flt_val;
-    static double_t dbl_val;
-    switch (m_type)
-    {
-    case e_void:
-        break;
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-        return (void *)m_integer.getRawData();
-    case e_float:
-        flt_val = m_float.convertToFloat();
-        return (void *)&flt_val;
-    case e_double:
-        dbl_val = m_float.convertToDouble();
-        return (void *)&dbl_val;
-    case e_long_double:
-        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return (void *)ldbl_val.getRawData();
-    }
-    return NULL;
-}
-
 size_t
 Scalar::GetByteSize() const
 {
@@ -285,17 +172,15 @@ Scalar::GetByteSize() const
     {
     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:      return (m_integer.getBitWidth() / 8);
-    case e_float:       return sizeof(float_t);
-    case e_double:      return sizeof(double_t);
-    case e_long_double: return sizeof(long_double_t);
+    case e_sint:        return sizeof(m_data.sint);
+    case e_uint:        return sizeof(m_data.uint);
+    case e_slong:       return sizeof(m_data.slong);
+    case e_ulong:       return sizeof(m_data.ulong);
+    case e_slonglong:   return sizeof(m_data.slonglong);
+    case e_ulonglong:   return sizeof(m_data.ulonglong);
+    case e_float:       return sizeof(m_data.flt);
+    case e_double:      return sizeof(m_data.dbl);
+    case e_long_double: return sizeof(m_data.ldbl);
     }
     return 0;
 }
@@ -303,24 +188,19 @@ Scalar::GetByteSize() const
 bool
 Scalar::IsZero() const
 {
-    llvm::APInt zero_int = llvm::APInt::getNullValue(m_integer.getBitWidth() / 8);
     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:
-        return llvm::APInt::isSameValue(zero_int, m_integer);
-    case e_float:
-    case e_double:
-    case e_long_double:
-        return m_float.isZero();
+    case e_sint:        return m_data.sint == 0;
+    case e_uint:        return m_data.uint == 0;
+    case e_slong:       return m_data.slong == 0;
+    case e_ulong:       return m_data.ulong == 0;
+    case e_slonglong:   return m_data.slonglong == 0;
+    case e_ulonglong:   return m_data.ulonglong == 0;
+    case e_float:       return m_data.flt == 0.0f;
+    case e_double:      return m_data.dbl == 0.0;
+    case e_long_double: return m_data.ldbl == 0.0;
     }
     return false;
 }
@@ -328,7 +208,6 @@ Scalar::IsZero() const
 void
 Scalar::GetValue (Stream *s, bool show_type) const
 {
-    const uint64_t *src;
     if (show_type)
         s->Printf("(%s) ", GetTypeAsCString());
 
@@ -336,26 +215,15 @@ Scalar::GetValue (Stream *s, bool show_type) const
     {
     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_sint128:
-        src = m_integer.getRawData();
-        s->Printf("%lli%lli", *(const slonglong_t *)src, *(const slonglong_t *)(src + 1));
-        break;
-    case e_uint128:
-        src = m_integer.getRawData();
-        s->Printf("0x%16.16llx%16.16llx", *(const ulonglong_t *)src, *(const ulonglong_t *)(src + 1));
-        break;
-    case e_float:       s->Printf("%f", m_float.convertToFloat());                break;
-    case e_double:      s->Printf("%g", m_float.convertToDouble());                break;
-    case e_long_double:
-        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        s->Printf("%Lg", *(const long_double_t *)ldbl_val.getRawData());
-        break;
+    case e_sint:        s->Printf("%i", m_data.sint);               break;
+    case e_uint:        s->Printf("0x%8.8x", m_data.uint);          break;
+    case e_slong:       s->Printf("%li", m_data.slong);             break;
+    case e_ulong:       s->Printf("0x%8.8lx", m_data.ulong);        break;
+    case e_slonglong:   s->Printf("%lli", m_data.slonglong);        break;
+    case e_ulonglong:   s->Printf("0x%16.16llx", m_data.ulonglong); break;
+    case e_float:       s->Printf("%f", m_data.flt);                break;
+    case e_double:      s->Printf("%g", m_data.dbl);                break;
+    case e_long_double: s->Printf("%Lg", m_data.ldbl);              break;
     }
 }
 
@@ -371,8 +239,6 @@ Scalar::GetTypeAsCString() const
     case e_ulong:       return "unsigned long";
     case e_slonglong:   return "long long";
     case e_ulonglong:   return "unsigned long long";
-    case e_sint128:     return "int128_t";
-    case e_uint128:     return "unsigned int128_t";
     case e_float:       return "float";
     case e_double:      return "double";
     case e_long_double: return "long double";
@@ -391,8 +257,7 @@ Scalar::operator=(const Scalar& rhs)
     if (this != &rhs)
     {
         m_type = rhs.m_type;
-        m_integer = llvm::APInt(rhs.m_integer);
-        m_float = rhs.m_float;
+        ::memcpy (&m_data, &rhs.m_data, sizeof(m_data));
     }
     return *this;
 }
@@ -401,7 +266,7 @@ Scalar&
 Scalar::operator= (const int v)
 {
     m_type = e_sint;
-    m_integer = llvm::APInt(sizeof(int) * 8, v, true);
+    m_data.sint = v;
     return *this;
 }
 
@@ -410,7 +275,7 @@ Scalar&
 Scalar::operator= (unsigned int v)
 {
     m_type = e_uint;
-    m_integer = llvm::APInt(sizeof(int) * 8, v);
+    m_data.uint = v;
     return *this;
 }
 
@@ -418,7 +283,7 @@ Scalar&
 Scalar::operator= (long v)
 {
     m_type = e_slong;
-    m_integer = llvm::APInt(sizeof(long) * 8, v, true);
+    m_data.slong = v;
     return *this;
 }
 
@@ -426,7 +291,7 @@ Scalar&
 Scalar::operator= (unsigned long v)
 {
     m_type = e_ulong;
-    m_integer = llvm::APInt(sizeof(long) * 8, v);
+    m_data.ulong = v;
     return *this;
 }
 
@@ -434,7 +299,7 @@ Scalar&
 Scalar::operator= (long long v)
 {
     m_type = e_slonglong;
-    m_integer = llvm::APInt(sizeof(long) * 8, v, true);
+    m_data.slonglong = v;
     return *this;
 }
 
@@ -442,7 +307,7 @@ Scalar&
 Scalar::operator= (unsigned long long v)
 {
     m_type = e_ulonglong;
-    m_integer = llvm::APInt(sizeof(long long) * 8, v);
+    m_data.ulonglong = v;
     return *this;
 }
 
@@ -450,7 +315,7 @@ Scalar&
 Scalar::operator= (float v)
 {
     m_type = e_float;
-    m_float = llvm::APFloat(v);
+    m_data.flt = v;
     return *this;
 }
 
@@ -458,7 +323,7 @@ Scalar&
 Scalar::operator= (double v)
 {
     m_type = e_double;
-    m_float = llvm::APFloat(v);
+    m_data.dbl = v;
     return *this;
 }
 
@@ -466,40 +331,7 @@ Scalar&
 Scalar::operator= (long double v)
 {
     m_type = e_long_double;
-    if(m_ieee_quad)
-        m_float = llvm::APFloat(llvm::APFloat::IEEEquad, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
-    else
-        m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
-    return *this;
-}
-
-Scalar&
-Scalar::operator= (llvm::APInt rhs)
-{
-    m_integer = llvm::APInt(rhs);
-    switch(m_integer.getBitWidth())
-    {
-        case 8:
-        case 16:
-        case 32:
-            if(m_integer.isSignedIntN(sizeof(sint_t) * 8))
-                m_type = e_sint;
-            else
-                m_type = e_uint;
-            break;
-        case 64:
-            if(m_integer.isSignedIntN(sizeof(slonglong_t) * 8))
-                m_type = e_slonglong;
-            else
-                m_type = e_ulonglong;
-            break;
-        case 128:
-            if(m_integer.isSignedIntN(BITWIDTH_INT128))
-                m_type = e_sint128;
-            else
-                m_type = e_uint128;
-            break;
-    }
+    m_data.ldbl = v;
     return *this;
 }
 
@@ -522,455 +354,128 @@ Scalar::Promote(Scalar::Type type)
     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);
-                success = true;
-                break;
-            }
-            case e_slong:
-            {
-                m_integer = llvm::APInt(sizeof(slong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
-                success = true;
-                break;
-            }
-            case e_ulong:
-            {
-                m_integer = llvm::APInt(sizeof(ulong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
-                success = true;
-                break;
-            }
-            case e_slonglong:
-            {
-                m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
-                success = true;
-                break;
-            }
-            case e_ulonglong:
-            {
-                m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
-                success = true;
-                break;
-            }
-            case e_sint128:
-            case e_uint128:
-            {
-                m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
-                success = true;
-                break;
-            }
-            case e_float:
-            {
-                m_float = llvm::APFloat(m_integer.bitsToFloat());
-                success = true;
-                break;
-            }
-            case e_double:
-            {
-                m_float = llvm::APFloat(m_integer.bitsToDouble());
-                success = true;
-                break;
-            }
-            case e_long_double:
-            {
-                if(m_ieee_quad)
-                    m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
-                else
-                    m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
-                success = true;
-                break;
-            }
+        case e_void:        break;
+        case e_sint:        success = true; break;
+        case e_uint:        m_data.uint         = m_data.sint;      success = true; break;
+        case e_slong:       m_data.slong        = m_data.sint;      success = true; break;
+        case e_ulong:       m_data.ulong        = m_data.sint;      success = true; break;
+        case e_slonglong:   m_data.slonglong    = m_data.sint;      success = true; break;
+        case e_ulonglong:   m_data.ulonglong    = m_data.sint;      success = true; break;
+        case e_float:       m_data.flt          = m_data.sint;      success = true; break;
+        case e_double:      m_data.dbl          = m_data.sint;      success = true; break;
+        case e_long_double: m_data.ldbl         = m_data.sint;      success = true; break;
         }
         break;
 
     case e_uint:
         switch (type)
         {
-             case e_void:
-             case e_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);
-                 success = true;
-                 break;
-             }
-             case e_ulong:
-             {
-                 m_integer = llvm::APInt(sizeof(ulong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
-                 success = true;
-                 break;
-             }
-             case e_slonglong:
-             {
-                 m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
-                 success = true;
-                 break;
-             }
-             case e_ulonglong:
-             {
-                 m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
-                 success = true;
-                 break;
-             }
-             case e_sint128:
-             case e_uint128:
-             {
-                 m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
-                 success = true;
-                 break;
-             }
-             case e_float:
-             {
-                 m_float = llvm::APFloat(m_integer.bitsToFloat());
-                 success = true;
-                 break;
-             }
-             case e_double:
-             {
-                 m_float = llvm::APFloat(m_integer.bitsToDouble());
-                 success = true;
-                 break;
-             }
-             case e_long_double:
-             {
-                 if(m_ieee_quad)
-                     m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
-                 else
-                     m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
-                 success = true;
-                 break;
-             }
+        case e_void:
+        case e_sint:        break;
+        case e_uint:        success = true; break;
+        case e_slong:       m_data.slong        = m_data.uint;      success = true; break;
+        case e_ulong:       m_data.ulong        = m_data.uint;      success = true; break;
+        case e_slonglong:   m_data.slonglong    = m_data.uint;      success = true; break;
+        case e_ulonglong:   m_data.ulonglong    = m_data.uint;      success = true; break;
+        case e_float:       m_data.flt          = m_data.uint;      success = true; break;
+        case e_double:      m_data.dbl          = m_data.uint;      success = true; break;
+        case e_long_double: m_data.ldbl         = m_data.uint;      success = true; break;
         }
         break;
 
     case e_slong:
         switch (type)
         {
-             case e_void:
-             case e_sint:
-             case e_uint:    break;
-             case e_slong:   success = true; break;
-             case e_ulong:
-             {
-                 m_integer = llvm::APInt(sizeof(ulong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
-                 success = true;
-                 break;
-             }
-             case e_slonglong:
-             {
-                 m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
-                 success = true;
-                 break;
-             }
-             case e_ulonglong:
-             {
-                 m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
-                 success = true;
-                 break;
-             }
-             case e_sint128:
-             case e_uint128:
-             {
-                 m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
-                 success = true;
-                 break;
-             }
-             case e_float:
-             {
-                 m_float = llvm::APFloat(m_integer.bitsToFloat());
-                 success = true;
-                 break;
-             }
-             case e_double:
-             {
-                 m_float = llvm::APFloat(m_integer.bitsToDouble());
-                 success = true;
-                 break;
-             }
-             case e_long_double:
-             {
-                 if(m_ieee_quad)
-                     m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
-                 else
-                     m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
-                 success = true;
-                 break;
-             }
+        case e_void:
+        case e_sint:
+        case e_uint:        break;
+        case e_slong:       success = true; break;
+        case e_ulong:       m_data.ulong        = m_data.slong;     success = true; break;
+        case e_slonglong:   m_data.slonglong    = m_data.slong;     success = true; break;
+        case e_ulonglong:   m_data.ulonglong    = m_data.slong;     success = true; break;
+        case e_float:       m_data.flt          = m_data.slong;     success = true; break;
+        case e_double:      m_data.dbl          = m_data.slong;     success = true; break;
+        case e_long_double: m_data.ldbl         = m_data.slong;     success = true; break;
         }
         break;
 
     case e_ulong:
         switch (type)
         {
-             case e_void:
-             case e_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);
-                 success = true;
-                 break;
-             }
-             case e_ulonglong:
-             {
-                 m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
-                 success = true;
-                 break;
-             }
-             case e_sint128:
-             case e_uint128:
-             {
-                 m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
-                 success = true;
-                 break;
-             }
-             case e_float:
-             {
-                 m_float = llvm::APFloat(m_integer.bitsToFloat());
-                 success = true;
-                 break;
-             }
-             case e_double:
-             {
-                 m_float = llvm::APFloat(m_integer.bitsToDouble());
-                 success = true;
-                 break;
-             }
-             case e_long_double:
-             {
-                 if(m_ieee_quad)
-                     m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
-                 else
-                     m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
-                 success = true;
-                 break;
-             }
+        case e_void:
+        case e_sint:
+        case e_uint:
+        case e_slong:       break;
+        case e_ulong:       success = true; break;
+        case e_slonglong:   m_data.slonglong    = m_data.ulong;     success = true; break;
+        case e_ulonglong:   m_data.ulonglong    = m_data.ulong;     success = true; break;
+        case e_float:       m_data.flt          = m_data.ulong;     success = true; break;
+        case e_double:      m_data.dbl          = m_data.ulong;     success = true; break;
+        case e_long_double: m_data.ldbl         = m_data.ulong;     success = true; break;
         }
         break;
 
     case e_slonglong:
         switch (type)
         {
-             case e_void:
-             case e_sint:
-             case e_uint:
-             case e_slong:
-             case e_ulong:        break;
-             case e_slonglong:    success = true; break;
-             case e_ulonglong:
-             {
-                 m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
-                 success = true;
-                 break;
-             }
-             case e_sint128:
-             case e_uint128:
-             {
-                 m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
-                 success = true;
-                 break;
-             }
-             case e_float:
-             {
-                 m_float = llvm::APFloat(m_integer.bitsToFloat());
-                 success = true;
-                 break;
-             }
-             case e_double:
-             {
-                 m_float = llvm::APFloat(m_integer.bitsToDouble());
-                 success = true;
-                 break;
-             }
-             case e_long_double:
-             {
-                 if(m_ieee_quad)
-                     m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
-                 else
-                     m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
-                 success = true;
-                 break;
-             }
+        case e_void:
+        case e_sint:
+        case e_uint:
+        case e_slong:
+        case e_ulong:       break;
+        case e_slonglong:   success = true; break;
+        case e_ulonglong:   m_data.ulonglong    = m_data.slonglong;     success = true; break;
+        case e_float:       m_data.flt          = m_data.slonglong;     success = true; break;
+        case e_double:      m_data.dbl          = m_data.slonglong;     success = true; break;
+        case e_long_double: m_data.ldbl         = m_data.slonglong;     success = true; break;
         }
         break;
 
     case e_ulonglong:
         switch (type)
         {
-             case e_void:
-             case e_sint:
-             case e_uint:
-             case e_slong:
-             case e_ulong:
-             case e_slonglong:    break;
-             case e_ulonglong:    success = true; break;
-             case e_sint128:
-             case e_uint128:
-             {
-                 m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
-                 success = true;
-                 break;
-             }
-             case e_float:
-             {
-                 m_float = llvm::APFloat(m_integer.bitsToFloat());
-                 success = true;
-                 break;
-             }
-             case e_double:
-             {
-                 m_float = llvm::APFloat(m_integer.bitsToDouble());
-                 success = true;
-                 break;
-             }
-             case e_long_double:
-             {
-                 if(m_ieee_quad)
-                     m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
-                 else
-                     m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
-                 success = true;
-                 break;
-             }
-        }
-        break;
-
-    case e_sint128:
-        switch (type)
-        {
-             case e_void:
-             case e_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()));
-                 success = true;
-                 break;
-             }
-             case e_float:
-             {
-                 m_float = llvm::APFloat(m_integer.bitsToFloat());
-                 success = true;
-                 break;
-             }
-             case e_double:
-             {
-                 m_float = llvm::APFloat(m_integer.bitsToDouble());
-                 success = true;
-                 break;
-             }
-             case e_long_double:
-             {
-                 if(m_ieee_quad)
-                     m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
-                 else
-                     m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
-                 success = true;
-                 break;
-             }
-        }
-        break;
-
-    case e_uint128:
-        switch (type)
-        {
-             case e_void:
-             case e_sint:
-             case e_uint:
-             case e_slong:
-             case e_ulong:
-             case e_slonglong:
-             case e_ulonglong:
-             case e_sint128:    break;
-             case e_uint128:    success = true; break;
-             case e_float:
-             {
-                 m_float = llvm::APFloat(m_integer.bitsToFloat());
-                 success = true;
-                 break;
-             }
-             case e_double:
-             {
-                 m_float = llvm::APFloat(m_integer.bitsToDouble());
-                 success = true;
-                 break;
-             }
-             case e_long_double:
-             {
-                 if(m_ieee_quad)
-                     m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
-                 else
-                     m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
-                 success = true;
-                 break;
-             }
+        case e_void:
+        case e_sint:
+        case e_uint:
+        case e_slong:
+        case e_ulong:
+        case e_slonglong:   break;
+        case e_ulonglong:   success = true; break;
+        case e_float:       m_data.flt          = m_data.ulonglong;     success = true; break;
+        case e_double:      m_data.dbl          = m_data.ulonglong;     success = true; break;
+        case e_long_double: m_data.ldbl         = m_data.ulonglong;     success = true; break;
         }
         break;
 
     case e_float:
         switch (type)
         {
-             case e_void:
-             case e_sint:
-             case e_uint:
-             case e_slong:
-             case e_ulong:
-             case e_slonglong:
-             case e_ulonglong:
-             case e_sint128:
-             case e_uint128:    break;
-             case e_float:      success = true; break;
-             case e_double:
-             {
-                 m_float = llvm::APFloat((float_t)m_float.convertToFloat());
-                 success = true;
-                 break;
-             }
-             case e_long_double:
-             {
-                 if(m_ieee_quad)
-                     m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_float.bitcastToAPInt());
-                 else
-                     m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_float.bitcastToAPInt());
-                 success = true;
-                 break;
-             }
+        case e_void:
+        case e_sint:
+        case e_uint:
+        case e_slong:
+        case e_ulong:
+        case e_slonglong:
+        case e_ulonglong:   break;
+        case e_float:       success = true; break;
+        case e_double:      m_data.dbl          = m_data.flt;           success = true; break;
+        case e_long_double: m_data.ldbl         = m_data.ulonglong;     success = true; break;
         }
         break;
 
     case e_double:
         switch (type)
         {
-             case e_void:
-             case e_sint:
-             case e_uint:
-             case e_slong:
-             case e_ulong:
-             case e_slonglong:
-             case e_ulonglong:
-             case e_sint128:
-             case e_uint128:
-             case e_float:      break;
-             case e_double:     success = true; break;
-             case e_long_double:
-             {
-                 if(m_ieee_quad)
-                     m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_float.bitcastToAPInt());
-                 else
-                     m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_float.bitcastToAPInt());
-                 success = true;
-                 break;
-             }
+        case e_void:
+        case e_sint:
+        case e_uint:
+        case e_slong:
+        case e_ulong:
+        case e_slonglong:
+        case e_ulonglong:
+        case e_float:       break;
+        case e_double:      success = true; break;
+        case e_long_double: m_data.ldbl         = m_data.dbl;       success = true; break;
         }
         break;
 
@@ -984,8 +489,6 @@ Scalar::Promote(Scalar::Type type)
         case e_ulong:
         case e_slonglong:
         case e_ulonglong:
-        case e_sint128:
-        case e_uint128:
         case e_float:
         case e_double:      break;
         case e_long_double: success = true; break;
@@ -1013,8 +516,6 @@ Scalar::GetValueTypeAsCString (Scalar::Type type)
     case e_float:       return "float";
     case e_double:      return "double";
     case e_long_double: return "long double";
-    case e_sint128:     return "int128_t";
-    case e_uint128:     return "uint128_t";
     }
     return "???";
 }
@@ -1066,198 +567,145 @@ Scalar::Cast(Scalar::Type type)
         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:
         switch (type)
         {
-             case e_void:        break;
-             case e_sint:
-             {
-                 m_integer = m_integer.sextOrTrunc(sizeof(sint_t) * 8);
-                 success = true;
-                 break;
-             }
-             case e_uint:
-             {
-                 m_integer = m_integer.zextOrTrunc(sizeof(sint_t) * 8);
-                 success = true;
-                 break;
-             }
-             case e_slong:
-             {
-                 m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
-                 success = true;
-                 break;
-             }
-             case e_ulong:
-             {
-                 m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
-                 success = true;
-                 break;
-             }
-             case e_slonglong:
-             {
-                 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
-                 success = true;
-                 break;
-             }
-             case e_ulonglong:
-             {
-                 m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
-                 success = true;
-                 break;
-             }
-             case e_sint128:
-             {
-                 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
-                 success = true;
-                 break;
-             }
-             case e_uint128:
-             {
-                 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
-                 success = true;
-                 break;
-             }
-             case e_float:
-             {
-                 m_float = llvm::APFloat(m_integer.bitsToFloat());
-                 success = true;
-                 break;
-             }
-             case e_double:
-             {
-                 m_float = llvm::APFloat(m_integer.bitsToDouble());
-                 success = true;
-                 break;
-             }
-             case e_long_double:
-             {
-                 if(m_ieee_quad)
-                     m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
-                 else
-                     m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
-                 success = true;
-                 break;
-             }
+        case e_void:        break;
+        case e_sint:        success = true; break;
+        case e_uint:        m_data.uint         = m_data.sint;      success = true; break;
+        case e_slong:       m_data.slong        = m_data.sint;      success = true; break;
+        case e_ulong:       m_data.ulong        = m_data.sint;      success = true; break;
+        case e_slonglong:   m_data.slonglong    = m_data.sint;      success = true; break;
+        case e_ulonglong:   m_data.ulonglong    = m_data.sint;      success = true; break;
+        case e_float:       m_data.flt          = m_data.sint;      success = true; break;
+        case e_double:      m_data.dbl          = m_data.sint;      success = true; break;
+        case e_long_double: m_data.ldbl         = m_data.sint;      success = true; break;
         }
         break;
 
-    case e_float:
+    case e_uint:
         switch (type)
         {
-        case e_void: break;
-        case e_sint:
-        case e_uint:
-        case e_slong:
-        case e_ulong:
-        case e_slonglong:
-        case e_ulonglong:
-        case e_sint128:
-        case e_uint128:     m_integer = m_float.bitcastToAPInt();         success = true; break;
-        case e_float:       m_float = llvm::APFloat(m_float.convertToFloat());         success = true; break;
-        case e_double:      m_float = llvm::APFloat(m_float.convertToFloat());         success = true; break;
-        case e_long_double:
-            if(m_ieee_quad)
-                m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_float.bitcastToAPInt());
-            else
-                m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_float.bitcastToAPInt());
-            success = true;
-            break;
+        case e_void:
+        case e_sint:        m_data.sint         = m_data.uint;      success = true; break;
+        case e_uint:        success = true; break;
+        case e_slong:       m_data.slong        = m_data.uint;      success = true; break;
+        case e_ulong:       m_data.ulong        = m_data.uint;      success = true; break;
+        case e_slonglong:   m_data.slonglong    = m_data.uint;      success = true; break;
+        case e_ulonglong:   m_data.ulonglong    = m_data.uint;      success = true; break;
+        case e_float:       m_data.flt          = m_data.uint;      success = true; break;
+        case e_double:      m_data.dbl          = m_data.uint;      success = true; break;
+        case e_long_double: m_data.ldbl         = m_data.uint;      success = true; break;
         }
         break;
 
-    case e_double:
+    case e_slong:
         switch (type)
         {
-        case e_void: break;
-        case e_sint:
-        case e_uint:
-        case e_slong:
-        case e_ulong:
-        case e_slonglong:
-        case e_ulonglong:
-        case e_sint128:
-        case e_uint128:     m_integer = m_float.bitcastToAPInt();                      success = true; break;
-        case e_float:       m_float = llvm::APFloat(m_float.convertToDouble());        success = true; break;
-        case e_double:      m_float = llvm::APFloat(m_float.convertToDouble());        success = true; break;
-        case e_long_double:
-            if(m_ieee_quad)
-                m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_float.bitcastToAPInt());
-            else
-                m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_float.bitcastToAPInt());
-            success = true;
-            break;
+        case e_void:
+        case e_sint:        m_data.sint         = (sint_t)m_data.slong;     success = true; break;
+        case e_uint:        m_data.uint         = (uint_t)m_data.slong;     success = true; break;
+        case e_slong:       success = true; break;
+        case e_ulong:       m_data.ulong        = m_data.slong;     success = true; break;
+        case e_slonglong:   m_data.slonglong    = m_data.slong;     success = true; break;
+        case e_ulonglong:   m_data.ulonglong    = m_data.slong;     success = true; break;
+        case e_float:       m_data.flt          = m_data.slong;     success = true; break;
+        case e_double:      m_data.dbl          = m_data.slong;     success = true; break;
+        case e_long_double: m_data.ldbl         = m_data.slong;     success = true; break;
         }
         break;
 
-    case e_long_double:
+    case e_ulong:
         switch (type)
         {
-        case e_void: break;
-        case e_sint:
-        {
-            m_integer = m_float.bitcastToAPInt();
-            m_integer = m_integer.sextOrTrunc(sizeof(sint_t) * 8);
-            success = true;
-            break;
-        }
-        case e_uint:
-        {
-            m_integer = m_float.bitcastToAPInt();
-            m_integer = m_integer.zextOrTrunc(sizeof(sint_t) * 8);
-            success = true;
-            break;
-        }
-        case e_slong:
-        {
-            m_integer = m_float.bitcastToAPInt();
-            m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
-            success = true;
-            break;
+        case e_void:
+        case e_sint:        m_data.sint         = (sint_t)m_data.ulong;     success = true; break;
+        case e_uint:        m_data.uint         = (uint_t)m_data.ulong;     success = true; break;
+        case e_slong:       m_data.slong        = m_data.ulong;     success = true; break;
+        case e_ulong:       success = true; break;
+        case e_slonglong:   m_data.slonglong    = m_data.ulong;     success = true; break;
+        case e_ulonglong:   m_data.ulonglong    = m_data.ulong;     success = true; break;
+        case e_float:       m_data.flt          = m_data.ulong;     success = true; break;
+        case e_double:      m_data.dbl          = m_data.ulong;     success = true; break;
+        case e_long_double: m_data.ldbl         = m_data.ulong;     success = true; break;
         }
-        case e_ulong:
+        break;
+
+    case e_slonglong:
+        switch (type)
         {
-            m_integer = m_float.bitcastToAPInt();
-            m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
-            success = true;
-            break;
+        case e_void:
+        case e_sint:        m_data.sint         = (sint_t)m_data.slonglong;     success = true; break;
+        case e_uint:        m_data.uint         = (uint_t)m_data.slonglong;     success = true; break;
+        case e_slong:       m_data.slong        = m_data.slonglong;     success = true; break;
+        case e_ulong:       m_data.ulong        = m_data.slonglong;     success = true; break;
+        case e_slonglong:   success = true; break;
+        case e_ulonglong:   m_data.ulonglong    = m_data.slonglong;     success = true; break;
+        case e_float:       m_data.flt          = m_data.slonglong;     success = true; break;
+        case e_double:      m_data.dbl          = m_data.slonglong;     success = true; break;
+        case e_long_double: m_data.ldbl         = m_data.slonglong;     success = true; break;
         }
-        case e_slonglong:
+        break;
+
+    case e_ulonglong:
+        switch (type)
         {
-            m_integer = m_float.bitcastToAPInt();
-            m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
-            success = true;
-            break;
+        case e_void:
+        case e_sint:        m_data.sint         = (sint_t)m_data.ulonglong;     success = true; break;
+        case e_uint:        m_data.uint         = (uint_t)m_data.ulonglong;     success = true; break;
+        case e_slong:       m_data.slong        = m_data.ulonglong;     success = true; break;
+        case e_ulong:       m_data.ulong        = m_data.ulonglong;     success = true; break;
+        case e_slonglong:   m_data.slonglong    = m_data.ulonglong;     success = true; break;
+        case e_ulonglong:   success = true; break;
+        case e_float:       m_data.flt          = m_data.ulonglong;     success = true; break;
+        case e_double:      m_data.dbl          = m_data.ulonglong;     success = true; break;
+        case e_long_double: m_data.ldbl         = m_data.ulonglong;     success = true; break;
         }
-        case e_ulonglong:
+        break;
+
+    case e_float:
+        switch (type)
         {
-            m_integer = m_float.bitcastToAPInt();
-            m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
-            success = true;
-            break;
+        case e_void:
+        case e_sint:        m_data.sint         = (sint_t)m_data.flt;       success = true; break;
+        case e_uint:        m_data.uint         = (uint_t)m_data.flt;       success = true; break;
+        case e_slong:       m_data.slong        = (slong_t)m_data.flt;      success = true; break;
+        case e_ulong:       m_data.ulong        = (ulong_t)m_data.flt;      success = true; break;
+        case e_slonglong:   m_data.slonglong    = (slonglong_t)m_data.flt;  success = true; break;
+        case e_ulonglong:   m_data.ulonglong    = (ulonglong_t)m_data.flt;  success = true; break;
+        case e_float:       success = true; break;
+        case e_double:      m_data.dbl          = m_data.flt;               success = true; break;
+        case e_long_double: m_data.ldbl         = m_data.flt;               success = true; break;
         }
-        case e_sint128:
+        break;
+
+    case e_double:
+        switch (type)
         {
-            m_integer = m_float.bitcastToAPInt();
-            m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
-            success = true;
-            break;
+        case e_void:
+        case e_sint:        m_data.sint         = (sint_t)m_data.dbl;       success = true; break;
+        case e_uint:        m_data.uint         = (uint_t)m_data.dbl;       success = true; break;
+        case e_slong:       m_data.slong        = (slong_t)m_data.dbl;      success = true; break;
+        case e_ulong:       m_data.ulong        = (ulong_t)m_data.dbl;      success = true; break;
+        case e_slonglong:   m_data.slonglong    = (slonglong_t)m_data.dbl;  success = true; break;
+        case e_ulonglong:   m_data.ulonglong    = (ulonglong_t)m_data.dbl;  success = true; break;
+        case e_float:       m_data.flt          = (float_t)m_data.dbl;      success = true; break;
+        case e_double:      success = true; break;
+        case e_long_double: m_data.ldbl         = m_data.dbl;               success = true; break;
         }
-        case e_uint128:
+        break;
+
+    case e_long_double:
+        switch (type)
         {
-            m_integer = m_float.bitcastToAPInt();
-            m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
-            success = true;
-            break;
-        }
-        case e_float:       m_float = llvm::APFloat(m_float.convertToFloat());     success = true; break;
-        case e_double:      m_float = llvm::APFloat(m_float.convertToFloat());    success = true; break;
+        case e_void:
+        case e_sint:        m_data.sint         = (sint_t)m_data.ldbl;      success = true; break;
+        case e_uint:        m_data.uint         = (uint_t)m_data.ldbl;      success = true; break;
+        case e_slong:       m_data.slong        = (slong_t)m_data.ldbl;     success = true; break;
+        case e_ulong:       m_data.ulong        = (ulong_t)m_data.ldbl;     success = true; break;
+        case e_slonglong:   m_data.slonglong    = (slonglong_t)m_data.ldbl; success = true; break;
+        case e_ulonglong:   m_data.ulonglong    = (ulonglong_t)m_data.ldbl; success = true; break;
+        case e_float:       m_data.flt          = (float_t)m_data.ldbl;     success = true; break;
+        case e_double:      m_data.dbl          = (double_t)m_data.ldbl;    success = true; break;
         case e_long_double: success = true; break;
         }
         break;
@@ -1282,8 +730,6 @@ Scalar::MakeSigned ()
     case e_ulong:       m_type = e_slong;       success = true; break;
     case e_slonglong:                           success = true; break;
     case e_ulonglong:   m_type = e_slonglong;   success = true; break;
-    case e_sint128:                             success = true; break;
-    case e_uint128:     m_type = e_sint;        success = true; break;
     case e_float:                               success = true; break;
     case e_double:                              success = true; break;
     case e_long_double:                         success = true; break;
@@ -1292,132 +738,21 @@ Scalar::MakeSigned ()
     return success;
 }
 
-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:
-        return *(const schar_t *)(m_integer.sext(sizeof(schar_t) * 8)).getRawData();
-    case e_float:
-        return (schar_t)m_float.convertToFloat();
-    case e_double:
-        return (schar_t)m_float.convertToDouble();
-    case e_long_double:
-        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return (schar_t)*ldbl_val.getRawData();
-    }
-    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:
-        return *(const uchar_t *)m_integer.getRawData();
-    case e_float:
-        return (uchar_t)m_float.convertToFloat();
-    case e_double:
-        return (uchar_t)m_float.convertToDouble();
-    case e_long_double:
-        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return (uchar_t)*ldbl_val.getRawData();
-    }
-    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:
-        return *(const sshort_t *)(m_integer.sext(sizeof(sshort_t) * 8)).getRawData();
-    case e_float:
-        return (sshort_t)m_float.convertToFloat();
-    case e_double:
-        return (sshort_t)m_float.convertToDouble();
-    case e_long_double:
-        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return *(const sshort_t *)ldbl_val.getRawData();
-    }
-    return fail_value;
-}
-
-unsigned short
-Scalar::UShort(unsigned short fail_value) const
-{
-    switch (m_type)
-    {
-    case e_void:        break;
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-        return *(const ushort_t *)m_integer.getRawData();
-    case e_float:
-        return (ushort_t)m_float.convertToFloat();
-    case e_double:
-        return (ushort_t)m_float.convertToDouble();
-    case e_long_double:
-        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return *(const ushort_t *)ldbl_val.getRawData();;
-    }
-    return fail_value;
-}
-
 int
 Scalar::SInt(int fail_value) const
 {
     switch (m_type)
     {
     case e_void:        break;
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-        return *(const sint_t *)(m_integer.sext(sizeof(sint_t) * 8)).getRawData();
-    case e_float:
-        return (sint_t)m_float.convertToFloat();
-    case e_double:
-        return (sint_t)m_float.convertToDouble();
-    case e_long_double:
-        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return *(const sint_t *)ldbl_val.getRawData();
+    case e_sint:        return m_data.sint;
+    case e_uint:        return (int)m_data.uint;
+    case e_slong:       return (int)m_data.slong;
+    case e_ulong:       return (int)m_data.ulong;
+    case e_slonglong:   return (int)m_data.slonglong;
+    case e_ulonglong:   return (int)m_data.ulonglong;
+    case e_float:       return (int)m_data.flt;
+    case e_double:      return (int)m_data.dbl;
+    case e_long_double: return (int)m_data.ldbl;
     }
     return fail_value;
 }
@@ -1428,22 +763,15 @@ 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:
-        return *(const uint_t *)m_integer.getRawData();
-    case e_float:
-        return (uint_t)m_float.convertToFloat();
-    case e_double:
-        return (uint_t)m_float.convertToDouble();
-    case e_long_double:
-        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return *(const uint_t *)ldbl_val.getRawData();
+    case e_sint:        return (unsigned int)m_data.sint;
+    case e_uint:        return (unsigned int)m_data.uint;
+    case e_slong:       return (unsigned int)m_data.slong;
+    case e_ulong:       return (unsigned int)m_data.ulong;
+    case e_slonglong:   return (unsigned int)m_data.slonglong;
+    case e_ulonglong:   return (unsigned int)m_data.ulonglong;
+    case e_float:       return (unsigned int)m_data.flt;
+    case e_double:      return (unsigned int)m_data.dbl;
+    case e_long_double: return (unsigned int)m_data.ldbl;
     }
     return fail_value;
 }
@@ -1455,22 +783,15 @@ 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:
-        return *(const slong_t *)(m_integer.sext(sizeof(slong_t) * 8)).getRawData();
-    case e_float:
-        return (slong_t)m_float.convertToFloat();
-    case e_double:
-        return (slong_t)m_float.convertToDouble();
-    case e_long_double:
-        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return *(const slong_t *)ldbl_val.getRawData();
+    case e_sint:        return (long)m_data.sint;
+    case e_uint:        return (long)m_data.uint;
+    case e_slong:       return (long)m_data.slong;
+    case e_ulong:       return (long)m_data.ulong;
+    case e_slonglong:   return (long)m_data.slonglong;
+    case e_ulonglong:   return (long)m_data.ulonglong;
+    case e_float:       return (long)m_data.flt;
+    case e_double:      return (long)m_data.dbl;
+    case e_long_double: return (long)m_data.ldbl;
     }
     return fail_value;
 }
@@ -1483,22 +804,15 @@ 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:
-        return *(const ulong_t *)m_integer.getRawData();
-    case e_float:
-        return (ulong_t)m_float.convertToFloat();
-    case e_double:
-        return (ulong_t)m_float.convertToDouble();
-    case e_long_double:
-        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return *(const ulong_t *)ldbl_val.getRawData();
+    case e_sint:        return (unsigned long)m_data.sint;
+    case e_uint:        return (unsigned long)m_data.uint;
+    case e_slong:       return (unsigned long)m_data.slong;
+    case e_ulong:       return (unsigned long)m_data.ulong;
+    case e_slonglong:   return (unsigned long)m_data.slonglong;
+    case e_ulonglong:   return (unsigned long)m_data.ulonglong;
+    case e_float:       return (unsigned long)m_data.flt;
+    case e_double:      return (unsigned long)m_data.dbl;
+    case e_long_double: return (unsigned long)m_data.ldbl;
     }
     return fail_value;
 }
@@ -1513,20 +827,42 @@ Scalar::GetRawBits64(uint64_t fail_value) const
 
     case e_sint:
     case e_uint:
+        return m_data.uint;
+
     case e_slong:
     case e_ulong:
+        return m_data.ulong;
+
     case e_slonglong:
     case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-        return *m_integer.getRawData();
+        return m_data.ulonglong;
+
     case e_float:
-        return (uint64_t)m_float.convertToFloat();
+        if (sizeof(m_data.flt) == sizeof(m_data.uint))
+            return m_data.uint;
+        else if (sizeof(m_data.flt) == sizeof(m_data.ulong))
+            return m_data.ulong;
+        else if (sizeof(m_data.flt) == sizeof(m_data.ulonglong))
+            return m_data.ulonglong;
+        break;
+
     case e_double:
-        return (uint64_t)m_float.convertToDouble();
+        if (sizeof(m_data.dbl) == sizeof(m_data.uint))
+            return m_data.uint;
+        else if (sizeof(m_data.dbl) == sizeof(m_data.ulong))
+            return m_data.ulong;
+        else if (sizeof(m_data.dbl) == sizeof(m_data.ulonglong))
+            return m_data.ulonglong;
+        break;
+
     case e_long_double:
-        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return *ldbl_val.getRawData();
+        if (sizeof(m_data.ldbl) == sizeof(m_data.uint))
+            return m_data.uint;
+        else if (sizeof(m_data.ldbl) == sizeof(m_data.ulong))
+            return m_data.ulong;
+        else if (sizeof(m_data.ldbl) == sizeof(m_data.ulonglong))
+            return m_data.ulonglong;
+        break;
     }
     return fail_value;
 }
@@ -1539,22 +875,15 @@ 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:
-        return *(const slonglong_t *)(m_integer.sext(sizeof(slonglong_t) * 8)).getRawData();
-    case e_float:
-        return (slonglong_t)m_float.convertToFloat();
-    case e_double:
-        return (slonglong_t)m_float.convertToDouble();
-    case e_long_double:
-        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return *(const slonglong_t *)ldbl_val.getRawData();
+    case e_sint:        return (long long)m_data.sint;
+    case e_uint:        return (long long)m_data.uint;
+    case e_slong:       return (long long)m_data.slong;
+    case e_ulong:       return (long long)m_data.ulong;
+    case e_slonglong:   return (long long)m_data.slonglong;
+    case e_ulonglong:   return (long long)m_data.ulonglong;
+    case e_float:       return (long long)m_data.flt;
+    case e_double:      return (long long)m_data.dbl;
+    case e_long_double: return (long long)m_data.ldbl;
     }
     return fail_value;
 }
@@ -1566,73 +895,19 @@ 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:
-        if(m_integer.isAllOnesValue())
-            return *(const ulonglong_t *)(llvm::APInt::getAllOnesValue(128)).getRawData();
-        return *(const ulonglong_t *)m_integer.getRawData();
-    case e_float:
-        return (ulonglong_t)m_float.convertToFloat();
-    case e_double:
-        return (ulonglong_t)m_float.convertToDouble();
-    case e_long_double:
-        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return *(const ulonglong_t *)ldbl_val.getRawData();
+    case e_sint:        return (unsigned long long)m_data.sint;
+    case e_uint:        return (unsigned long long)m_data.uint;
+    case e_slong:       return (unsigned long long)m_data.slong;
+    case e_ulong:       return (unsigned long long)m_data.ulong;
+    case e_slonglong:   return (unsigned long long)m_data.slonglong;
+    case e_ulonglong:   return (unsigned long long)m_data.ulonglong;
+    case e_float:       return (unsigned long long)m_data.flt;
+    case e_double:      return (unsigned long long)m_data.dbl;
+    case e_long_double: return (unsigned long long)m_data.ldbl;
     }
     return fail_value;
 }
 
-llvm::APInt
-Scalar::UInt128(llvm::APInt& fail_value) const
-{
-    switch (m_type)
-    {
-    case e_void:        break;
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-        return m_integer;
-    case e_float:
-    case e_double:
-    case e_long_double:
-        return m_float.bitcastToAPInt();
-    }
-    return fail_value;
-}
-
-llvm::APInt
-Scalar::SInt128(llvm::APInt& fail_value) const
-{
-    switch (m_type)
-    {
-    case e_void:        break;
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-        return m_integer;
-    case e_float:
-    case e_double:
-    case e_long_double:
-        return m_float.bitcastToAPInt();
-    }
-    return fail_value;
-}
 
 float
 Scalar::Float(float fail_value) const
@@ -1640,22 +915,15 @@ Scalar::Float(float 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:
-        return m_integer.bitsToFloat();
-    case e_float:
-        return m_float.convertToFloat();
-    case e_double:
-        return (float_t)m_float.convertToDouble();
-    case e_long_double:
-        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return ldbl_val.bitsToFloat();
+    case e_sint:        return (float)m_data.sint;
+    case e_uint:        return (float)m_data.uint;
+    case e_slong:       return (float)m_data.slong;
+    case e_ulong:       return (float)m_data.ulong;
+    case e_slonglong:   return (float)m_data.slonglong;
+    case e_ulonglong:   return (float)m_data.ulonglong;
+    case e_float:       return (float)m_data.flt;
+    case e_double:      return (float)m_data.dbl;
+    case e_long_double: return (float)m_data.ldbl;
     }
     return fail_value;
 }
@@ -1667,22 +935,15 @@ Scalar::Double(double 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:
-        return m_integer.bitsToDouble();
-    case e_float:
-        return (double_t)m_float.convertToFloat();
-    case e_double:
-        return m_float.convertToDouble();
-    case e_long_double:
-        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return ldbl_val.bitsToFloat();
+    case e_sint:        return (double)m_data.sint;
+    case e_uint:        return (double)m_data.uint;
+    case e_slong:       return (double)m_data.slong;
+    case e_ulong:       return (double)m_data.ulong;
+    case e_slonglong:   return (double)m_data.slonglong;
+    case e_ulonglong:   return (double)m_data.ulonglong;
+    case e_float:       return (double)m_data.flt;
+    case e_double:      return (double)m_data.dbl;
+    case e_long_double: return (double)m_data.ldbl;
     }
     return fail_value;
 }
@@ -1694,22 +955,15 @@ Scalar::LongDouble(long double 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:
-        return (long_double_t)m_integer.bitsToDouble();
-    case e_float:
-        return (long_double_t)m_float.convertToFloat();
-    case e_double:
-        return (long_double_t)m_float.convertToDouble();
-    case e_long_double:
-        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-        return (long_double_t)ldbl_val.bitsToDouble();
+    case e_sint:        return (long double)m_data.sint;
+    case e_uint:        return (long double)m_data.uint;
+    case e_slong:       return (long double)m_data.slong;
+    case e_ulong:       return (long double)m_data.ulong;
+    case e_slonglong:   return (long double)m_data.slonglong;
+    case e_ulonglong:   return (long double)m_data.ulonglong;
+    case e_float:       return (long double)m_data.flt;
+    case e_double:      return (long double)m_data.dbl;
+    case e_long_double: return (long double)m_data.ldbl;
     }
     return fail_value;
 }
@@ -1724,27 +978,17 @@ Scalar::operator+= (const Scalar& rhs)
     if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) != Scalar::e_void)
     {
         switch (m_type)
-            {
-             case e_void:        break;
-             case e_sint:
-             case e_uint:
-             case e_slong:
-             case e_ulong:
-             case e_slonglong:
-             case e_ulonglong:
-             case e_sint128:
-             case e_uint128:
-             {
-                 m_integer = a->m_integer + b->m_integer;
-                 break;
-             }
-             case e_float:
-             case e_double:
-             case e_long_double:
-             {
-                 m_float = a->m_float + b->m_float;
-                 break;
-             }
+        {
+        case e_void:        break;
+        case e_sint:        m_data.sint         = a->m_data.sint        + b->m_data.sint;       break;
+        case e_uint:        m_data.uint         = a->m_data.uint        + b->m_data.uint;       break;
+        case e_slong:       m_data.slong        = a->m_data.slong       + b->m_data.slong;      break;
+        case e_ulong:       m_data.ulong        = a->m_data.ulong       + b->m_data.ulong;      break;
+        case e_slonglong:   m_data.slonglong    = a->m_data.slonglong   + b->m_data.slonglong;  break;
+        case e_ulonglong:   m_data.ulonglong    = a->m_data.ulonglong   + b->m_data.ulonglong;  break;
+        case e_float:       m_data.flt          = a->m_data.flt         + b->m_data.flt;        break;
+        case e_double:      m_data.dbl          = a->m_data.dbl         + b->m_data.dbl;        break;
+        case e_long_double: m_data.ldbl         = a->m_data.ldbl        + b->m_data.ldbl;       break;
         }
     }
     return *this;
@@ -1763,33 +1007,109 @@ Scalar::operator<<= (const Scalar& rhs)
         break;
 
     case e_sint:
+        switch (rhs.m_type)
+        {
+        case e_void:
+        case e_float:
+        case e_double:
+        case e_long_double:
+            m_type = e_void;
+            break;
+        case e_sint:            m_data.sint <<= rhs.m_data.sint;        break;
+        case e_uint:            m_data.sint <<= rhs.m_data.uint;        break;
+        case e_slong:           m_data.sint <<= rhs.m_data.slong;       break;
+        case e_ulong:           m_data.sint <<= rhs.m_data.ulong;       break;
+        case e_slonglong:       m_data.sint <<= rhs.m_data.slonglong;   break;
+        case e_ulonglong:       m_data.sint <<= rhs.m_data.ulonglong;   break;
+        }
+        break;
+
     case e_uint:
+        switch (rhs.m_type)
+        {
+        case e_void:
+        case e_float:
+        case e_double:
+        case e_long_double:
+            m_type = e_void;
+            break;
+        case e_sint:            m_data.uint <<= rhs.m_data.sint;        break;
+        case e_uint:            m_data.uint <<= rhs.m_data.uint;        break;
+        case e_slong:           m_data.uint <<= rhs.m_data.slong;       break;
+        case e_ulong:           m_data.uint <<= rhs.m_data.ulong;       break;
+        case e_slonglong:       m_data.uint <<= rhs.m_data.slonglong;   break;
+        case e_ulonglong:       m_data.uint <<= rhs.m_data.ulonglong;   break;
+        }
+        break;
+
     case e_slong:
+        switch (rhs.m_type)
+        {
+        case e_void:
+        case e_float:
+        case e_double:
+        case e_long_double:
+            m_type = e_void;
+            break;
+        case e_sint:            m_data.slong <<= rhs.m_data.sint;       break;
+        case e_uint:            m_data.slong <<= rhs.m_data.uint;       break;
+        case e_slong:           m_data.slong <<= rhs.m_data.slong;      break;
+        case e_ulong:           m_data.slong <<= rhs.m_data.ulong;      break;
+        case e_slonglong:       m_data.slong <<= rhs.m_data.slonglong;  break;
+        case e_ulonglong:       m_data.slong <<= rhs.m_data.ulonglong;  break;
+        }
+        break;
+
     case e_ulong:
+        switch (rhs.m_type)
+        {
+        case e_void:
+        case e_float:
+        case e_double:
+        case e_long_double:
+            m_type = e_void;
+            break;
+        case e_sint:            m_data.ulong <<= rhs.m_data.sint;       break;
+        case e_uint:            m_data.ulong <<= rhs.m_data.uint;       break;
+        case e_slong:           m_data.ulong <<= rhs.m_data.slong;      break;
+        case e_ulong:           m_data.ulong <<= rhs.m_data.ulong;      break;
+        case e_slonglong:       m_data.ulong <<= rhs.m_data.slonglong;  break;
+        case e_ulonglong:       m_data.ulong <<= rhs.m_data.ulonglong;  break;
+        }
+        break;
     case e_slonglong:
+        switch (rhs.m_type)
+        {
+        case e_void:
+        case e_float:
+        case e_double:
+        case e_long_double:
+            m_type = e_void;
+            break;
+        case e_sint:            m_data.slonglong <<= rhs.m_data.sint;       break;
+        case e_uint:            m_data.slonglong <<= rhs.m_data.uint;       break;
+        case e_slong:           m_data.slonglong <<= rhs.m_data.slong;      break;
+        case e_ulong:           m_data.slonglong <<= rhs.m_data.ulong;      break;
+        case e_slonglong:       m_data.slonglong <<= rhs.m_data.slonglong;  break;
+        case e_ulonglong:       m_data.slonglong <<= rhs.m_data.ulonglong;  break;
+        }
+        break;
+
     case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
         switch (rhs.m_type)
         {
-             case e_void:
-             case e_float:
-             case e_double:
-             case e_long_double:
-                 m_type = e_void;
-                 break;
-             case e_sint:
-             case e_uint:
-             case e_slong:
-             case e_ulong:
-             case e_slonglong:
-             case e_ulonglong:
-             case e_sint128:
-             case e_uint128:
-             {
-                 m_integer <<= *rhs.m_integer.getRawData();
-                 break;
-             }
+        case e_void:
+        case e_float:
+        case e_double:
+        case e_long_double:
+            m_type = e_void;
+            break;
+        case e_sint:            m_data.ulonglong <<= rhs.m_data.sint;       break;
+        case e_uint:            m_data.ulonglong <<= rhs.m_data.uint;       break;
+        case e_slong:           m_data.ulonglong <<= rhs.m_data.slong;      break;
+        case e_ulong:           m_data.ulonglong <<= rhs.m_data.ulong;      break;
+        case e_slonglong:       m_data.ulonglong <<= rhs.m_data.slonglong;  break;
+        case e_ulonglong:       m_data.ulonglong <<= rhs.m_data.ulonglong;  break;
         }
         break;
     }
@@ -1810,12 +1130,44 @@ Scalar::ShiftRightLogical(const Scalar& rhs)
 
     case e_sint:
     case e_uint:
+        switch (rhs.m_type)
+        {
+        case e_void:
+        case e_float:
+        case e_double:
+        case e_long_double:
+            m_type = e_void;
+            break;
+        case e_sint:            m_data.uint >>= rhs.m_data.sint;        break;
+        case e_uint:            m_data.uint >>= rhs.m_data.uint;        break;
+        case e_slong:           m_data.uint >>= rhs.m_data.slong;       break;
+        case e_ulong:           m_data.uint >>= rhs.m_data.ulong;       break;
+        case e_slonglong:       m_data.uint >>= rhs.m_data.slonglong;   break;
+        case e_ulonglong:       m_data.uint >>= rhs.m_data.ulonglong;   break;
+        }
+        break;
+
     case e_slong:
     case e_ulong:
+        switch (rhs.m_type)
+        {
+        case e_void:
+        case e_float:
+        case e_double:
+        case e_long_double:
+            m_type = e_void;
+            break;
+        case e_sint:            m_data.ulong >>= rhs.m_data.sint;       break;
+        case e_uint:            m_data.ulong >>= rhs.m_data.uint;       break;
+        case e_slong:           m_data.ulong >>= rhs.m_data.slong;      break;
+        case e_ulong:           m_data.ulong >>= rhs.m_data.ulong;      break;
+        case e_slonglong:       m_data.ulong >>= rhs.m_data.slonglong;  break;
+        case e_ulonglong:       m_data.ulong >>= rhs.m_data.ulonglong;  break;
+        }
+        break;
+
     case e_slonglong:
     case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
         switch (rhs.m_type)
         {
         case e_void:
@@ -1824,15 +1176,12 @@ Scalar::ShiftRightLogical(const Scalar& rhs)
         case e_long_double:
             m_type = 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:
-            m_integer = m_integer.lshr(*(const uint_t *) rhs.m_integer.getRawData());   break;
+        case e_sint:            m_data.ulonglong >>= rhs.m_data.sint;       break;
+        case e_uint:            m_data.ulonglong >>= rhs.m_data.uint;       break;
+        case e_slong:           m_data.ulonglong >>= rhs.m_data.slong;      break;
+        case e_ulong:           m_data.ulonglong >>= rhs.m_data.ulong;      break;
+        case e_slonglong:       m_data.ulonglong >>= rhs.m_data.slonglong;  break;
+        case e_ulonglong:       m_data.ulonglong >>= rhs.m_data.ulonglong;  break;
         }
         break;
     }
@@ -1853,13 +1202,95 @@ Scalar::operator>>= (const Scalar& rhs)
         break;
 
     case e_sint:
+        switch (rhs.m_type)
+        {
+        case e_void:
+        case e_float:
+        case e_double:
+        case e_long_double:
+            m_type = e_void;
+            break;
+        case e_sint:            m_data.sint >>= rhs.m_data.sint;        break;
+        case e_uint:            m_data.sint >>= rhs.m_data.uint;        break;
+        case e_slong:           m_data.sint >>= rhs.m_data.slong;       break;
+        case e_ulong:           m_data.sint >>= rhs.m_data.ulong;       break;
+        case e_slonglong:       m_data.sint >>= rhs.m_data.slonglong;   break;
+        case e_ulonglong:       m_data.sint >>= rhs.m_data.ulonglong;   break;
+        }
+        break;
+
     case e_uint:
+        switch (rhs.m_type)
+        {
+        case e_void:
+        case e_float:
+        case e_double:
+        case e_long_double:
+            m_type = e_void;
+            break;
+        case e_sint:            m_data.uint >>= rhs.m_data.sint;        break;
+        case e_uint:            m_data.uint >>= rhs.m_data.uint;        break;
+        case e_slong:           m_data.uint >>= rhs.m_data.slong;       break;
+        case e_ulong:           m_data.uint >>= rhs.m_data.ulong;       break;
+        case e_slonglong:       m_data.uint >>= rhs.m_data.slonglong;   break;
+        case e_ulonglong:       m_data.uint >>= rhs.m_data.ulonglong;   break;
+        }
+        break;
+
     case e_slong:
+        switch (rhs.m_type)
+        {
+        case e_void:
+        case e_float:
+        case e_double:
+        case e_long_double:
+            m_type = e_void;
+            break;
+        case e_sint:            m_data.slong >>= rhs.m_data.sint;       break;
+        case e_uint:            m_data.slong >>= rhs.m_data.uint;       break;
+        case e_slong:           m_data.slong >>= rhs.m_data.slong;      break;
+        case e_ulong:           m_data.slong >>= rhs.m_data.ulong;      break;
+        case e_slonglong:       m_data.slong >>= rhs.m_data.slonglong;  break;
+        case e_ulonglong:       m_data.slong >>= rhs.m_data.ulonglong;  break;
+        }
+        break;
+
     case e_ulong:
+        switch (rhs.m_type)
+        {
+        case e_void:
+        case e_float:
+        case e_double:
+        case e_long_double:
+            m_type = e_void;
+            break;
+        case e_sint:            m_data.ulong >>= rhs.m_data.sint;       break;
+        case e_uint:            m_data.ulong >>= rhs.m_data.uint;       break;
+        case e_slong:           m_data.ulong >>= rhs.m_data.slong;      break;
+        case e_ulong:           m_data.ulong >>= rhs.m_data.ulong;      break;
+        case e_slonglong:       m_data.ulong >>= rhs.m_data.slonglong;  break;
+        case e_ulonglong:       m_data.ulong >>= rhs.m_data.ulonglong;  break;
+        }
+        break;
     case e_slonglong:
+        switch (rhs.m_type)
+        {
+        case e_void:
+        case e_float:
+        case e_double:
+        case e_long_double:
+            m_type = e_void;
+            break;
+        case e_sint:            m_data.slonglong >>= rhs.m_data.sint;       break;
+        case e_uint:            m_data.slonglong >>= rhs.m_data.uint;       break;
+        case e_slong:           m_data.slonglong >>= rhs.m_data.slong;      break;
+        case e_ulong:           m_data.slonglong >>= rhs.m_data.ulong;      break;
+        case e_slonglong:       m_data.slonglong >>= rhs.m_data.slonglong;  break;
+        case e_ulonglong:       m_data.slonglong >>= rhs.m_data.ulonglong;  break;
+        }
+        break;
+
     case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
         switch (rhs.m_type)
         {
         case e_void:
@@ -1868,18 +1299,12 @@ Scalar::operator>>= (const Scalar& rhs)
         case e_long_double:
             m_type = 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:
-             {
-                 m_integer >> *rhs.m_integer.getRawData();
-                 break;
-             }
+        case e_sint:            m_data.ulonglong >>= rhs.m_data.sint;       break;
+        case e_uint:            m_data.ulonglong >>= rhs.m_data.uint;       break;
+        case e_slong:           m_data.ulonglong >>= rhs.m_data.slong;      break;
+        case e_ulong:           m_data.ulonglong >>= rhs.m_data.ulong;      break;
+        case e_slonglong:       m_data.ulonglong >>= rhs.m_data.slonglong;  break;
+        case e_ulonglong:       m_data.ulonglong >>= rhs.m_data.ulonglong;  break;
         }
         break;
     }
@@ -1900,13 +1325,95 @@ Scalar::operator&= (const Scalar& rhs)
         break;
 
     case e_sint:
+        switch (rhs.m_type)
+        {
+        case e_void:
+        case e_float:
+        case e_double:
+        case e_long_double:
+            m_type = e_void;
+            break;
+        case e_sint:            m_data.sint &= rhs.m_data.sint;         break;
+        case e_uint:            m_data.sint &= rhs.m_data.uint;         break;
+        case e_slong:           m_data.sint &= rhs.m_data.slong;        break;
+        case e_ulong:           m_data.sint &= rhs.m_data.ulong;        break;
+        case e_slonglong:       m_data.sint &= rhs.m_data.slonglong;    break;
+        case e_ulonglong:       m_data.sint &= rhs.m_data.ulonglong;    break;
+        }
+        break;
+
     case e_uint:
+        switch (rhs.m_type)
+        {
+        case e_void:
+        case e_float:
+        case e_double:
+        case e_long_double:
+            m_type = e_void;
+            break;
+        case e_sint:            m_data.uint &= rhs.m_data.sint;         break;
+        case e_uint:            m_data.uint &= rhs.m_data.uint;         break;
+        case e_slong:           m_data.uint &= rhs.m_data.slong;        break;
+        case e_ulong:           m_data.uint &= rhs.m_data.ulong;        break;
+        case e_slonglong:       m_data.uint &= rhs.m_data.slonglong;    break;
+        case e_ulonglong:       m_data.uint &= rhs.m_data.ulonglong;    break;
+        }
+        break;
+
     case e_slong:
+        switch (rhs.m_type)
+        {
+        case e_void:
+        case e_float:
+        case e_double:
+        case e_long_double:
+            m_type = e_void;
+            break;
+        case e_sint:            m_data.slong &= rhs.m_data.sint;        break;
+        case e_uint:            m_data.slong &= rhs.m_data.uint;        break;
+        case e_slong:           m_data.slong &= rhs.m_data.slong;       break;
+        case e_ulong:           m_data.slong &= rhs.m_data.ulong;       break;
+        case e_slonglong:       m_data.slong &= rhs.m_data.slonglong;   break;
+        case e_ulonglong:       m_data.slong &= rhs.m_data.ulonglong;   break;
+        }
+        break;
+
     case e_ulong:
+        switch (rhs.m_type)
+        {
+        case e_void:
+        case e_float:
+        case e_double:
+        case e_long_double:
+            m_type = e_void;
+            break;
+        case e_sint:            m_data.ulong &= rhs.m_data.sint;        break;
+        case e_uint:            m_data.ulong &= rhs.m_data.uint;        break;
+        case e_slong:           m_data.ulong &= rhs.m_data.slong;       break;
+        case e_ulong:           m_data.ulong &= rhs.m_data.ulong;       break;
+        case e_slonglong:       m_data.ulong &= rhs.m_data.slonglong;   break;
+        case e_ulonglong:       m_data.ulong &= rhs.m_data.ulonglong;   break;
+        }
+        break;
     case e_slonglong:
+        switch (rhs.m_type)
+        {
+        case e_void:
+        case e_float:
+        case e_double:
+        case e_long_double:
+            m_type = e_void;
+            break;
+        case e_sint:            m_data.slonglong &= rhs.m_data.sint;        break;
+        case e_uint:            m_data.slonglong &= rhs.m_data.uint;        break;
+        case e_slong:           m_data.slonglong &= rhs.m_data.slong;       break;
+        case e_ulong:           m_data.slonglong &= rhs.m_data.ulong;       break;
+        case e_slonglong:       m_data.slonglong &= rhs.m_data.slonglong;   break;
+        case e_ulonglong:       m_data.slonglong &= rhs.m_data.ulonglong;   break;
+        }
+        break;
+
     case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
         switch (rhs.m_type)
         {
         case e_void:
@@ -1915,18 +1422,12 @@ Scalar::operator&= (const Scalar& rhs)
         case e_long_double:
             m_type = 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:
-             {
-                 m_integer &= rhs.m_integer;
-                 break;
-             }
+        case e_sint:            m_data.ulonglong &= rhs.m_data.sint;        break;
+        case e_uint:            m_data.ulonglong &= rhs.m_data.uint;        break;
+        case e_slong:           m_data.ulonglong &= rhs.m_data.slong;       break;
+        case e_ulong:           m_data.ulonglong &= rhs.m_data.ulong;       break;
+        case e_slonglong:       m_data.ulonglong &= rhs.m_data.slonglong;   break;
+        case e_ulonglong:       m_data.ulonglong &= rhs.m_data.ulonglong;   break;
         }
         break;
     }
@@ -1944,22 +1445,26 @@ Scalar::AbsoluteValue()
         break;
 
     case e_sint:
+        if (m_data.sint < 0)
+            m_data.sint = -m_data.sint;
+        return true;
+
     case e_slong:
+        if (m_data.slong < 0)
+            m_data.slong = -m_data.slong;
+        return true;
+
     case e_slonglong:
-    case e_sint128:
-        if (m_integer.isNegative())
-            m_integer = -m_integer;
+        if (m_data.slonglong < 0)
+            m_data.slonglong = -m_data.slonglong;
         return true;
 
     case e_uint:
     case e_ulong:
     case e_ulonglong:   return true;
-    case e_uint128:
-    case e_float:
-    case e_double:
-    case e_long_double:
-        m_float.clearSign();
-        return true;
+    case e_float:       m_data.flt = fabsf(m_data.flt);     return true;
+    case e_double:      m_data.dbl = fabs(m_data.dbl);      return true;
+    case e_long_double: m_data.ldbl = fabsl(m_data.ldbl);   return true;
     }
     return false;
 }
@@ -1971,19 +1476,15 @@ Scalar::UnaryNegate()
     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:
-        m_integer = -m_integer; return true;
-    case e_float:
-    case e_double:
-    case e_long_double:
-        m_float.changeSign(); return true;
+    case e_sint:        m_data.sint = -m_data.sint;             return true;
+    case e_uint:        m_data.uint = -m_data.uint;             return true;
+    case e_slong:       m_data.slong = -m_data.slong;           return true;
+    case e_ulong:       m_data.ulong = -m_data.ulong;           return true;
+    case e_slonglong:   m_data.slonglong = -m_data.slonglong;   return true;
+    case e_ulonglong:   m_data.ulonglong = -m_data.ulonglong;   return true;
+    case e_float:       m_data.flt = -m_data.flt;               return true;
+    case e_double:      m_data.dbl = -m_data.dbl;               return true;
+    case e_long_double: m_data.ldbl = -m_data.ldbl;             return true;
     }
     return false;
 }
@@ -1993,15 +1494,12 @@ Scalar::OnesComplement()
 {
     switch (m_type)
     {
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-        m_integer = ~m_integer; return true;
+    case e_sint:        m_data.sint = ~m_data.sint; return true;
+    case e_uint:        m_data.uint = ~m_data.uint; return true;
+    case e_slong:       m_data.slong = ~m_data.slong; return true;
+    case e_ulong:       m_data.ulong = ~m_data.ulong; return true;
+    case e_slonglong:   m_data.slonglong = ~m_data.slonglong; return true;
+    case e_ulonglong:   m_data.ulonglong = ~m_data.ulonglong; return true;
 
     case e_void:
     case e_float:
@@ -2025,19 +1523,15 @@ lldb_private::operator+ (const Scalar& lhs, const Scalar& rhs)
         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:
-            result.m_integer = a->m_integer + b->m_integer;  break;
-        case Scalar::e_float:
-        case Scalar::e_double:
-        case Scalar::e_long_double:
-            result.m_float = a->m_float + b->m_float; break;
+        case Scalar::e_sint:            result.m_data.sint      = a->m_data.sint        + b->m_data.sint;       break;
+        case Scalar::e_uint:            result.m_data.uint      = a->m_data.uint        + b->m_data.uint;       break;
+        case Scalar::e_slong:           result.m_data.slong     = a->m_data.slong       + b->m_data.slong;      break;
+        case Scalar::e_ulong:           result.m_data.ulong     = a->m_data.ulong       + b->m_data.ulong;      break;
+        case Scalar::e_slonglong:       result.m_data.slonglong = a->m_data.slonglong   + b->m_data.slonglong;  break;
+        case Scalar::e_ulonglong:       result.m_data.ulonglong = a->m_data.ulonglong   + b->m_data.ulonglong;  break;
+        case Scalar::e_float:           result.m_data.flt       = a->m_data.flt         + b->m_data.flt;        break;
+        case Scalar::e_double:      result.m_data.dbl       = a->m_data.dbl         + b->m_data.dbl;        break;
+        case Scalar::e_long_double: result.m_data.ldbl      = a->m_data.ldbl        + b->m_data.ldbl;       break;
         }
     }
     return result;
@@ -2056,19 +1550,15 @@ lldb_private::operator- (const Scalar& lhs, const Scalar& rhs)
         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:
-            result.m_integer = a->m_integer - b->m_integer;  break;
-        case Scalar::e_float:
-        case Scalar::e_double:
-        case Scalar::e_long_double:
-            result.m_float = a->m_float - b->m_float; break;
+        case Scalar::e_sint:            result.m_data.sint      = a->m_data.sint        - b->m_data.sint;       break;
+        case Scalar::e_uint:            result.m_data.uint      = a->m_data.uint        - b->m_data.uint;       break;
+        case Scalar::e_slong:           result.m_data.slong     = a->m_data.slong       - b->m_data.slong;      break;
+        case Scalar::e_ulong:           result.m_data.ulong     = a->m_data.ulong       - b->m_data.ulong;      break;
+        case Scalar::e_slonglong:       result.m_data.slonglong = a->m_data.slonglong   - b->m_data.slonglong;  break;
+        case Scalar::e_ulonglong:       result.m_data.ulonglong = a->m_data.ulonglong   - b->m_data.ulonglong;  break;
+        case Scalar::e_float:           result.m_data.flt       = a->m_data.flt         - b->m_data.flt;        break;
+        case Scalar::e_double:      result.m_data.dbl       = a->m_data.dbl         - b->m_data.dbl;        break;
+        case Scalar::e_long_double: result.m_data.ldbl      = a->m_data.ldbl        - b->m_data.ldbl;       break;
         }
     }
     return result;
@@ -2086,31 +1576,16 @@ lldb_private::operator/ (const Scalar& lhs, const Scalar& rhs)
         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:
-        {
-            if (b->m_integer != 0)
-            {
-                result.m_integer = *a->m_integer.getRawData() / *b->m_integer.getRawData();
-                return result;
-            }
-            break;
-        }
-        case Scalar::e_float:
-        case Scalar::e_double:
-        case Scalar::e_long_double:
-            if (b->m_float.isZero())
-            {
-                result.m_float = a->m_float / b->m_float;
-                return result;
-            }
-            break;
+
+        case Scalar::e_sint:            if (b->m_data.sint != 0)        { result.m_data.sint = a->m_data.sint/ b->m_data.sint; return result; } break;
+        case Scalar::e_uint:            if (b->m_data.uint != 0)        { result.m_data.uint = a->m_data.uint / b->m_data.uint; return result; } break;
+        case Scalar::e_slong:           if (b->m_data.slong != 0)       { result.m_data.slong = a->m_data.slong / b->m_data.slong; return result; } break;
+        case Scalar::e_ulong:           if (b->m_data.ulong != 0)       { result.m_data.ulong = a->m_data.ulong / b->m_data.ulong; return result; } break;
+        case Scalar::e_slonglong:       if (b->m_data.slonglong != 0)   { result.m_data.slonglong = a->m_data.slonglong / b->m_data.slonglong; return result; } break;
+        case Scalar::e_ulonglong:       if (b->m_data.ulonglong != 0)   { result.m_data.ulonglong = a->m_data.ulonglong / b->m_data.ulonglong; return result; } break;
+        case Scalar::e_float:           if (b->m_data.flt != 0.0f)      { result.m_data.flt = a->m_data.flt / b->m_data.flt; return result; } break;
+        case Scalar::e_double:      if (b->m_data.dbl != 0.0)       { result.m_data.dbl = a->m_data.dbl / b->m_data.dbl; return result; } break;
+        case Scalar::e_long_double: if (b->m_data.ldbl != 0.0)      { result.m_data.ldbl = a->m_data.ldbl / b->m_data.ldbl; return result; } break;
         }
     }
     // For division only, the only way it should make it here is if a promotion failed,
@@ -2131,19 +1606,15 @@ lldb_private::operator* (const Scalar& lhs, const Scalar& rhs)
         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:
-            result.m_integer = a->m_integer * b->m_integer;  break;
-        case Scalar::e_float:
-        case Scalar::e_double:
-        case Scalar::e_long_double:
-            result.m_float = a->m_float * b->m_float; break;
+        case Scalar::e_sint:            result.m_data.sint      = a->m_data.sint        * b->m_data.sint;       break;
+        case Scalar::e_uint:            result.m_data.uint      = a->m_data.uint        * b->m_data.uint;       break;
+        case Scalar::e_slong:           result.m_data.slong     = a->m_data.slong       * b->m_data.slong;      break;
+        case Scalar::e_ulong:           result.m_data.ulong     = a->m_data.ulong       * b->m_data.ulong;      break;
+        case Scalar::e_slonglong:       result.m_data.slonglong = a->m_data.slonglong   * b->m_data.slonglong;  break;
+        case Scalar::e_ulonglong:       result.m_data.ulonglong = a->m_data.ulonglong   * b->m_data.ulonglong;  break;
+        case Scalar::e_float:           result.m_data.flt       = a->m_data.flt         * b->m_data.flt;        break;
+        case Scalar::e_double:      result.m_data.dbl       = a->m_data.dbl         * b->m_data.dbl;        break;
+        case Scalar::e_long_double: result.m_data.ldbl      = a->m_data.ldbl        * b->m_data.ldbl;       break;
         }
     }
     return result;
@@ -2160,15 +1631,13 @@ lldb_private::operator& (const Scalar& lhs, const Scalar& rhs)
     {
         switch (result.m_type)
         {
-        case Scalar::e_sint:
-        case Scalar::e_uint:
-        case Scalar::e_slong:
-        case Scalar::e_ulong:
-        case Scalar::e_slonglong:
-        case Scalar::e_ulonglong:
-        case Scalar::e_sint128:
-        case Scalar::e_uint128:
-            result.m_integer = a->m_integer & b->m_integer;  break;
+        case Scalar::e_sint:        result.m_data.sint      = a->m_data.sint        & b->m_data.sint;       break;
+        case Scalar::e_uint:        result.m_data.uint      = a->m_data.uint        & b->m_data.uint;       break;
+        case Scalar::e_slong:       result.m_data.slong     = a->m_data.slong       & b->m_data.slong;      break;
+        case Scalar::e_ulong:       result.m_data.ulong     = a->m_data.ulong       & b->m_data.ulong;      break;
+        case Scalar::e_slonglong:   result.m_data.slonglong = a->m_data.slonglong   & b->m_data.slonglong;  break;
+        case Scalar::e_ulonglong:   result.m_data.ulonglong = a->m_data.ulonglong   & b->m_data.ulonglong;  break;
+
         case Scalar::e_void:
         case Scalar::e_float:
         case Scalar::e_double:
@@ -2192,15 +1661,12 @@ lldb_private::operator| (const Scalar& lhs, const Scalar& rhs)
     {
         switch (result.m_type)
         {
-        case Scalar::e_sint:
-        case Scalar::e_uint:
-        case Scalar::e_slong:
-        case Scalar::e_ulong:
-        case Scalar::e_slonglong:
-        case Scalar::e_ulonglong:
-        case Scalar::e_sint128:
-        case Scalar::e_uint128:
-            result.m_integer = a->m_integer | b->m_integer;  break;
+        case Scalar::e_sint:        result.m_data.sint      = a->m_data.sint        | b->m_data.sint;       break;
+        case Scalar::e_uint:        result.m_data.uint      = a->m_data.uint        | b->m_data.uint;       break;
+        case Scalar::e_slong:       result.m_data.slong     = a->m_data.slong       | b->m_data.slong;      break;
+        case Scalar::e_ulong:       result.m_data.ulong     = a->m_data.ulong       | b->m_data.ulong;      break;
+        case Scalar::e_slonglong:   result.m_data.slonglong = a->m_data.slonglong   | b->m_data.slonglong;  break;
+        case Scalar::e_ulonglong:   result.m_data.ulonglong = a->m_data.ulonglong   | b->m_data.ulonglong;  break;
 
         case Scalar::e_void:
         case Scalar::e_float:
@@ -2226,23 +1692,12 @@ lldb_private::operator% (const Scalar& lhs, const Scalar& rhs)
         switch (result.m_type)
         {
         default:                    break;
-             case Scalar::e_void:            break;
-             case Scalar::e_sint:
-             case Scalar::e_uint:
-             case Scalar::e_slong:
-             case Scalar::e_ulong:
-             case Scalar::e_slonglong:
-             case Scalar::e_ulonglong:
-             case Scalar::e_sint128:
-             case Scalar::e_uint128:
-             {
-                 if (b->m_integer != 0)
-                 {
-                     result.m_integer = *a->m_integer.getRawData() % *b->m_integer.getRawData();
-                     return result;
-                 }
-                 break;
-             }
+        case Scalar::e_sint:        if (b->m_data.sint != 0)        {   result.m_data.sint      = a->m_data.sint        % b->m_data.sint;       return result;  }   break;
+        case Scalar::e_uint:        if (b->m_data.uint != 0)        {   result.m_data.uint      = a->m_data.uint        % b->m_data.uint;       return result;  }   break;
+        case Scalar::e_slong:       if (b->m_data.slong != 0)       {   result.m_data.slong     = a->m_data.slong       % b->m_data.slong;      return result;  }   break;
+        case Scalar::e_ulong:       if (b->m_data.ulong != 0)       {   result.m_data.ulong     = a->m_data.ulong       % b->m_data.ulong;      return result;  }   break;
+        case Scalar::e_slonglong:   if (b->m_data.slonglong != 0)   {   result.m_data.slonglong = a->m_data.slonglong   % b->m_data.slonglong;  return result;  }   break;
+        case Scalar::e_ulonglong:   if (b->m_data.ulonglong != 0)   {   result.m_data.ulonglong = a->m_data.ulonglong   % b->m_data.ulonglong;  return result;  }   break;
         }
     }
     result.m_type = Scalar::e_void;
@@ -2260,15 +1715,12 @@ lldb_private::operator^ (const Scalar& lhs, const Scalar& rhs)
     {
         switch (result.m_type)
         {
-        case Scalar::e_sint:
-        case Scalar::e_uint:
-        case Scalar::e_slong:
-        case Scalar::e_ulong:
-        case Scalar::e_slonglong:
-        case Scalar::e_ulonglong:
-        case Scalar::e_sint128:
-        case Scalar::e_uint128:
-            result.m_integer = a->m_integer ^ b->m_integer;  break;
+        case Scalar::e_sint:        result.m_data.sint      = a->m_data.sint        ^ b->m_data.sint;       break;
+        case Scalar::e_uint:        result.m_data.uint      = a->m_data.uint        ^ b->m_data.uint;       break;
+        case Scalar::e_slong:       result.m_data.slong     = a->m_data.slong       ^ b->m_data.slong;      break;
+        case Scalar::e_ulong:       result.m_data.ulong     = a->m_data.ulong       ^ b->m_data.ulong;      break;
+        case Scalar::e_slonglong:   result.m_data.slonglong = a->m_data.slonglong   ^ b->m_data.slonglong;  break;
+        case Scalar::e_ulonglong:   result.m_data.ulonglong = a->m_data.ulonglong   ^ b->m_data.ulonglong;  break;
 
         case Scalar::e_void:
         case Scalar::e_float:
@@ -2302,21 +1754,21 @@ lldb_private::operator>> (const Scalar& lhs, const Scalar &rhs)
 unsigned int
 Scalar::RawUInt () const
 {
-    return *(const uint_t *) m_integer.getRawData();
+    return m_data.uint;
 }
 
 // Return the raw unsigned long without any casting or conversion
 unsigned long
 Scalar::RawULong () const
 {
-    return *(const ulong_t *) m_integer.getRawData();
+    return m_data.ulong;
 }
 
 // Return the raw unsigned long long without any casting or conversion
 unsigned long long
 Scalar::RawULongLong () const
 {
-    return *(const ulonglong_t *) m_integer.getRawData();
+    return m_data.ulonglong;
 }
 
 
@@ -2349,9 +1801,9 @@ Scalar::SetValueFromCString (const char *value_str, Encoding encoding, size_t by
                 m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize (byte_size);
                 switch (m_type)
                 {
-                case e_uint:        m_integer = llvm::APInt(sizeof(uint_t) * 8, uval64, false);           break;
-                case e_ulong:       m_integer = llvm::APInt(sizeof(ulong_t) * 8, uval64, false);         break;
-                case e_ulonglong:   m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, uval64, false); break;
+                case e_uint:        m_data.uint = (uint_t)uval64;           break;
+                case e_ulong:       m_data.ulong = (ulong_t)uval64;         break;
+                case e_ulonglong:   m_data.ulonglong = (ulonglong_t)uval64; break;
                 default:
                     error.SetErrorStringWithFormat("unsupported unsigned integer byte size: %" PRIu64 "", (uint64_t)byte_size);
                     break;
@@ -2378,9 +1830,9 @@ Scalar::SetValueFromCString (const char *value_str, Encoding encoding, size_t by
                 m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize (byte_size);
                 switch (m_type)
                 {
-                case e_sint:        m_integer = llvm::APInt(sizeof(sint_t) * 8, sval64, true);           break;
-                case e_slong:       m_integer = llvm::APInt(sizeof(slong_t) * 8, sval64, true);         break;
-                case e_slonglong:   m_integer = llvm::APInt(sizeof(slonglong_t) * 8, sval64, true); break;
+                case e_sint:        m_data.sint = (sint_t)sval64;           break;
+                case e_slong:       m_data.slong = (slong_t)sval64;         break;
+                case e_slonglong:   m_data.slonglong = (slonglong_t)sval64; break;
                 default:
                     error.SetErrorStringWithFormat("unsupported signed integer byte size: %" PRIu64 "", (uint64_t)byte_size);
                     break;
@@ -2395,36 +1847,24 @@ Scalar::SetValueFromCString (const char *value_str, Encoding encoding, size_t by
         break;
 
     case eEncodingIEEE754:
-        static float f_val;
-        static double d_val;
-        static long double l_val;
         if (byte_size == sizeof (float))
         {
-            if (::sscanf (value_str, "%f", &f_val) == 1)
-            {
-                m_float = llvm::APFloat(f_val);
+            if (::sscanf (value_str, "%f", &m_data.flt) == 1)
                 m_type = e_float;
-            }
             else
                 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
         }
         else if (byte_size == sizeof (double))
         {
-            if (::sscanf (value_str, "%lf", &d_val) == 1)
-            {
-                m_float = llvm::APFloat(d_val);
+            if (::sscanf (value_str, "%lf", &m_data.dbl) == 1)
                 m_type = e_double;
-            }
             else
                 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
         }
         else if (byte_size == sizeof (long double))
         {
-            if (::sscanf (value_str, "%Lf", &l_val) == 1)
-            {
-                m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&l_val)->x));
+            if (::sscanf (value_str, "%Lf", &m_data.ldbl) == 1)
                 m_type = e_long_double;
-            }
             else
                 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
         }
@@ -2450,7 +1890,6 @@ Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t b
 {
     Error error;
     
-    type128 int128;
     switch (encoding)
     {
     case lldb::eEncodingInvalid:
@@ -2465,25 +1904,10 @@ Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t b
             
             switch (byte_size)
             {
-            case 1:  operator=((uint8_t)data.GetU8(&offset)); break;
-            case 2:  operator=((uint16_t)data.GetU16(&offset)); break;
-            case 4:  operator=((uint32_t)data.GetU32(&offset)); break;
-            case 8:  operator=((uint64_t)data.GetU64(&offset)); break;
-            case 16:
-            {
-                if (data.GetByteOrder() == eByteOrderBig)
-                {
-                    int128.x[1] = (uint64_t)data.GetU64 (&offset);
-                    int128.x[0] = (uint64_t)data.GetU64 (&offset + 1);
-                }
-                else
-                {
-                    int128.x[0] = (uint64_t)data.GetU64 (&offset);
-                    int128.x[1] = (uint64_t)data.GetU64 (&offset + 1);
-                }
-                operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
-                break;
-            }
+            case 1: operator=((uint8_t)data.GetU8(&offset)); break;
+            case 2: operator=((uint16_t)data.GetU16(&offset)); break;
+            case 4: operator=((uint32_t)data.GetU32(&offset)); break;
+            case 8: operator=((uint64_t)data.GetU64(&offset)); break;
             default:
                 error.SetErrorStringWithFormat("unsupported unsigned integer byte size: %" PRIu64 "", (uint64_t)byte_size);
                 break;
@@ -2500,21 +1924,6 @@ Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t b
             case 2: operator=((int16_t)data.GetU16(&offset)); break;
             case 4: operator=((int32_t)data.GetU32(&offset)); break;
             case 8: operator=((int64_t)data.GetU64(&offset)); break;
-            case 16:
-            {
-                if (data.GetByteOrder() == eByteOrderBig)
-                {
-                    int128.x[1] = (uint64_t)data.GetU64 (&offset);
-                    int128.x[0] = (uint64_t)data.GetU64 (&offset + 1);
-                }
-                else
-                {
-                    int128.x[0] = (uint64_t)data.GetU64 (&offset);
-                    int128.x[1] = (uint64_t)data.GetU64 (&offset + 1);
-                }
-                operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
-                break;
-            }
             default:
                 error.SetErrorStringWithFormat("unsupported signed integer byte size: %" PRIu64 "", (uint64_t)byte_size);
                 break;
@@ -2557,22 +1966,47 @@ Scalar::SignExtend (uint32_t sign_bit_pos)
             
         case Scalar::e_sint:            
         case Scalar::e_uint:
+            if (max_bit_pos == sign_bit_pos)
+                return true;
+            else if (sign_bit_pos < (max_bit_pos-1))
+            {
+                unsigned int sign_bit = 1u << sign_bit_pos;
+                if (m_data.uint & sign_bit)
+                {
+                    const unsigned int mask = ~(sign_bit) + 1u;
+                    m_data.uint |= mask;
+                }
+                return true;
+            }
+            break;
+            
         case Scalar::e_slong:
         case Scalar::e_ulong:
+            if (max_bit_pos == sign_bit_pos)
+                return true;
+            else if (sign_bit_pos < (max_bit_pos-1))
+            {
+                unsigned long sign_bit = 1ul << sign_bit_pos;
+                if (m_data.ulong & sign_bit)
+                {
+                    const unsigned long mask = ~(sign_bit) + 1ul;
+                    m_data.ulong |= mask;
+                }
+                return true;
+            }
+            break;
+            
         case Scalar::e_slonglong:
         case Scalar::e_ulonglong:
-        case Scalar::e_sint128:
-        case Scalar::e_uint128:
             if (max_bit_pos == sign_bit_pos)
                 return true;
             else if (sign_bit_pos < (max_bit_pos-1))
             {
-                llvm::APInt sign_bit = llvm::APInt::getSignBit(sign_bit_pos + 1);
-                llvm::APInt bitwize_and = m_integer & sign_bit;
-                if (bitwize_and.getBoolValue())
+                unsigned long long sign_bit = 1ull << sign_bit_pos;
+                if (m_data.ulonglong & sign_bit)
                 {
-                    const llvm::APInt mask = ~(sign_bit) + llvm::APInt(m_integer.getBitWidth(), 1);
-                    m_integer |= mask;
+                    const unsigned long long mask = ~(sign_bit) + 1ull;
+                    m_data.ulonglong |= mask;
                 }
                 return true;
             }
@@ -2619,40 +2053,66 @@ Scalar::ExtractBitfield (uint32_t bit_size,
 
     uint32_t msbit = bit_offset + bit_size - 1;
     uint32_t lsbit = bit_offset;
-    uint64_t result;
     switch (m_type)
     {
         case Scalar::e_void:
             break;
             
         case e_float:
-            result = SignedBits ((uint64_t )m_float.convertToFloat(), msbit, lsbit);
-            m_float = llvm::APFloat((float_t)result);
+            if (sizeof(m_data.flt) == sizeof(sint_t))
+                m_data.sint = (sint_t)SignedBits (m_data.sint, msbit, lsbit);
+            else if (sizeof(m_data.flt) == sizeof(ulong_t))
+                m_data.slong = (slong_t)SignedBits (m_data.slong, msbit, lsbit);
+            else if (sizeof(m_data.flt) == sizeof(ulonglong_t))
+                m_data.slonglong = (slonglong_t)SignedBits (m_data.slonglong, msbit, lsbit);
+            else
+                return false;
             return true;
+            
         case e_double:
-            result = SignedBits ((uint64_t )m_float.convertToDouble(), msbit, lsbit);
-            m_float = llvm::APFloat((double_t)result);
+            if (sizeof(m_data.dbl) == sizeof(sint_t))
+                m_data.sint = SignedBits (m_data.sint, msbit, lsbit);
+            else if (sizeof(m_data.dbl) == sizeof(ulong_t))
+                m_data.slong = SignedBits (m_data.slong, msbit, lsbit);
+            else if (sizeof(m_data.dbl) == sizeof(ulonglong_t))
+                m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit);
+            else
+                return false;
+            return true;
+            
         case e_long_double:
-            m_integer = m_float.bitcastToAPInt();
-            result = SignedBits (*m_integer.getRawData(), msbit, lsbit);
-            if(m_ieee_quad)
-                m_float = llvm::APFloat(llvm::APFloat::IEEEquad, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&result)->x));
+            if (sizeof(m_data.ldbl) == sizeof(sint_t))
+                m_data.sint = SignedBits (m_data.sint, msbit, lsbit);
+            else if (sizeof(m_data.ldbl) == sizeof(ulong_t))
+                m_data.slong = SignedBits (m_data.slong, msbit, lsbit);
+            else if (sizeof(m_data.ldbl) == sizeof(ulonglong_t))
+                m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit);
             else
-                m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&result)->x));
+                return false;
             return true;
             
         case Scalar::e_sint:
-        case Scalar::e_slong:
-        case Scalar::e_slonglong:
-        case Scalar::e_sint128:
-            m_integer = SignedBits (*m_integer.getRawData(), msbit, lsbit);
+            m_data.sint = (sint_t)SignedBits (m_data.sint, msbit, lsbit);
             return true;
 
         case Scalar::e_uint:
+            m_data.uint = (uint_t)UnsignedBits (m_data.uint, msbit, lsbit);
+            return true;
+            
+        case Scalar::e_slong:
+            m_data.slong = (slong_t)SignedBits (m_data.slong, msbit, lsbit);
+            return true;
+
         case Scalar::e_ulong:
+            m_data.ulong = (ulong_t)UnsignedBits (m_data.ulong, msbit, lsbit);
+            return true;
+            
+        case Scalar::e_slonglong:
+            m_data.slonglong = (slonglong_t)SignedBits (m_data.slonglong, msbit, lsbit);
+            return true;
+
         case Scalar::e_ulonglong:
-        case Scalar::e_uint128:
-            m_integer = UnsignedBits (*m_integer.getRawData(), msbit, lsbit);
+            m_data.ulonglong = (ulonglong_t)UnsignedBits (m_data.ulonglong, msbit, lsbit);
             return true;
     }
     return false;
@@ -2672,25 +2132,18 @@ lldb_private::operator== (const Scalar& lhs, const Scalar& rhs)
     Scalar temp_value;
     const Scalar* a;
     const Scalar* b;
-    llvm::APFloat::cmpResult result;
     switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
     {
     case Scalar::e_void:            break;
-    case Scalar::e_sint:
-    case Scalar::e_uint:
-    case Scalar::e_slong:
-    case Scalar::e_ulong:
-    case Scalar::e_slonglong:
-    case Scalar::e_ulonglong:
-    case Scalar::e_sint128:
-    case Scalar::e_uint128:
-        return a->m_integer == b->m_integer;
-    case Scalar::e_float:
-    case Scalar::e_double:
-    case Scalar::e_long_double:
-        result = a->m_float.compare(b->m_float);
-        if(result == llvm::APFloat::cmpEqual)
-            return true;
+    case Scalar::e_sint:            return a->m_data.sint       == b->m_data.sint;
+    case Scalar::e_uint:            return a->m_data.uint       == b->m_data.uint;
+    case Scalar::e_slong:           return a->m_data.slong      == b->m_data.slong;
+    case Scalar::e_ulong:           return a->m_data.ulong      == b->m_data.ulong;
+    case Scalar::e_slonglong:       return a->m_data.slonglong  == b->m_data.slonglong;
+    case Scalar::e_ulonglong:       return a->m_data.ulonglong  == b->m_data.ulonglong;
+    case Scalar::e_float:           return a->m_data.flt        == b->m_data.flt;
+    case Scalar::e_double:      return a->m_data.dbl        == b->m_data.dbl;
+    case Scalar::e_long_double: return a->m_data.ldbl       == b->m_data.ldbl;
     }
     return false;
 }
@@ -2705,25 +2158,18 @@ lldb_private::operator!= (const Scalar& lhs, const Scalar& rhs)
     Scalar temp_value;  // A temp value that might get a copy of either promoted value
     const Scalar* a;
     const Scalar* b;
-    llvm::APFloat::cmpResult result;
     switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
     {
     case Scalar::e_void:            break;
-    case Scalar::e_sint:
-    case Scalar::e_uint:
-    case Scalar::e_slong:
-    case Scalar::e_ulong:
-    case Scalar::e_slonglong:
-    case Scalar::e_ulonglong:
-    case Scalar::e_sint128:
-    case Scalar::e_uint128:
-        return a->m_integer != b->m_integer;
-    case Scalar::e_float:
-    case Scalar::e_double:
-    case Scalar::e_long_double:
-        result = a->m_float.compare(b->m_float);
-        if(result != llvm::APFloat::cmpEqual)
-            return true;
+    case Scalar::e_sint:            return a->m_data.sint       != b->m_data.sint;
+    case Scalar::e_uint:            return a->m_data.uint       != b->m_data.uint;
+    case Scalar::e_slong:           return a->m_data.slong      != b->m_data.slong;
+    case Scalar::e_ulong:           return a->m_data.ulong      != b->m_data.ulong;
+    case Scalar::e_slonglong:       return a->m_data.slonglong  != b->m_data.slonglong;
+    case Scalar::e_ulonglong:       return a->m_data.ulonglong  != b->m_data.ulonglong;
+    case Scalar::e_float:           return a->m_data.flt        != b->m_data.flt;
+    case Scalar::e_double:      return a->m_data.dbl        != b->m_data.dbl;
+    case Scalar::e_long_double: return a->m_data.ldbl       != b->m_data.ldbl;
     }
     return true;
 }
@@ -2737,25 +2183,18 @@ lldb_private::operator< (const Scalar& lhs, const Scalar& rhs)
     Scalar temp_value;
     const Scalar* a;
     const Scalar* b;
-    llvm::APFloat::cmpResult result;
     switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
     {
     case Scalar::e_void:            break;
-    case Scalar::e_sint:
-    case Scalar::e_uint:
-    case Scalar::e_slong:
-    case Scalar::e_ulong:
-    case Scalar::e_slonglong:
-    case Scalar::e_ulonglong:
-    case Scalar::e_sint128:
-    case Scalar::e_uint128:
-        return a->m_integer < b->m_integer;
-    case Scalar::e_float:
-    case Scalar::e_double:
-    case Scalar::e_long_double:
-        result = a->m_float.compare(b->m_float);
-        if(result == llvm::APFloat::cmpLessThan)
-            return true;
+    case Scalar::e_sint:            return a->m_data.sint       < b->m_data.sint;
+    case Scalar::e_uint:            return a->m_data.uint       < b->m_data.uint;
+    case Scalar::e_slong:           return a->m_data.slong      < b->m_data.slong;
+    case Scalar::e_ulong:           return a->m_data.ulong      < b->m_data.ulong;
+    case Scalar::e_slonglong:       return a->m_data.slonglong  < b->m_data.slonglong;
+    case Scalar::e_ulonglong:       return a->m_data.ulonglong  < b->m_data.ulonglong;
+    case Scalar::e_float:           return a->m_data.flt        < b->m_data.flt;
+    case Scalar::e_double:      return a->m_data.dbl        < b->m_data.dbl;
+    case Scalar::e_long_double: return a->m_data.ldbl       < b->m_data.ldbl;
     }
     return false;
 }
@@ -2769,25 +2208,18 @@ lldb_private::operator<= (const Scalar& lhs, const Scalar& rhs)
     Scalar temp_value;
     const Scalar* a;
     const Scalar* b;
-    llvm::APFloat::cmpResult result;
     switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
     {
     case Scalar::e_void:            break;
-    case Scalar::e_sint:
-    case Scalar::e_uint:
-    case Scalar::e_slong:
-    case Scalar::e_ulong:
-    case Scalar::e_slonglong:
-    case Scalar::e_ulonglong:
-    case Scalar::e_sint128:
-    case Scalar::e_uint128:
-        return a->m_integer <= b->m_integer;
-    case Scalar::e_float:
-    case Scalar::e_double:
-    case Scalar::e_long_double:
-        result = a->m_float.compare(b->m_float);
-        if(result == llvm::APFloat::cmpLessThan || result == llvm::APFloat::cmpEqual)
-            return true;
+    case Scalar::e_sint:            return a->m_data.sint       <= b->m_data.sint;
+    case Scalar::e_uint:            return a->m_data.uint       <= b->m_data.uint;
+    case Scalar::e_slong:           return a->m_data.slong      <= b->m_data.slong;
+    case Scalar::e_ulong:           return a->m_data.ulong      <= b->m_data.ulong;
+    case Scalar::e_slonglong:       return a->m_data.slonglong  <= b->m_data.slonglong;
+    case Scalar::e_ulonglong:       return a->m_data.ulonglong  <= b->m_data.ulonglong;
+    case Scalar::e_float:           return a->m_data.flt        <= b->m_data.flt;
+    case Scalar::e_double:      return a->m_data.dbl        <= b->m_data.dbl;
+    case Scalar::e_long_double: return a->m_data.ldbl       <= b->m_data.ldbl;
     }
     return false;
 }
@@ -2802,24 +2234,18 @@ lldb_private::operator> (const Scalar& lhs, const Scalar& rhs)
     Scalar temp_value;
     const Scalar* a;
     const Scalar* b;
-    llvm::APFloat::cmpResult result;
     switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
     {
-        case Scalar::e_void:            break;
-        case Scalar::e_sint:
-        case Scalar::e_uint:
-        case Scalar::e_slong:
-        case Scalar::e_ulong:
-        case Scalar::e_slonglong:
-        case Scalar::e_ulonglong:
-        case Scalar::e_sint128:
-        case Scalar::e_uint128:
-        case Scalar::e_float:
-        case Scalar::e_double:
-        case Scalar::e_long_double:
-        result = a->m_float.compare(b->m_float);
-        if(result == llvm::APFloat::cmpGreaterThan)
-            return true;
+    case Scalar::e_void:            break;
+    case Scalar::e_sint:            return a->m_data.sint       > b->m_data.sint;
+    case Scalar::e_uint:            return a->m_data.uint       > b->m_data.uint;
+    case Scalar::e_slong:           return a->m_data.slong      > b->m_data.slong;
+    case Scalar::e_ulong:           return a->m_data.ulong      > b->m_data.ulong;
+    case Scalar::e_slonglong:       return a->m_data.slonglong  > b->m_data.slonglong;
+    case Scalar::e_ulonglong:       return a->m_data.ulonglong  > b->m_data.ulonglong;
+    case Scalar::e_float:           return a->m_data.flt        > b->m_data.flt;
+    case Scalar::e_double:      return a->m_data.dbl        > b->m_data.dbl;
+    case Scalar::e_long_double: return a->m_data.ldbl       > b->m_data.ldbl;
     }
     return false;
 }
@@ -2833,137 +2259,22 @@ lldb_private::operator>= (const Scalar& lhs, const Scalar& rhs)
     Scalar temp_value;
     const Scalar* a;
     const Scalar* b;
-    llvm::APFloat::cmpResult result;
     switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
     {
-        case Scalar::e_void:            break;
-        case Scalar::e_sint:
-        case Scalar::e_uint:
-        case Scalar::e_slong:
-        case Scalar::e_ulong:
-        case Scalar::e_slonglong:
-        case Scalar::e_ulonglong:
-        case Scalar::e_sint128:
-        case Scalar::e_uint128:
-            return a->m_integer <= b->m_integer;
-        case Scalar::e_float:
-        case Scalar::e_double:
-        case Scalar::e_long_double:
-        result = a->m_float.compare(b->m_float);
-        if(result == llvm::APFloat::cmpGreaterThan || result == llvm::APFloat::cmpEqual)
-            return true;
+    case Scalar::e_void:            break;
+    case Scalar::e_sint:            return a->m_data.sint       >= b->m_data.sint;
+    case Scalar::e_uint:            return a->m_data.uint       >= b->m_data.uint;
+    case Scalar::e_slong:           return a->m_data.slong      >= b->m_data.slong;
+    case Scalar::e_ulong:           return a->m_data.ulong      >= b->m_data.ulong;
+    case Scalar::e_slonglong:       return a->m_data.slonglong  >= b->m_data.slonglong;
+    case Scalar::e_ulonglong:       return a->m_data.ulonglong  >= b->m_data.ulonglong;
+    case Scalar::e_float:           return a->m_data.flt        >= b->m_data.flt;
+    case Scalar::e_double:      return a->m_data.dbl        >= b->m_data.dbl;
+    case Scalar::e_long_double: return a->m_data.ldbl       >= b->m_data.ldbl;
     }
     return false;
 }
 
-bool
-Scalar::ClearBit (uint32_t bit)
-{
-    switch (m_type)
-    {
-    case e_void:
-        break;
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128: m_integer.clearBit(bit); return true;
-    case e_float:
-    case e_double:
-    case e_long_double: break;
-    }
-    return false;
-}
 
-bool
-Scalar::SetBit (uint32_t bit)
-{
-    switch (m_type)
-    {
-    case e_void:
-        break;
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128: m_integer.setBit(bit); return true;
-    case e_float:
-    case e_double:
-    case e_long_double: break;
-    }
-    return false;
-}
 
-void
-Scalar::SetType (const RegisterInfo *reg_info)
-{
-    const uint32_t byte_size = reg_info->byte_size;
-    switch (reg_info->encoding)
-    {
-        case eEncodingInvalid:
-            break;
-        case eEncodingUint:
-            if (byte_size == 1 || byte_size == 2 || byte_size == 4)
-            {
-                m_integer = llvm::APInt(sizeof(uint_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
-                m_type = e_uint;
-            }
-            if (byte_size == 8)
-            {
-                m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
-                m_type = e_ulonglong;
-            }
-            if (byte_size == 16)
-            {
-                m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData())->x);
-                m_type = e_uint128;
-            }
-            break;
-        case eEncodingSint:
-            if (byte_size == 1 || byte_size == 2 || byte_size == 4)
-            {
-                m_integer = llvm::APInt(sizeof(sint_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
-                m_type = e_sint;
-            }
-            if (byte_size == 8)
-            {
-                m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
-                m_type = e_slonglong;
-            }
-            if (byte_size == 16)
-            {
-                m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData())->x);
-                m_type = e_sint128;
-            }
-            break;
-        case eEncodingIEEE754:
-            if (byte_size == sizeof(float))
-            {
-                m_float = llvm::APFloat(m_float.convertToFloat());
-                m_type = e_float;
-            }
-            else if (byte_size == sizeof(double))
-            {
-                m_float = llvm::APFloat(m_float.convertToDouble());
-                m_type = e_double;
-            }
-            else if (byte_size == sizeof(long double))
-            {
-                if(m_ieee_quad)
-                     m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_float.bitcastToAPInt());
-                 else
-                     m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_float.bitcastToAPInt());
-                m_type = e_long_double;
-            }
-            break;
-        case eEncodingVector:
-            m_type = e_void;
-            break;
-    }
-}
+
diff --git a/lldb/source/Core/ValueObject.cpp b/lldb/source/Core/ValueObject.cpp
index 90e73c44088..3d757bd4a07 100644
--- a/lldb/source/Core/ValueObject.cpp
+++ b/lldb/source/Core/ValueObject.cpp
@@ -1897,7 +1897,7 @@ ValueObject::SetValueFromCString (const char *value_str, Error& error)
         // If the value is already a scalar, then let the scalar change itself:
         m_value.GetScalar().SetValueFromCString (value_str, encoding, byte_size);
     }
-    else if (byte_size <= 16)
+    else if (byte_size <= Scalar::GetMaxByteSize())
     {
         // If the value fits in a scalar, then make a new scalar and again let the
         // scalar code do the conversion, then figure out where to put the new value.