[LLDB][MIPS] Fix offsets of all register sets and add MSA regset and FRE=1 mode support.

[slthakur]

Summary

This patch :

• Fixes offsets of all register sets for Mips.
• Adds MSA register set and FRE=1 mode support for FP register set.
• Separates lldb register numbers and register infos of freebsd/mips64 from linux/mips64.
• Re-orders the register numbers of all kinds for mips to be consistent with freebsd order of register numbers.
• Eliminates ENABLE_128_BIT_SUPPORT and union ValueData from Scalar.cpp and uses llvm::APInt and llvm::APFloat for all integer and floating point types.

[slthakur]

Removed #if define ENABLE_128_BIT_SUPPORT from reg infos and UserArea structure as it is not required there.

[clayborg]

I haven't been too happy about our current 128 bit integer support (before this patch). We should probably try to fix this in a way that works on all platforms and get rid of the ENABLE_128_BIT_SUPPORT all together. We can probably use a llvm::APInt in lldb_private::Scalar and get support for integers of any size. We just need to convert many of the functions in lldb_private::Scalar to use the llvm::APInt class and implement the C type promotion rules correctly when using this class. Because if you make a MIPS debugger on a 32 bit system, we don't want the debugger to fail to show certain types or perform DWARF expressions (since they use a stack of lldb_private::Value objects which contain a lldb_private::Scalar objects)...

It would be great to take care of so the debugger doesn't just drop some types on the floor when there is no 128 bit integer support natively on the current machine running LLDB.

[slthakur]

• Used llvm:APInt for 128 bit integers as suggested by @clayborg.

[clayborg]

So Scalar can switch to using llvm::APInt for all integer values. Right now there are functions that assign and use llvm::APInt, but they don't guarantee that these llvm::APInt values are actually 128 bit. We should be able to switch over for all integers. So this:

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;
};

Could end up being:

llvm::APInt m_integer;
llvm::APFloat m_float;

We get rid of the union here since they are classes. Then we should be able to update all the code to use the "m_integer" or "m_float" to represent integers and floats of any size. We just need to implement type promotion and ensure that it works for signed/unsigned types correctly...

[slthakur]

• Eliminated ValueData from Scalar and used llvm::APInt and llvm::APFloat for all integer and floating point types.

[slthakur]

Increasing patch context and adding #defines for constants

[clayborg]

Great stuff in Scalar. One more thing to fix is that RegisterValue should probably get rid of its union and use have the following ivars:

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;

This would simplify a bunch of stuff in RegisterValue where it had its own union. Then any use of "m_data.uintXXX" or "m_data.ieee_XXX" in RegisterValue should use m_scalar. If we can encapsulate that, this should be good to go.

include/lldb/Core/Scalar.h

118–119

We shouldn't need this function anymore. APInt can support integers of any size...

346

Why do we need m_long_double?

[slthakur]

Hi,

One more thing to fix is that RegisterValue should probably get rid of its union and use have the following ivars:

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;

This would simplify a bunch of stuff in RegisterValue where it had its own union. Then any use of "m_data.uintXXX" or >"m_data.ieee_XXX" in RegisterValue should use m_scalar.

I will updated the patch with the required changes in RegisterValue. Thanks for the comments.

include/lldb/Core/Scalar.h

346

I could not see a generic float semantic for long doubles in llvm::APFloat.
The two semantics that support long doubles are x87DoubleExtended and IEEEquad.
How do I distinguish between these two semantics according to architecture in Scalar?
Could I use IEEEquad for all architectures?

[clayborg]

We should detect the float type from the architecture. We might need to specify an extra parameter when setting a Scalar to a long double and specify if it is to use the x87DoubleExtended or IEEEquad. Each clang::ASTContext already has been setup with a correct architecture and the clang::ASTContext has the float semantics for each different type. We should require clients of Scalar to properly specify the type of float, or only allow people to set float values in the Scalar class using llvm::APFloat. This would leave it up to the user to set the float correctly using the float semantics in the clang::ASTContext before setting the value into the Scalar...

include/lldb/Core/Scalar.h

57–59

Possible solution here is to:

• change all these constructors over to take a llvm::APFloat
• change the long double constructor to also take a bool that indicates if this should be an x87DoubleExtended or IEEEquad...

[slthakur]

Addressed review comments

[slthakur]

• Removed Scalar::GetMaxByteSize() function.
• Removed SetType() from Scalar as it is not needed there.
• Fixed some code in NativeRegisterContextLinux_mips64.cpp.

[clayborg]

Thanks for bearing with me and fixing everything. Looks good.

[slthakur]

Committed in revision 244308

[ovyalov]

Hi,

This CL caused bunch of tests to fail - http://lab.llvm.org:8011/builders/lldb-x86_64-ubuntu-14.04-cmake/builds/4949
For example, TestLldbGdbServer.py is failing on Linux x86_64 - it seems, GPR value is sent as 8-byte value regardless of register's size - for example:

0000000000000000 - 32, {'set': 'General Purpose Registers', 'name': 'eax', 'format': 'hex', 'bitsize': '32', 'encoding': 'uint', 'container-regs': '0', 'offset': '80'}
0000000000000000 - 8, {'set': 'General Purpose Registers', 'name': 'ah', 'format': 'hex', 'bitsize': '8', 'encoding': 'uint', 'container-regs': '0', 'offset': '81'}

It sued to be:
00000000 - 32, {'set': 'General Purpose Registers', 'name': 'eax', 'format': 'hex', 'bitsize': '32', 'encoding': 'uint', 'container-regs': '0', 'offset': '80'}
00 - 8, {'set': 'General Purpose Registers', 'name': 'ah', 'format': 'hex', 'bitsize': '8', 'encoding': 'uint', 'container-regs': '0', 'offset': '81'}

Could you take a look into this failures or revert CL for now?

[ovyalov]

In D10919#220901, @ovyalov wrote:

Hi,

This CL caused bunch of tests to fail - http://lab.llvm.org:8011/builders/lldb-x86_64-ubuntu-14.04-cmake/builds/4949
For example, TestLldbGdbServer.py is failing on Linux x86_64 - it seems, GPR value is sent as 8-byte value regardless of register's size - for example:

0000000000000000 - 32, {'set': 'General Purpose Registers', 'name': 'eax', 'format': 'hex', 'bitsize': '32', 'encoding': 'uint', 'container-regs': '0', 'offset': '80'}
0000000000000000 - 8, {'set': 'General Purpose Registers', 'name': 'ah', 'format': 'hex', 'bitsize': '8', 'encoding': 'uint', 'container-regs': '0', 'offset': '81'}

It sued to be:
00000000 - 32, {'set': 'General Purpose Registers', 'name': 'eax', 'format': 'hex', 'bitsize': '32', 'encoding': 'uint', 'container-regs': '0', 'offset': '80'}
00 - 8, {'set': 'General Purpose Registers', 'name': 'ah', 'format': 'hex', 'bitsize': '8', 'encoding': 'uint', 'container-regs': '0', 'offset': '81'}

Could you take a look into this failures or revert CL for now?

I reverted the CL with http://reviews.llvm.org/rL244514 since it was causing multiple test regressions - feel free to re-submit it with fixed Linux tests.

[slthakur]

Fixed failures reported by Oleksiy

[slthakur]

Hi Oleksiy,

Revert r244308 since it's introducing test regressions on Linux:

• TestLldbGdbServer.py both clang & gcc, i386 and x86_64
• TestConstVariables.py gcc, i386 and x86_64
• 112 failures clang, i386

• TestLldbGdbServer.py both clang & gcc, i386 and x86_64
  
  This test was failing because Scalar objects type was not set properly when we set the type of RegisterValue. I have added the SetType function in Scalar now which fixes this failure.

• TestConstVariables.py gcc, i386 and x86_64
  
  This test was failing only with gcc because gcc produces DW_OP_const2u which causes it to create a Scalar of short type for variable index.

  1684         case DW_OP_const1u             :    stack.push_back(Scalar(( uint8_t)opcodes.GetU8 (&offset))); break;
  1685         case DW_OP_const1s             :    stack.push_back(Scalar((  int8_t)opcodes.GetU8 (&offset))); break;
->1686         case DW_OP_const2u             :    stack.push_back(Scalar((uint16_t)opcodes.GetU16 (&offset))); break;
  1687         case DW_OP_const2s             :    stack.push_back(Scalar(( int16_t)opcodes.GetU16 (&offset))); break;
  1688         case DW_OP_const4u             :    stack.push_back(Scalar((uint32_t)opcodes.GetU32 (&offset))); break;

Because of this the size of ValueObject is less than the size of variable index. I have now updated Scalar class to use int for all 1 byte, 2 byte and 4 byte integers. This fixes TestConstVariables.py with gcc.

• 112 failures clang, i386
  
  I couldn’t see any failures with clang, i386. I am using the following command for testing i386 arch : python ./dosep.py -o "-A i386 --executable /home/sagar/LLDB_x86/build/bin/lldb -t -v" Is there anything wrong in the way I am testing ?

[tberghammer]

• 112 failures clang, i386
  
  I couldn’t see any failures with clang, i386. I am using the following command for testing i386 arch : python ./dosep.py -o "-A i386 --executable /home/sagar/LLDB_x86/build/bin/lldb -t -v" Is there anything wrong in the way I am testing ?

I haven't tried it out, but based on your command I guess you are using a 32bit LLDB with 32bit inferiors and the failures Oleksiy mentioned are happening when you run 64bit LLDB with 32bit inferiors (this is the configuration what is tested by the build bot).

[emaste]

Applied to my tree and testing now.

Is it possible/reasonable to submit this in two parts, the value changes first, and then the MIPS changes?

as an aside git apply complained about whitespace errors, but I think many/all of these already existed prior to your change:

<stdin>:68: trailing whitespace.
        RegisterValue (llvm::APInt inst) : 
<stdin>:161: trailing whitespace.
            m_scalar = llvm::APInt(uint); 
<stdin>:292: trailing whitespace.
        struct 
<stdin>:348: trailing whitespace.
    Scalar(long double v, bool ieee_quad) 
<stdin>:356: trailing whitespace.
    Scalar(llvm::APInt v) : 
warning: squelched 15 whitespace errors
warning: 20 lines add whitespace errors.

include/lldb/Core/RegisterValue.h

83

Example line with reported whitespace issue

[emaste]

Test suite passes on FreeBSD with this change.

I did see a failure in a couple of runs, but these have a long history of very occasional intermittent failures for me, and I can't really make any claim about them with respect to this patch.

Ran 388 test suites (0 failed) (0.000000%)
Ran 288 test cases (0 failed) (0.000000%)
      145.36 real       621.10 user       181.65 sys

Failing Tests (1)
FAIL: LLDB (suite) :: TestMultithreaded.py (FreeBSD feynman 10.1-STABLE FreeBSD 10.1-STABLE #28 r280427+86df2de(stable-10): Thu Mar 26 16:07:47 EDT 2015     emaste@feynman:/tank/emaste/obj/tank/emaste/src/git-stable-10/sys/GENERIC amd64 amd64)

Failing Tests (1)
FAIL: LLDB (suite) :: TestEvents.py (FreeBSD feynman 10.1-STABLE FreeBSD 10.1-STABLE #28 r280427+86df2de(stable-10): Thu Mar 26 16:07:47 EDT 2015     emaste@feynman:/tank/emaste/obj/tank/emaste/src/git-stable-10/sys/GENERIC amd64 amd64)

[slthakur]

Hi,

@tberghammer: The LLDB I am using is 64-bit. And the tests are getting compiled with the -m32 option with the command I gave, so the inferiors are 32-bit.

@emaste: Thanks for the review. It is reasonable to commit the generic part and the MIPS part separately. I will also clear the white spaces before committing.

[tberghammer]

I tried out your change with i386 and "Patch #7" have a lot of failure, but "Patch #8" fixes all of them

[slthakur]

Hi,

Since all tests are passing with Patch #8 and if everyone is okay with it, may I commit it in two parts:

1. Scalar and RegisterValue changes.
2. MIPS MSA register context part.

[tberghammer]

In D10919#225481, @Sagar wrote:

Hi,

Since all tests are passing with Patch #8 and if everyone is okay with it, may I commit it in two parts:

1. Scalar and RegisterValue changes.
2. MIPS MSA register context part.

Yes please go for it.

[slthakur]

Committed scalar and register value part in r245216

[slthakur]

Committed MIPS MSA register context part in r245217

include/lldb/Core/RegisterValue.h

 #include <string.h>
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #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
     {
     public:
         enum
         {
             kMaxRegisterByteSize = 32u
         };
         enum Type
         {
             eTypeInvalid,
             eTypeUInt8,
             eTypeUInt16,
             eTypeUInt32,
             eTypeUInt64,
-#if defined (ENABLE_128_BIT_SUPPORT)
             eTypeUInt128,
-#endif
             eTypeFloat,
             eTypeDouble,
             eTypeLongDouble,
             eTypeBytes
         };
         
         RegisterValue () : 
             m_type (eTypeInvalid)
         {
+            m_scalar = (unsigned long)0;
         }
 
         explicit 
         RegisterValue (uint8_t inst) : 
             m_type (eTypeUInt8)
         {
-            m_data.uint8 = inst;
+            m_scalar = inst;
         }
 
         explicit 
         RegisterValue (uint16_t inst) : 
             m_type (eTypeUInt16)
         {
-            m_data.uint16 = inst;
+            m_scalar = inst;
         }
 
         explicit 
         RegisterValue (uint32_t inst) : 
             m_type (eTypeUInt32)
         {
-            m_data.uint32 = inst;
+            m_scalar = inst;
         }
 
         explicit 
         RegisterValue (uint64_t inst) : 
             m_type (eTypeUInt64)
         {
-            m_data.uint64 = inst;
+            m_scalar = inst;
         }
 
-#if defined (ENABLE_128_BIT_SUPPORT)
         explicit 
-        RegisterValue (__uint128_t inst) : 
+        RegisterValue (llvm::APInt inst) : 
             m_type (eTypeUInt128)
         {
-            m_data.uint128 = inst;
+            m_scalar = llvm::APInt(inst);
         }
-#endif        
         explicit 
         RegisterValue (float value) : 
             m_type (eTypeFloat)
         {
-            m_data.ieee_float = value;
+            m_scalar = value;
         }
 
         explicit 
         RegisterValue (double value) : 
             m_type (eTypeDouble)
         {
-            m_data.ieee_double = value;
+            m_scalar = value;
         }
 
         explicit 
         RegisterValue (long double value) : 
             m_type (eTypeLongDouble)
         {
-            m_data.ieee_long_double = value;
+            m_scalar = value;
         }
 
         explicit 
         RegisterValue (uint8_t *bytes, size_t length, lldb::ByteOrder byte_order)
         {
             SetBytes (bytes, length, byte_order);
         }
 
public:
 
         uint8_t
         GetAsUInt8 (uint8_t fail_value = UINT8_MAX, bool *success_ptr = NULL) const
         {
             if (m_type == eTypeUInt8)
             {
                 if (success_ptr)
                     *success_ptr = true;                
-                return m_data.uint8;
+                return m_scalar.UChar(fail_value);
             }
             if (success_ptr)
                 *success_ptr = true;
             return fail_value;
         }
 
         uint16_t
         GetAsUInt16 (uint16_t fail_value = UINT16_MAX, bool *success_ptr = NULL) const;
 
         uint32_t
         GetAsUInt32 (uint32_t fail_value = UINT32_MAX, bool *success_ptr = NULL) const;
 
         uint64_t
         GetAsUInt64 (uint64_t fail_value = UINT64_MAX, bool *success_ptr = NULL) const;
 
-#if defined (ENABLE_128_BIT_SUPPORT)
-        __uint128_t
-        GetAsUInt128 (__uint128_t fail_value = ~((__uint128_t)0), bool *success_ptr = NULL) const;
-#endif
+        llvm::APInt
+        GetAsUInt128 (llvm::APInt& fail_value, bool *success_ptr = NULL) const;
 
         float
         GetAsFloat (float fail_value = 0.0f, bool *success_ptr = NULL) const;
 
         double
         GetAsDouble (double fail_value = 0.0, bool *success_ptr = NULL) const;
 
         long double
public:
 
         bool
         operator != (const RegisterValue &rhs) const;
 
         void
         operator = (uint8_t uint)
         {
             m_type = eTypeUInt8;
-            m_data.uint8 = uint;
+            m_scalar = uint;
         }
 
         void
         operator = (uint16_t uint)
         {
             m_type = eTypeUInt16;
-            m_data.uint16 = uint;
+            m_scalar = uint;
         }
 
         void
         operator = (uint32_t uint)
         {
             m_type = eTypeUInt32;
-            m_data.uint32 = uint;
+            m_scalar = uint;
         }
 
         void
         operator = (uint64_t uint)
         {
             m_type = eTypeUInt64;
-            m_data.uint64 = uint;
+            m_scalar = uint;
         }
 
-#if defined (ENABLE_128_BIT_SUPPORT)
         void
-        operator = (__uint128_t uint)
+        operator = (llvm::APInt uint)
         {
             m_type = eTypeUInt128;
-            m_data.uint128 = uint;
+            m_scalar = llvm::APInt(uint); 
         }
-#endif        
+
         void
         operator = (float f)
         {
             m_type = eTypeFloat;
-            m_data.ieee_float = f;
+            m_scalar = f;
         }
 
         void
         operator = (double f)
         {
             m_type = eTypeDouble;
-            m_data.ieee_double = f;
+            m_scalar = f;
         }
 
         void
         operator = (long double f)
         {
             m_type = eTypeLongDouble;
-            m_data.ieee_long_double = f;
+            m_scalar = f;
         }
 
         void
         SetUInt8 (uint8_t uint)
         {
             m_type = eTypeUInt8;
-            m_data.uint8 = uint;
+            m_scalar = uint;
         }
 
         void
         SetUInt16 (uint16_t uint)
         {
             m_type = eTypeUInt16;
-            m_data.uint16 = uint;
+            m_scalar = uint;
         }
 
         void
         SetUInt32 (uint32_t uint, Type t = eTypeUInt32)
         {
             m_type = t;
-            m_data.uint32 = uint;
+            m_scalar = uint;
         }
 
         void
         SetUInt64 (uint64_t uint, Type t = eTypeUInt64)
         {
             m_type = t;
-            m_data.uint64 = uint;
+            m_scalar = uint;
         }
 
-#if defined (ENABLE_128_BIT_SUPPORT)
         void
-        SetUInt128 (__uint128_t uint)
+        SetUInt128 (llvm::APInt uint)
         {
             m_type = eTypeUInt128;
-            m_data.uint128 = uint;
+            m_scalar = llvm::APInt(uint);
         }
-#endif
         bool
         SetUInt (uint64_t uint, uint32_t byte_size);
     
         void
         SetFloat (float f)
         {
             m_type = eTypeFloat;
-            m_data.ieee_float = f;
+            m_scalar = f;
         }
 
         void
         SetDouble (double f)
         {
             m_type = eTypeDouble;
-            m_data.ieee_double = f;
+            m_scalar = f;
         }
 
         void
         SetLongDouble (long double f)
         {
             m_type = eTypeLongDouble;
-            m_data.ieee_long_double = f;
+            m_scalar = f;
         }
 
         void
         SetBytes (const void *bytes, size_t length, lldb::ByteOrder byte_order);
 
         bool
         SignExtend (uint32_t sign_bitpos);
 
public:
         
         const void *
         GetBytes () const;
 
         lldb::ByteOrder
         GetByteOrder () const
         {
             if (m_type == eTypeBytes)
-                return m_data.buffer.byte_order;
+                return buffer.byte_order;
             return lldb::endian::InlHostByteOrder();
         }
         
         uint32_t
         GetByteSize () const;
 
         static uint32_t
         GetMaxByteSize ()
         {
             return kMaxRegisterByteSize;
         }
 
         void
         Clear();
 
     protected:
 
         RegisterValue::Type m_type;
-        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;
+        Scalar m_scalar;
     };
 
 } // namespace lldb_private
 
 #endif  // lldb_RegisterValue_h

include/lldb/Core/Scalar.h

 //===-- Scalar.h ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_Scalar_h_
 #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 {
 
 //----------------------------------------------------------------------
 // A class designed to hold onto values and their corresponding types.
 // Operators are defined and Scalar objects will correctly promote
 // their types and values before performing these operations. Type
 // promotion currently follows the ANSI C type promotion rules.
 //----------------------------------------------------------------------
 class Scalar
 {
 public:
     enum Type
     {
         e_void = 0,
         e_sint,
         e_uint,
         e_slong,
         e_ulong,
         e_slonglong,
         e_ulonglong,
         e_float,
         e_double,
-        e_long_double
+        e_long_double,
+        e_uint128,
+        e_sint128
     };
 
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
     Scalar();
-    Scalar(int v)               : m_type(e_sint),           m_data() { m_data.sint      = v; }
-    Scalar(unsigned int v)      : m_type(e_uint),           m_data() { m_data.uint      = v; }
-    Scalar(long v)              : m_type(e_slong),          m_data() { m_data.slong     = v; }
-    Scalar(unsigned long v)     : m_type(e_ulong),          m_data() { m_data.ulong     = v; }
-    Scalar(long long v)         : m_type(e_slonglong),      m_data() { m_data.slonglong = v; }
-    Scalar(unsigned long long v): m_type(e_ulonglong),      m_data() { m_data.ulonglong = v; }
-    Scalar(float v)             : m_type(e_float),          m_data() { m_data.flt       = v; }
-    Scalar(double v)            : m_type(e_double),         m_data() { m_data.dbl       = v; }
-    Scalar(long double v)       : m_type(e_long_double),    m_data() { m_data.ldbl      = v; }
+    Scalar(int v)               : m_type(e_sint),        m_float((float)0) { m_integer = llvm::APInt(sizeof(int) * 8, v, true);}
+    Scalar(unsigned int v)      : m_type(e_uint),        m_float((float)0) { m_integer = llvm::APInt(sizeof(int) * 8, v);}
+    Scalar(long v)              : m_type(e_slong),       m_float((float)0) { m_integer = llvm::APInt(sizeof(long) * 8, v, true);}
+    Scalar(unsigned long v)     : m_type(e_ulong),       m_float((float)0) { m_integer = llvm::APInt(sizeof(long) * 8, v);}
+    Scalar(long long v)         : m_type(e_slonglong),   m_float((float)0) { m_integer = llvm::APInt(sizeof(long long) * 8, v, true);}
+    Scalar(unsigned long long v): m_type(e_ulonglong),   m_float((float)0) { m_integer = llvm::APInt(sizeof(long long) * 8, v);}
+    Scalar(float v)             : m_type(e_float),       m_float(v) { m_float   = llvm::APFloat(v); }
+    Scalar(double v)            : m_type(e_double),      m_float(v) { m_float   = llvm::APFloat(v); }
+    Scalar(long double v, bool ieee_quad) 
+        : m_type(e_long_double), m_float((float)0), m_ieee_quad(ieee_quad)
+        {
+            if(ieee_quad)
+                m_float = llvm::APFloat(llvm::APFloat::IEEEquad, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
+            else
+                m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
+        }
+    Scalar(llvm::APInt v) : 
+        m_type(),
+        m_float((float)0)
+        {
+            m_integer = llvm::APInt(v);
+            switch(m_integer.getBitWidth())
+            {
+            case 8:
+            case 16:
+            case 32:
+                if(m_integer.isSignedIntN(sizeof(sint_t) * 8))
+                    m_type = e_sint;
+                else
+                    m_type = e_uint;
+                break;
+            case 64:
+                if(m_integer.isSignedIntN(sizeof(slonglong_t) * 8))
+                    m_type = e_slonglong;
+                else
+                    m_type = e_ulonglong;
+                break;
+            case 128:
+                if(m_integer.isSignedIntN(BITWIDTH_INT128))
+                    m_type = e_sint128;
+                else
+                    m_type = e_uint128;
+                break;
+            }
+        }
     Scalar(const Scalar& rhs);
     //Scalar(const RegisterValue& reg_value);
     virtual ~Scalar();
 
     bool
     SignExtend (uint32_t bit_pos);
 
     bool
     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;
 
     size_t
     GetAsMemoryData (void *dst,
                      size_t dst_len, 
                      lldb::ByteOrder dst_byte_order,
                      Error &error) const;
 
     bool
     IsZero() const;
 
     void
-    Clear() { m_type = e_void; m_data.ulonglong = 0; }
+    Clear() { m_type = e_void; m_integer.clearAllBits(); }
 
     const char *
     GetTypeAsCString() const;
 
     void
     GetValue (Stream *s, bool show_type) const;
 
     bool
public:
     Scalar& operator= (unsigned int v);
     Scalar& operator= (long v);
     Scalar& operator= (unsigned long v);
     Scalar& operator= (long long v);
     Scalar& operator= (unsigned long long v);
     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
     Scalar& operator>>= (const Scalar& rhs);    // Shift right (arithmetic)
     Scalar& operator&= (const Scalar& rhs);
 
     //----------------------------------------------------------------------
     // Shifts the current value to the right without maintaining the current
public:
     OnesComplement();                       // Returns true on success
 
     //----------------------------------------------------------------------
     // Access the type of the current value.
     //----------------------------------------------------------------------
     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
     // of the value is void or invalid.
     //----------------------------------------------------------------------
     int
     SInt(int fail_value = 0) const;
 
     // Return the raw unsigned integer without any casting or conversion
     unsigned int
     RawUInt () const;
 
     // Return the raw unsigned long without any casting or conversion
     unsigned long
     RawULong () const;
 
     // Return the raw unsigned long long without any casting or conversion
     unsigned long long
     RawULongLong () const;
 
+    unsigned char
+    UChar(unsigned char fail_value = 0) const;
+
+    char
+    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;
 
     long
     SLong(long fail_value = 0) const;
 
     unsigned long
     ULong(unsigned long fail_value = 0) const;
 
     long long
     SLongLong(long long fail_value = 0) const;
 
     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;
 
     double
     Double(double fail_value = 0.0) const;
 
     long double
     LongDouble(long double fail_value = 0.0) const;
SIntValueIsValidForSize (int64_t sval64, size_t total_byte_size)
             return true;
 
         const int64_t max = ((int64_t)1 << (uint64_t)(total_byte_size * 8 - 1)) - 1;
         const int64_t min = ~(max);
         return min <= sval64 && sval64 <= max;
     }
 
 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;
     typedef unsigned long       ulong_t;
     typedef long long           slonglong_t;
     typedef unsigned long long  ulonglong_t;
     typedef float               float_t;
     typedef double              double_t;
     typedef long double         long_double_t;
     
-    union ValueData
-    {
-        int                 sint;
-        unsigned int        uint;
-        long                slong;
-        unsigned long       ulong;
-        long long           slonglong;
-        unsigned long long  ulonglong;
-        float               flt;
-        double              dbl;
-        long double         ldbl;
-    };
-
     //------------------------------------------------------------------
     // Classes that inherit from Scalar can see and modify these
     //------------------------------------------------------------------
     Scalar::Type m_type;
-    ValueData m_data;
+    llvm::APInt m_integer;
+    llvm::APFloat m_float;
+    bool m_ieee_quad = false;
 
 private:
     friend const Scalar operator+   (const Scalar& lhs, const Scalar& rhs);
     friend const Scalar operator-   (const Scalar& lhs, const Scalar& rhs);
     friend const Scalar operator/   (const Scalar& lhs, const Scalar& rhs);
     friend const Scalar operator*   (const Scalar& lhs, const Scalar& rhs);
     friend const Scalar operator&   (const Scalar& lhs, const Scalar& rhs);
     friend const Scalar operator|   (const Scalar& lhs, const Scalar& rhs);

include/lldb/Core/Value.h

SetBytes(const void *bytes, size_t length, lldb::ByteOrder byte_order)
         bool
     IsValid() const 
     {
             return (length > 0 && length < kMaxByteSize && byte_order != lldb::eByteOrderInvalid);
         }
         // 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 
     {
             Scalar scalar;
             if (IsValid())
             {
                 if (length == 1) scalar = *(const uint8_t *)bytes;
                 else if (length == 2) scalar = *(const uint16_t *)bytes;
                 else if (length == 4) scalar = *(const uint32_t *)bytes;
                 else if (length == 8) scalar = *(const uint64_t *)bytes;
-#if defined (ENABLE_128_BIT_SUPPORT)
-                else if (length >= 16) scalar = *(const __uint128_t *)bytes;
-#else
-                else if (length >= 16) scalar = *(const uint64_t *)bytes;
-#endif
+                else if (length >= 16) scalar = rhs;
             }
             return scalar;
         }
     };
 
     Value();
     Value(const Scalar& scalar);
     Value(const Vector& vector);

include/lldb/lldb-private-types.h

struct OptionDefinition
         OptionValidator* validator;              // If non-NULL, option is valid iff |validator->IsValid()|, otherwise always valid.
         OptionEnumValueElement *enum_values;     // If non-NULL an array of enum values.
         uint32_t completion_type;                // Cookie the option class can use to do define the argument completion.
         lldb::CommandArgumentType argument_type; // Type of argument this option takes
         const char *usage_text;                  // Full text explaining what this options does and what (if any) argument to
                                                  // pass it.
     };
 
+    typedef struct type128 { uint64_t x[2]; } type128;
+
 } // namespace lldb_private
 
 #endif  // #if defined(__cplusplus)
 
 #endif  // liblldb_lldb_private_types_h_

source/Core/RegisterValue.cpp

RegisterValue::SetFromMemoryData (const RegisterInfo *reg_info,
     if (value_type == eTypeInvalid)        
     {
         // No value has been read into this object...
         error.SetErrorStringWithFormat("invalid register value type for register %s", reg_info->name);
         return 0;
     }
     else if (value_type == eTypeBytes)
     {
-        m_data.buffer.byte_order = src_byte_order;
+        buffer.byte_order = src_byte_order;
         // Make sure to set the buffer length of the destination buffer to avoid
-        // problems due to uninitialized variables.
-        m_data.buffer.length = src_len;
+        // problems due to uninitalized variables.
+        buffer.length = src_len;
     }
 
     const uint32_t bytes_copied = src_data.CopyByteOrderedData (0,               // src offset
                                                                 src_len,         // src length
                                                                 GetBytes(),      // dst buffer
                                                                 GetByteSize(),   // dst length
                                                                 GetByteOrder()); // dst byte order
     if (bytes_copied == 0)
         error.SetErrorStringWithFormat("failed to copy data for register write of %s", reg_info->name);
 
     return bytes_copied;
 }
 
 bool
 RegisterValue::GetScalarValue (Scalar &scalar) const
 {
     switch (m_type)
     {
         case eTypeInvalid:      break;
         case eTypeBytes:
         {
-            switch (m_data.buffer.length)
+            switch (buffer.length)
             {
             default:    break;
-            case 1:     scalar = m_data.uint8; return true;
-            case 2:     scalar = m_data.uint16; return true;
-            case 4:     scalar = m_data.uint32; return true;
-            case 8:     scalar = m_data.uint64; return true;
-            }
-        }
-        case eTypeUInt8:        scalar = m_data.uint8; return true;
-        case eTypeUInt16:       scalar = m_data.uint16; return true;
-        case eTypeUInt32:       scalar = m_data.uint32; return true;
-        case eTypeUInt64:       scalar = m_data.uint64; return true;
-#if defined (ENABLE_128_BIT_SUPPORT)
-        case eTypeUInt128:      break;
-#endif
-        case eTypeFloat:        scalar = m_data.ieee_float; return true;
-        case eTypeDouble:       scalar = m_data.ieee_double; return true;
-        case eTypeLongDouble:   scalar = m_data.ieee_long_double; return true;
+            case 1:     scalar = *(const uint8_t *)buffer.bytes; return true;
+            case 2:     scalar = *(const uint16_t *)buffer.bytes; return true;
+            case 4:     scalar = *(const uint32_t *)buffer.bytes; return true;
+            case 8:     scalar = *(const uint64_t *)buffer.bytes; return true;
+            }
+        }
+        case eTypeUInt8:
+        case eTypeUInt16:
+        case eTypeUInt32:
+        case eTypeUInt64:
+        case eTypeUInt128:
+        case eTypeFloat:
+        case eTypeDouble:
+        case eTypeLongDouble:   scalar = m_scalar; return true;
     }
     return false;
 }
 
 void
 RegisterValue::Clear()
 {
     m_type = eTypeInvalid;
switch (reg_info->encoding)
             if (byte_size == 1)
                 m_type = eTypeUInt8;
             else if (byte_size <= 2)
                 m_type = eTypeUInt16;
             else if (byte_size <= 4)
                 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:
             if (byte_size == sizeof(float))
                 m_type = eTypeFloat;
             else if (byte_size == sizeof(double))
                 m_type = eTypeDouble;
             else if (byte_size == sizeof(long double))
                 m_type = eTypeLongDouble;
             break;
 
         case eEncodingVector:
             m_type = eTypeBytes;
             break;
     }
+    m_scalar.SetType(reg_info);
     return m_type;
 }
 
 Error
 RegisterValue::SetValueFromData (const RegisterInfo *reg_info, DataExtractor &src, lldb::offset_t src_offset, bool partial_data_ok)
 {
     Error error;
     
RegisterValue::SetValueFromData (const RegisterInfo *reg_info, DataExtractor &src, lldb::offset_t src_offset, bool partial_data_ok)
     }
         
     // Cap the data length if there is more than enough bytes for this register
     // value
     if (src_len > reg_info->byte_size)
         src_len = reg_info->byte_size;
 
     // Zero out the value in case we get partial data...
-    memset (m_data.buffer.bytes, 0, sizeof (m_data.buffer.bytes));
-    
+    memset (buffer.bytes, 0, sizeof (buffer.bytes));
+    type128 int128; 
     switch (SetType (reg_info))
     {
         case eTypeInvalid:
             error.SetErrorString("");
             break;
         case eTypeUInt8:    SetUInt8  (src.GetMaxU32 (&src_offset, src_len)); break;
         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)
-                    SetUInt128 (data1 << 64 + data2);
+                {
+                    int128.x[1] = src.GetU64 (&src_offset + 1);
+                    int128.x[0] = src.GetU64 (&src_offset);
+                }
                 else
-                    SetUInt128 (data2 << 64 + data1);
+                {
+                    int128.x[0] = src.GetU64 (&src_offset);
+                    int128.x[1] = src.GetU64 (&src_offset + 1);
+                }
+                SetUInt128 (llvm::APInt(128, 2, int128.x));
             }
             break;
-#endif
         case eTypeFloat:        SetFloat (src.GetFloat (&src_offset));      break;
         case eTypeDouble:       SetDouble(src.GetDouble (&src_offset));     break;
         case eTypeLongDouble:   SetFloat (src.GetLongDouble (&src_offset)); break;
         case eTypeBytes:
         {
-            m_data.buffer.length = reg_info->byte_size;
-            m_data.buffer.byte_order = src.GetByteOrder();
-            assert (m_data.buffer.length <= kMaxRegisterByteSize);
-            if (m_data.buffer.length > kMaxRegisterByteSize)
-                m_data.buffer.length = kMaxRegisterByteSize;
+            buffer.length = reg_info->byte_size;
+            buffer.byte_order = src.GetByteOrder();
+            assert (buffer.length <= kMaxRegisterByteSize);
+            if (buffer.length > kMaxRegisterByteSize)
+                buffer.length = kMaxRegisterByteSize;
             if (src.CopyByteOrderedData (src_offset,                    // offset within "src" to start extracting data
                                          src_len,                       // src length
-                                         m_data.buffer.bytes,           // dst buffer
-                                         m_data.buffer.length,          // dst length
-                                         m_data.buffer.byte_order) == 0)// dst byte order
+                                         buffer.bytes,           // dst buffer
+                                         buffer.length,          // dst length
+                                         buffer.byte_order) == 0)// dst byte order
             {
                 error.SetErrorString ("data copy failed data.");
                 return error;
             }
         }
     }
     
     return error;
RegisterValue::SetValueFromCString (const RegisterInfo *reg_info, const char *value_str)
 
     if (value_str == NULL || value_str[0] == '\0')
     {
         error.SetErrorString ("Invalid c-string value string.");
         return error;
     }
     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:
             error.SetErrorString ("Invalid encoding.");
             break;
             
         case eEncodingUint:
             if (byte_size <= sizeof (uint64_t))
switch (reg_info->encoding)
                 error.SetErrorStringWithFormat ("unsupported signed integer byte size: %u", byte_size);
                 return error;
             }
             break;
             
         case eEncodingIEEE754:
             if (byte_size == sizeof (float))
             {
-                if (::sscanf (value_str, "%f", &m_data.ieee_float) == 1)
+                if (::sscanf (value_str, "%f", &flt_val) == 1)
+                {
+                    m_scalar = flt_val;
                     m_type = eTypeFloat;
+                }
                 else
                     error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
             }
             else if (byte_size == sizeof (double))
             {
-                if (::sscanf (value_str, "%lf", &m_data.ieee_double) == 1)
+                if (::sscanf (value_str, "%lf", &dbl_val) == 1)
+                {
+                    m_scalar = dbl_val;
                     m_type = eTypeDouble;
+                }
                 else
                     error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
             }
             else if (byte_size == sizeof (long double))
             {
-                if (::sscanf (value_str, "%Lf", &m_data.ieee_long_double) == 1)
+                if (::sscanf (value_str, "%Lf", &ldbl_val) == 1)
+                {
+                    m_scalar = ldbl_val;
                     m_type = eTypeLongDouble;
+                }
                 else
                     error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
             }
             else
             {
                 error.SetErrorStringWithFormat ("unsupported float byte size: %u", byte_size);
                 return error;
             }

 RegisterValue::SignExtend (uint32_t sign_bitpos)
 {
     switch (m_type)
     {
         case eTypeInvalid:
             break;
 
         case eTypeUInt8:        
-            if (sign_bitpos == (8-1))
-                return true;
-            else if (sign_bitpos < (8-1))
-            {
-                uint8_t sign_bit = 1u << sign_bitpos;
-                if (m_data.uint8 & sign_bit)
-                {
-                    const uint8_t mask = ~(sign_bit) + 1u;
-                    m_data.uint8 |= mask;
-                }
-                return true;
-            }
-            break;
-
         case eTypeUInt16:
-            if (sign_bitpos == (16-1))
-                return true;
-            else if (sign_bitpos < (16-1))
-            {
-                uint16_t sign_bit = 1u << sign_bitpos;
-                if (m_data.uint16 & sign_bit)
-                {
-                    const uint16_t mask = ~(sign_bit) + 1u;
-                    m_data.uint16 |= mask;
-                }
-                return true;
-            }
-            break;
-        
         case eTypeUInt32:
-            if (sign_bitpos == (32-1))
-                return true;
-            else if (sign_bitpos < (32-1))
-            {
-                uint32_t sign_bit = 1u << sign_bitpos;
-                if (m_data.uint32 & sign_bit)
-                {
-                    const uint32_t mask = ~(sign_bit) + 1u;
-                    m_data.uint32 |= mask;
-                }
-                return true;
-            }
-            break;
-
         case eTypeUInt64:
-            if (sign_bitpos == (64-1))
-                return true;
-            else if (sign_bitpos < (64-1))
-            {
-                uint64_t sign_bit = 1ull << sign_bitpos;
-                if (m_data.uint64 & sign_bit)
-                {
-                    const uint64_t mask = ~(sign_bit) + 1ull;
-                    m_data.uint64 |= mask;
-                }
-                return true;
-            }
-            break;
-
-#if defined (ENABLE_128_BIT_SUPPORT)
         case eTypeUInt128:
-            if (sign_bitpos == (128-1))
-                return true;
-            else if (sign_bitpos < (128-1))
-            {
-                __uint128_t sign_bit = (__uint128_t)1u << sign_bitpos;
-                if (m_data.uint128 & sign_bit)
-                {
-                    const uint128_t mask = ~(sign_bit) + 1u;
-                    m_data.uint128 |= mask;
-                }
-                return true;
-            }
-            break;
-#endif
+            return m_scalar.SignExtend(sign_bitpos);
         case eTypeFloat:
         case eTypeDouble:
         case eTypeLongDouble:
         case eTypeBytes:
             break;
     }
     return false;
 }
 
 bool
 RegisterValue::CopyValue (const RegisterValue &rhs)
 {
     m_type = rhs.m_type;
     switch (m_type)
     {
         case eTypeInvalid: 
             return false;
-        case eTypeUInt8:        m_data.uint8 = rhs.m_data.uint8; break;
-        case eTypeUInt16:       m_data.uint16 = rhs.m_data.uint16; break;
-        case eTypeUInt32:       m_data.uint32 = rhs.m_data.uint32; break;
-        case eTypeUInt64:       m_data.uint64 = rhs.m_data.uint64; break;
-#if defined (ENABLE_128_BIT_SUPPORT)
-        case eTypeUInt128:      m_data.uint128 = rhs.m_data.uint128; break;
-#endif
-        case eTypeFloat:        m_data.ieee_float = rhs.m_data.ieee_float; break;
-        case eTypeDouble:       m_data.ieee_double = rhs.m_data.ieee_double; break;
-        case eTypeLongDouble:   m_data.ieee_long_double = rhs.m_data.ieee_long_double; break;
+        case eTypeUInt8:
+        case eTypeUInt16:
+        case eTypeUInt32:
+        case eTypeUInt64:
+        case eTypeUInt128:
+        case eTypeFloat:
+        case eTypeDouble:
+        case eTypeLongDouble:   m_scalar = rhs.m_scalar; break;
         case eTypeBytes:        
-            assert (rhs.m_data.buffer.length <= kMaxRegisterByteSize);
-            ::memcpy (m_data.buffer.bytes, rhs.m_data.buffer.bytes, kMaxRegisterByteSize);
-            m_data.buffer.length = rhs.m_data.buffer.length;
-            m_data.buffer.byte_order = rhs.m_data.buffer.byte_order;
+            assert (rhs.buffer.length <= kMaxRegisterByteSize);
+            ::memcpy (buffer.bytes, rhs.buffer.bytes, kMaxRegisterByteSize);
+            buffer.length = rhs.buffer.length;
+            buffer.byte_order = rhs.buffer.byte_order;
             break;
     }
     return true;
 }
 
 uint16_t
 RegisterValue::GetAsUInt16 (uint16_t fail_value, bool *success_ptr) const
 {
     if (success_ptr)
         *success_ptr = true;
     
     switch (m_type)
     {
         default:            break;
-        case eTypeUInt8:    return m_data.uint8;
-        case eTypeUInt16:   return m_data.uint16;
+        case eTypeUInt8:
+        case eTypeUInt16:   return m_scalar.UShort(fail_value);
         case eTypeBytes:
         {
-            switch (m_data.buffer.length)
+            switch (buffer.length)
             {
             default:    break;
-            case 1:     return m_data.uint8;
-            case 2:     return m_data.uint16;
+            case 1:
+            case 2:     return *(const uint16_t *)buffer.bytes;
             }
         }
         break;
     }
     if (success_ptr)
         *success_ptr = false;
     return fail_value;
 }
 
 uint32_t
 RegisterValue::GetAsUInt32 (uint32_t fail_value, bool *success_ptr) const
 {
     if (success_ptr)
         *success_ptr = true;
     switch (m_type)
     {
         default:            break;
-        case eTypeUInt8:    return m_data.uint8;
-        case eTypeUInt16:   return m_data.uint16;
-        case eTypeUInt32:   return m_data.uint32;
+        case eTypeUInt8:
+        case eTypeUInt16:
+        case eTypeUInt32:
         case eTypeFloat:
-            if (sizeof(float) == sizeof(uint32_t))
-                return m_data.uint32;
-            break;
         case eTypeDouble:
-            if (sizeof(double) == sizeof(uint32_t))
-                return m_data.uint32;
-            break;
-        case eTypeLongDouble:
-            if (sizeof(long double) == sizeof(uint32_t))
-                return m_data.uint32;
-            break;
+        case eTypeLongDouble:   return m_scalar.UInt(fail_value);
         case eTypeBytes:
         {
-            switch (m_data.buffer.length)
+            switch (buffer.length)
             {
             default:    break;
-            case 1:     return m_data.uint8;
-            case 2:     return m_data.uint16;
-            case 4:     return m_data.uint32;
+            case 1:
+            case 2:
+            case 4:     return *(const uint32_t *)buffer.bytes;
             }
         }
         break;
     }
     if (success_ptr)
         *success_ptr = false;
     return fail_value;
 }
 
 uint64_t
 RegisterValue::GetAsUInt64 (uint64_t fail_value, bool *success_ptr) const
 {
     if (success_ptr)
         *success_ptr = true;
     switch (m_type)
     {
         default:            break;
-        case eTypeUInt8:    return m_data.uint8;
-        case eTypeUInt16:   return m_data.uint16;
-        case eTypeUInt32:   return m_data.uint32;
-        case eTypeUInt64:   return m_data.uint64;
+        case eTypeUInt8:
+        case eTypeUInt16:
+        case eTypeUInt32:
+        case eTypeUInt64:
         case eTypeFloat:
-            if (sizeof(float) == sizeof(uint64_t))
-                return m_data.uint64;
-            break;
         case eTypeDouble:
-            if (sizeof(double) == sizeof(uint64_t))
-                return m_data.uint64;
-            break;
-        case eTypeLongDouble:
-            if (sizeof(long double) == sizeof(uint64_t))
-                return m_data.uint64;
-            break;
+        case eTypeLongDouble: return m_scalar.ULongLong(fail_value);
         case eTypeBytes:
         {
-            switch (m_data.buffer.length)
+            switch (buffer.length)
             {
             default:    break;
-            case 1:     return m_data.uint8;
-            case 2:     return m_data.uint16;
-            case 4:     return m_data.uint32;
-            case 8:     return m_data.uint64;
+            case 1:
+            case 2:
+            case 4:
+            case 8:     return *(const uint64_t *)buffer.bytes;
             }
         }
         break;
     }
     if (success_ptr)
         *success_ptr = false;
     return fail_value;
 }
 
-#if defined (ENABLE_128_BIT_SUPPORT)
-__uint128_t
-RegisterValue::GetAsUInt128 (__uint128_t fail_value, bool *success_ptr) const
+llvm::APInt 
+RegisterValue::GetAsUInt128 (llvm::APInt& fail_value, bool *success_ptr) const
 {
     if (success_ptr)
         *success_ptr = true;
     switch (m_type)
     {
         default:            break;
-        case eTypeUInt8:    return m_data.uint8;
-        case eTypeUInt16:   return m_data.uint16;
-        case eTypeUInt32:   return m_data.uint32;
-        case eTypeUInt64:   return m_data.uint64;
-        case eTypeUInt128:  return m_data.uint128;
+        case eTypeUInt8:
+        case eTypeUInt16:
+        case eTypeUInt32:
+        case eTypeUInt64:
+        case eTypeUInt128:
         case eTypeFloat:
-            if (sizeof(float) == sizeof(__uint128_t))
-                return m_data.uint128;
-            break;
         case eTypeDouble:
-            if (sizeof(double) == sizeof(__uint128_t))
-                return m_data.uint128;
-            break;
-        case eTypeLongDouble:
-            if (sizeof(long double) == sizeof(__uint128_t))
-                return m_data.uint128;
-            break;
+        case eTypeLongDouble:  return m_scalar.UInt128(fail_value);
         case eTypeBytes:
         {
-            switch (m_data.buffer.length)
+            switch (buffer.length)
             {
                 default:
                     break;
-            case 1:     return m_data.uint8;
-            case 2:     return m_data.uint16;
-            case 4:     return m_data.uint32;
-            case 8:     return m_data.uint64;
-            case 16:    return m_data.uint128;
+                case 1:
+                case 2:
+                case 4:
+                case 8:
+                case 16:
+                {
+                    return llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)buffer.bytes)->x);
+                }
             }
         }
         break;
     }
     if (success_ptr)
         *success_ptr = false;
     return fail_value;
 }
-#endif
+
 float
 RegisterValue::GetAsFloat (float fail_value, bool *success_ptr) const
 {
     if (success_ptr)
         *success_ptr = true;
     switch (m_type)
     {
         default:            break;
         case eTypeUInt32:
-            if (sizeof(float) == sizeof(m_data.uint32))
-                return m_data.ieee_float;
-            break;
         case eTypeUInt64:
-            if (sizeof(float) == sizeof(m_data.uint64))
-                return m_data.ieee_float;
-            break;
-#if defined (ENABLE_128_BIT_SUPPORT)
         case eTypeUInt128:
-            if (sizeof(float) == sizeof(m_data.uint128))
-                return m_data.ieee_float;
-            break;
-#endif
-        case eTypeFloat:    return m_data.ieee_float;
+        case eTypeFloat:
         case eTypeDouble:
-            if (sizeof(float) == sizeof(double))
-                return m_data.ieee_float;
-            break;
         case eTypeLongDouble:
-            if (sizeof(float) == sizeof(long double))
-                return m_data.ieee_float;
-            break;
+            return m_scalar.Float(fail_value);
     }
     if (success_ptr)
         *success_ptr = false;
     return fail_value;
 }
 
 double
 RegisterValue::GetAsDouble (double fail_value, bool *success_ptr) const
 {
     if (success_ptr)
         *success_ptr = true;
     switch (m_type)
     {
         default:            
             break;
             
         case eTypeUInt32:
-            if (sizeof(double) == sizeof(m_data.uint32))
-                return m_data.ieee_double;
-            break;
-            
         case eTypeUInt64:
-            if (sizeof(double) == sizeof(m_data.uint64))
-                return m_data.ieee_double;
-            break;
-            
-#if defined (ENABLE_128_BIT_SUPPORT)
         case eTypeUInt128:
-            if (sizeof(double) == sizeof(m_data.uint128))
-                return m_data.ieee_double;
-#endif
-        case eTypeFloat:    return m_data.ieee_float;
-        case eTypeDouble:   return m_data.ieee_double;
-            
+        case eTypeFloat:
+        case eTypeDouble:
         case eTypeLongDouble:
-            if (sizeof(double) == sizeof(long double))
-                return m_data.ieee_double;
-            break;
+            return m_scalar.Double(fail_value);
     }
     if (success_ptr)
         *success_ptr = false;
     return fail_value;
 }
 
 long double
 RegisterValue::GetAsLongDouble (long double fail_value, bool *success_ptr) const
 {
     if (success_ptr)
         *success_ptr = true;
     switch (m_type)
     {
         default:
             break;
             
         case eTypeUInt32:
-            if (sizeof(long double) == sizeof(m_data.uint32))
-                return m_data.ieee_long_double;
-            break;
-            
         case eTypeUInt64:
-            if (sizeof(long double) == sizeof(m_data.uint64))
-                return m_data.ieee_long_double;
-            break;
-            
-#if defined (ENABLE_128_BIT_SUPPORT)
         case eTypeUInt128:
-            if (sizeof(long double) == sizeof(m_data.uint128))
-                return m_data.ieee_long_double;
-#endif
-        case eTypeFloat:        return m_data.ieee_float;
-        case eTypeDouble:       return m_data.ieee_double;
-        case eTypeLongDouble:   return m_data.ieee_long_double;
-            break;
+        case eTypeFloat:
+        case eTypeDouble:
+        case eTypeLongDouble:
+            return m_scalar.LongDouble();
     }
     if (success_ptr)
         *success_ptr = false;
     return fail_value;
 }
 
 const void *
 RegisterValue::GetBytes () const
 {
     switch (m_type)
     {
         case eTypeInvalid:      break;
-        case eTypeUInt8:        return &m_data.uint8;
-        case eTypeUInt16:       return &m_data.uint16;
-        case eTypeUInt32:       return &m_data.uint32;
-        case eTypeUInt64:       return &m_data.uint64;
-#if defined (ENABLE_128_BIT_SUPPORT)
-        case eTypeUInt128:      return &m_data.uint128;
-#endif
-        case eTypeFloat:        return &m_data.ieee_float;
-        case eTypeDouble:       return &m_data.ieee_double;
-        case eTypeLongDouble:   return &m_data.ieee_long_double;
-        case eTypeBytes:        return m_data.buffer.bytes;
+        case eTypeUInt8:
+        case eTypeUInt16:
+        case eTypeUInt32:
+        case eTypeUInt64:
+        case eTypeUInt128:
+        case eTypeFloat:
+        case eTypeDouble:
+        case eTypeLongDouble:   return m_scalar.GetBytes();
+        case eTypeBytes:        return buffer.bytes;
     }
     return NULL;
 }
 
 void *
 RegisterValue::GetBytes ()
 {
     switch (m_type)
     {
         case eTypeInvalid:      break;
-        case eTypeUInt8:        return &m_data.uint8;
-        case eTypeUInt16:       return &m_data.uint16;
-        case eTypeUInt32:       return &m_data.uint32;
-        case eTypeUInt64:       return &m_data.uint64;
-#if defined (ENABLE_128_BIT_SUPPORT)
-        case eTypeUInt128:      return &m_data.uint128;
-#endif
-        case eTypeFloat:        return &m_data.ieee_float;
-        case eTypeDouble:       return &m_data.ieee_double;
-        case eTypeLongDouble:   return &m_data.ieee_long_double;
-        case eTypeBytes:        return m_data.buffer.bytes;
+        case eTypeUInt8:
+        case eTypeUInt16:
+        case eTypeUInt32:
+        case eTypeUInt64:
+        case eTypeUInt128:
+        case eTypeFloat:
+        case eTypeDouble:
+        case eTypeLongDouble:   return m_scalar.GetBytes();
+        case eTypeBytes:        return buffer.bytes;
     }
     return NULL;
 }
 
 uint32_t
 RegisterValue::GetByteSize () const
 {
     switch (m_type)
     {
         case eTypeInvalid: break;
-        case eTypeUInt8:        return sizeof(m_data.uint8);
-        case eTypeUInt16:       return sizeof(m_data.uint16);
-        case eTypeUInt32:       return sizeof(m_data.uint32);
-        case eTypeUInt64:       return sizeof(m_data.uint64);
-#if defined (ENABLE_128_BIT_SUPPORT)
-        case eTypeUInt128:      return sizeof(m_data.uint128);
-#endif
-        case eTypeFloat:        return sizeof(m_data.ieee_float);
-        case eTypeDouble:       return sizeof(m_data.ieee_double);
-        case eTypeLongDouble:   return sizeof(m_data.ieee_long_double);
-        case eTypeBytes: return m_data.buffer.length;
+        case eTypeUInt8:   return 1;
+        case eTypeUInt16:  return 2;
+        case eTypeUInt32:
+        case eTypeUInt64:
+        case eTypeUInt128:
+        case eTypeFloat:
+        case eTypeDouble:
+        case eTypeLongDouble: return m_scalar.GetByteSize();
+        case eTypeBytes: return buffer.length;
     }
     return 0;
 }
 
 
 bool
 RegisterValue::SetUInt (uint64_t uint, uint32_t byte_size)
 {
RegisterValue::SetUInt (uint64_t uint, uint32_t byte_size)
     else if (byte_size <= 4)
     {
         SetUInt32 (uint);
     }
     else if (byte_size <= 8)
     {
         SetUInt64 (uint);
     }
-#if defined (ENABLE_128_BIT_SUPPORT)
     else if (byte_size <= 16)
     {
-        SetUInt128 (uint);
+        SetUInt128 (llvm::APInt(64, uint));
     }
-#endif
     else
         return false;
     return true;
 }
 
 void
 RegisterValue::SetBytes (const void *bytes, size_t length, lldb::ByteOrder byte_order)
 {
     // If this assertion fires off we need to increase the size of
-    // m_data.buffer.bytes, or make it something that is allocated on
+    // buffer.bytes, or make it something that is allocated on
     // the heap. Since the data buffer is in a union, we can't make it
     // a collection class like SmallVector...
     if (bytes && length > 0)
     {
-        assert (length <= sizeof (m_data.buffer.bytes) && "Storing too many bytes in a RegisterValue.");
+        assert (length <= sizeof (buffer.bytes) && "Storing too many bytes in a RegisterValue.");
         m_type = eTypeBytes;
-        m_data.buffer.length = length;
-        memcpy (m_data.buffer.bytes, bytes, length);
-        m_data.buffer.byte_order = byte_order;
+        buffer.length = length;
+        memcpy (buffer.bytes, bytes, length);
+        buffer.byte_order = byte_order;
     }
     else
     {
         m_type = eTypeInvalid;
-        m_data.buffer.length = 0;
+        buffer.length = 0;
     }
 }
 
 
 bool
 RegisterValue::operator == (const RegisterValue &rhs) const
 {
     if (m_type == rhs.m_type)
     {
         switch (m_type)
         {
             case eTypeInvalid:      return true;
-            case eTypeUInt8:        return m_data.uint8 == rhs.m_data.uint8;
-            case eTypeUInt16:       return m_data.uint16 == rhs.m_data.uint16;
-            case eTypeUInt32:       return m_data.uint32 == rhs.m_data.uint32;
-            case eTypeUInt64:       return m_data.uint64 == rhs.m_data.uint64;
-#if defined (ENABLE_128_BIT_SUPPORT)
-            case eTypeUInt128:      return m_data.uint128 == rhs.m_data.uint128;
-#endif
-            case eTypeFloat:        return m_data.ieee_float == rhs.m_data.ieee_float;
-            case eTypeDouble:       return m_data.ieee_double == rhs.m_data.ieee_double;
-            case eTypeLongDouble:   return m_data.ieee_long_double == rhs.m_data.ieee_long_double;
+            case eTypeUInt8:
+            case eTypeUInt16:
+            case eTypeUInt32:
+            case eTypeUInt64:
+            case eTypeUInt128:
+            case eTypeFloat:
+            case eTypeDouble:
+            case eTypeLongDouble:   return m_scalar == rhs.m_scalar;
             case eTypeBytes:        
-                if (m_data.buffer.length != rhs.m_data.buffer.length)
+                if (buffer.length != rhs.buffer.length)
                     return false;
                 else
                 {
-                    uint8_t length = m_data.buffer.length;
+                    uint8_t length = buffer.length;
                     if (length > kMaxRegisterByteSize)
                         length = kMaxRegisterByteSize;
-                    return memcmp (m_data.buffer.bytes, rhs.m_data.buffer.bytes, length) == 0;
+                    return memcmp (buffer.bytes, rhs.buffer.bytes, length) == 0;
                 }
                 break;
         }
     }
     return false;
 }
 
 bool
 RegisterValue::operator != (const RegisterValue &rhs) const
 {
     if (m_type != rhs.m_type)
         return true;
     switch (m_type)
     {
         case eTypeInvalid:      return false;
-        case eTypeUInt8:        return m_data.uint8 != rhs.m_data.uint8;
-        case eTypeUInt16:       return m_data.uint16 != rhs.m_data.uint16;
-        case eTypeUInt32:       return m_data.uint32 != rhs.m_data.uint32;
-        case eTypeUInt64:       return m_data.uint64 != rhs.m_data.uint64;
-#if defined (ENABLE_128_BIT_SUPPORT)
-        case eTypeUInt128:      return m_data.uint128 != rhs.m_data.uint128;
-#endif
-        case eTypeFloat:        return m_data.ieee_float != rhs.m_data.ieee_float;
-        case eTypeDouble:       return m_data.ieee_double != rhs.m_data.ieee_double;
-        case eTypeLongDouble:   return m_data.ieee_long_double != rhs.m_data.ieee_long_double;
+        case eTypeUInt8:
+        case eTypeUInt16:
+        case eTypeUInt32:
+        case eTypeUInt64:
+        case eTypeUInt128:
+        case eTypeFloat:
+        case eTypeDouble:
+        case eTypeLongDouble:   return m_scalar != rhs.m_scalar;
         case eTypeBytes:        
-            if (m_data.buffer.length != rhs.m_data.buffer.length)
+            if (buffer.length != rhs.buffer.length)
             {
                 return true;
             }
             else
             {
-                uint8_t length = m_data.buffer.length;
+                uint8_t length = buffer.length;
                 if (length > kMaxRegisterByteSize)
                     length = kMaxRegisterByteSize;
-                return memcmp (m_data.buffer.bytes, rhs.m_data.buffer.bytes, length) != 0;
+                return memcmp (buffer.bytes, rhs.buffer.bytes, length) != 0;
             }
             break;
     }
     return true;
 }
 
 bool
 RegisterValue::ClearBit (uint32_t bit)
 {
     switch (m_type)
     {
         case eTypeInvalid:
             break;
 
-        case eTypeUInt8:        
-            if (bit < 8)
-            {
-                m_data.uint8 &= ~(1u << bit);
-                return true;
-            }
-            break;
-            
+        case eTypeUInt8:
         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:
-            if (bit < 64)
-            {
-                m_data.uint64 &= ~(1ull << (uint64_t)bit);
-                return true;
-            }
-            break;
-#if defined (ENABLE_128_BIT_SUPPORT)
         case eTypeUInt128:
-            if (bit < 64)
+            if (bit < (GetByteSize() * 8))
             {
-                m_data.uint128 &= ~((__uint128_t)1ull << (__uint128_t)bit);
-                return true;
+                return m_scalar.ClearBit(bit);
             }
-#endif
+            break;
+
         case eTypeFloat:
         case eTypeDouble:
         case eTypeLongDouble:
             break;
 
         case eTypeBytes:
-            if (m_data.buffer.byte_order == eByteOrderBig || m_data.buffer.byte_order == eByteOrderLittle)
+            if (buffer.byte_order == eByteOrderBig || buffer.byte_order == eByteOrderLittle)
             {
                 uint32_t byte_idx;
-                if (m_data.buffer.byte_order == eByteOrderBig)
-                    byte_idx = m_data.buffer.length - (bit / 8) - 1;
+                if (buffer.byte_order == eByteOrderBig)
+                    byte_idx = buffer.length - (bit / 8) - 1;
                 else
                     byte_idx = bit / 8;
 
                 const uint32_t byte_bit = bit % 8;
-                if (byte_idx < m_data.buffer.length)
+                if (byte_idx < buffer.length)
                 {
-                    m_data.buffer.bytes[byte_idx] &= ~(1u << byte_bit);
+                    buffer.bytes[byte_idx] &= ~(1u << byte_bit);
                     return true;
                 }
             }
             break;
     }
     return false;
 }
 
 
 bool
 RegisterValue::SetBit (uint32_t bit)
 {
     switch (m_type)
     {
         case eTypeInvalid:
             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:
-            if (bit < 64)
-            {
-                m_data.uint64 |= (1ull << (uint64_t)bit);
-                return true;
-            }
-            break;
-#if defined (ENABLE_128_BIT_SUPPORT)
         case eTypeUInt128:
-            if (bit < 64)
+            if (bit < (GetByteSize() * 8))
             {
-                m_data.uint128 |= ((__uint128_t)1ull << (__uint128_t)bit);
-                return true;
+                return m_scalar.SetBit(bit);
             }
-#endif
+            break;
+
         case eTypeFloat:
         case eTypeDouble:
         case eTypeLongDouble:
             break;
             
         case eTypeBytes:
-            if (m_data.buffer.byte_order == eByteOrderBig || m_data.buffer.byte_order == eByteOrderLittle)
+            if (buffer.byte_order == eByteOrderBig || buffer.byte_order == eByteOrderLittle)
             {
                 uint32_t byte_idx;
-                if (m_data.buffer.byte_order == eByteOrderBig)
-                    byte_idx = m_data.buffer.length - (bit / 8) - 1;
+                if (buffer.byte_order == eByteOrderBig)
+                    byte_idx = buffer.length - (bit / 8) - 1;
                 else
                     byte_idx = bit / 8;
                 
                 const uint32_t byte_bit = bit % 8;
-                if (byte_idx < m_data.buffer.length)
+                if (byte_idx < buffer.length)
                 {
-                    m_data.buffer.bytes[byte_idx] |= (1u << byte_bit);
+                    buffer.bytes[byte_idx] |= (1u << byte_bit);
                     return true;
                 }
             }
             break;
     }
     return false;
 }
 

source/Core/Scalar.cpp

 //===-- Scalar.cpp ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/Scalar.h"
 
 #include <math.h>
 #include <inttypes.h>
+#include <stdio.h>
 
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Host/StringConvert.h"
 

 }
 
 
 //----------------------------------------------------------------------
 // Scalar constructor
 //----------------------------------------------------------------------
 Scalar::Scalar() :
     m_type(e_void),
-    m_data()
+    m_float((float)0)
 {
 }
 
 //----------------------------------------------------------------------
 // Scalar copy constructor
 //----------------------------------------------------------------------
 Scalar::Scalar(const Scalar& rhs) :
     m_type(rhs.m_type),
-    m_data(rhs.m_data)  // TODO: verify that for C++ this will correctly copy the union??
+    m_integer(rhs.m_integer),
+    m_float(rhs.m_float)
 {
 }
 
 //Scalar::Scalar(const RegisterValue& reg) :
 //  m_type(e_void),
 //  m_data()
 //{
 //  switch (reg.info.encoding)

 //      break;
 //  }
 //}
 
 bool
 Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const
 {
     size_t byte_size = GetByteSize();
+    static float f_val;
+    static double d_val;
     if (byte_size > 0)
     {
         if (limit_byte_size < byte_size)
         {
             if (lldb::endian::InlHostByteOrder() == eByteOrderLittle)
             {
                 // On little endian systems if we want fewer bytes from the
                 // current type we just specify fewer bytes since the LSByte
                 // is first...
-                data.SetData((uint8_t*)&m_data, limit_byte_size, lldb::endian::InlHostByteOrder());
+                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;
+                }
             }
             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
-                data.SetData(((uint8_t*)&m_data) + byte_size - limit_byte_size, limit_byte_size, lldb::endian::InlHostByteOrder());
+                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;
+                }
             }
         }
         else
         {
             // We want all of the data
-            data.SetData((uint8_t*)&m_data, byte_size, lldb::endian::InlHostByteOrder());
+            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;
+            }
         }
         return true;
     }
     data.Clear();
     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
 {
     switch (m_type)
     {
     case e_void:
         break;
-    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);
+    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);
     }
     return 0;
 }
 
 bool
 Scalar::IsZero() const
 {
+    llvm::APInt zero_int = llvm::APInt::getAllOnesValue(m_integer.getBitWidth() / 8);
     switch (m_type)
     {
     case e_void:
         break;
-    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;
+    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();
     }
     return false;
 }
 
 void
 Scalar::GetValue (Stream *s, bool show_type) const
 {
+    const uint64_t *src;
     if (show_type)
         s->Printf("(%s) ", GetTypeAsCString());
 
     switch (m_type)
     {
     case e_void:
         break;
-    case e_sint:        s->Printf("%i", 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;
+    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;
     }
 }
 
 const char *
 Scalar::GetTypeAsCString() const
 {
     switch (m_type)
     {
     case e_void:        return "void";
     case e_sint:        return "int";
     case e_uint:        return "unsigned int";
     case e_slong:       return "long";
     case e_ulong:       return "unsigned long";
     case e_slonglong:   return "long long";
     case e_ulonglong:   return "unsigned long long";
+    case e_sint128:     return "int128_t";
+    case e_uint128:     return "unsigned int128_t";
     case e_float:       return "float";
     case e_double:      return "double";
     case e_long_double: return "long double";
     }
     return "<invalid Scalar type>";
 }
 
 
 
 //----------------------------------------------------------------------
 // Scalar copy constructor
 //----------------------------------------------------------------------
 Scalar&
 Scalar::operator=(const Scalar& rhs)
 {
     if (this != &rhs)
     {
         m_type = rhs.m_type;
-        ::memcpy (&m_data, &rhs.m_data, sizeof(m_data));
+        m_integer = llvm::APInt(rhs.m_integer);
+        m_float = rhs.m_float;
     }
     return *this;
 }
 
 Scalar&
 Scalar::operator= (const int v)
 {
     m_type = e_sint;
-    m_data.sint = v;
+    m_integer = llvm::APInt(sizeof(int) * 8, v, true);
     return *this;
 }
 
 
 Scalar&
 Scalar::operator= (unsigned int v)
 {
     m_type = e_uint;
-    m_data.uint = v;
+    m_integer = llvm::APInt(sizeof(int) * 8, v);
     return *this;
 }
 
 Scalar&
 Scalar::operator= (long v)
 {
     m_type = e_slong;
-    m_data.slong = v;
+    m_integer = llvm::APInt(sizeof(long) * 8, v, true);
     return *this;
 }
 
 Scalar&
 Scalar::operator= (unsigned long v)
 {
     m_type = e_ulong;
-    m_data.ulong = v;
+    m_integer = llvm::APInt(sizeof(long) * 8, v);
     return *this;
 }
 
 Scalar&
 Scalar::operator= (long long v)
 {
     m_type = e_slonglong;
-    m_data.slonglong = v;
+    m_integer = llvm::APInt(sizeof(long) * 8, v, true);
     return *this;
 }
 
 Scalar&
 Scalar::operator= (unsigned long long v)
 {
     m_type = e_ulonglong;
-    m_data.ulonglong = v;
+    m_integer = llvm::APInt(sizeof(long long) * 8, v);
     return *this;
 }
 
 Scalar&
 Scalar::operator= (float v)
 {
     m_type = e_float;
-    m_data.flt = v;
+    m_float = llvm::APFloat(v);
     return *this;
 }
 
 Scalar&
 Scalar::operator= (double v)
 {
     m_type = e_double;
-    m_data.dbl = v;
+    m_float = llvm::APFloat(v);
     return *this;
 }
 
 Scalar&
 Scalar::operator= (long double v)
 {
     m_type = e_long_double;
-    m_data.ldbl = v;
+    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;
+    }
     return *this;
 }
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 Scalar::~Scalar()
 {
 }
 
 bool
 Scalar::Promote(Scalar::Type type)
 {
     bool success = false;
     switch (m_type)
     {
     case e_void:
         break;
 
     case e_sint:
         switch (type)
         {
-        case e_void:        break;
-        case e_sint:        success = true; break;
-        case e_uint:        m_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;
+            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;
+            }
         }
         break;
 
     case e_uint:
         switch (type)
         {
              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;
+             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;
+             }
         }
         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_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;
+             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;
+             }
         }
         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_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_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;
+             }
         }
         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_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_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;
+             }
         }
         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_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_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_float:
+    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_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;
+             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;
+             }
+        }
+        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;
+             }
         }
         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_float:       break;
-        case e_double:      success = true; break;
-        case e_long_double: m_data.ldbl         = m_data.dbl;       success = true; break;
+             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;
+             }
         }
         break;
 
     case e_long_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:
         case e_double:      break;
         case e_long_double: success = true; break;
         }
         break;
     }
 
     if (success)
Scalar::GetValueTypeAsCString (Scalar::Type type)
     case e_uint:        return "unsigned int";
     case e_slong:       return "long";
     case e_ulong:       return "unsigned long";
     case e_slonglong:   return "long long";
     case e_ulonglong:   return "unsigned long long";
     case e_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 "???";
 }
 
 
 Scalar::Type
 Scalar::GetValueTypeForSignedIntegerWithByteSize (size_t byte_size)
 {

 {
     bool success = false;
     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:
         switch (type)
         {
              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;
-        }
+             case e_sint:
+             {
+                 m_integer = m_integer.sextOrTrunc(sizeof(sint_t) * 8);
+                 success = true;
                  break;
-
+             }
              case e_uint:
-        switch (type)
              {
-        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;
-        }
+                 m_integer = m_integer.zextOrTrunc(sizeof(sint_t) * 8);
+                 success = true;
                  break;
-
+             }
              case e_slong:
-        switch (type)
              {
-        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;
-        }
+                 m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
+                 success = true;
                  break;
-
+             }
              case e_ulong:
-        switch (type)
              {
-        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;
-        }
+                 m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
+                 success = true;
                  break;
-
+             }
              case e_slonglong:
-        switch (type)
              {
-        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;
-        }
+                 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
+                 success = true;
                  break;
-
+             }
              case e_ulonglong:
-        switch (type)
              {
-        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;
+                 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;
+             }
         }
         break;
 
     case e_float:
         switch (type)
         {
-        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_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;
         }
         break;
 
     case e_double:
         switch (type)
         {
-        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_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;
         }
         break;
 
     case e_long_double:
         switch (type)
         {
-        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_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_ulong:
+        {
+            m_integer = m_float.bitcastToAPInt();
+            m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
+            success = true;
+            break;
+        }
+        case e_slonglong:
+        {
+            m_integer = m_float.bitcastToAPInt();
+            m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
+            success = true;
+            break;
+        }
+        case e_ulonglong:
+        {
+            m_integer = m_float.bitcastToAPInt();
+            m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
+            success = true;
+            break;
+        }
+        case e_sint128:
+        {
+            m_integer = m_float.bitcastToAPInt();
+            m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
+            success = true;
+            break;
+        }
+        case e_uint128:
+        {
+            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_long_double: success = true; break;
         }
         break;
     }
 
     if (success)
         m_type = type;
     return success;
 }
 
 bool
 Scalar::MakeSigned ()
 {
     bool success = false;
     
     switch (m_type)
     {
     case e_void:                                break;
     case e_sint:                                success = true; break;
     case e_uint:        m_type = e_sint;        success = true; break;
     case e_slong:                               success = true; break;
     case e_ulong:       m_type = e_slong;       success = true; break;
     case e_slonglong:                           success = true; break;
     case e_ulonglong:   m_type = e_slonglong;   success = true; break;
+    case e_sint128:                             success = true; break;
+    case e_uint128:     m_type = e_sint;        success = true; break;
     case e_float:                               success = true; break;
     case e_double:                              success = true; break;
     case e_long_double:                         success = true; break;
     }
     
     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:        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;
+    case e_sint:
+    case e_uint:
+    case e_slong:
+    case e_ulong:
+    case e_slonglong:
+    case e_ulonglong:
+    case e_sint128:
+    case e_uint128:
+        return *(const sint_t *)(m_integer.sext(sizeof(sint_t) * 8)).getRawData();
+    case e_float:
+        return (sint_t)m_float.convertToFloat();
+    case e_double:
+        return (sint_t)m_float.convertToDouble();
+    case e_long_double:
+        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+        return *(const sint_t *)ldbl_val.getRawData();
     }
     return fail_value;
 }
 
 unsigned int
 Scalar::UInt(unsigned int fail_value) const
 {
     switch (m_type)
     {
     case e_void:        break;
-    case e_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;
+    case e_sint:
+    case e_uint:
+    case e_slong:
+    case e_ulong:
+    case e_slonglong:
+    case e_ulonglong:
+    case e_sint128:
+    case e_uint128:
+        return *(const uint_t *)m_integer.getRawData();
+    case e_float:
+        return (uint_t)m_float.convertToFloat();
+    case e_double:
+        return (uint_t)m_float.convertToDouble();
+    case e_long_double:
+        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+        return *(const uint_t *)ldbl_val.getRawData();
     }
     return fail_value;
 }
 
 
 long
 Scalar::SLong(long fail_value) const
 {
     switch (m_type)
     {
     case e_void:        break;
-    case e_sint:        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;
+    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();
     }
     return fail_value;
 }
 
 
 
 unsigned long
 Scalar::ULong(unsigned long fail_value) const
 {
     switch (m_type)
     {
     case e_void:        break;
-    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;
+    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();
     }
     return fail_value;
 }
 
 uint64_t
 Scalar::GetRawBits64(uint64_t fail_value) const
 {
     switch (m_type)
     {
     case e_void:
         break;
 
     case e_sint:
     case e_uint:
-        return m_data.uint;
-
     case e_slong:
     case e_ulong:
-        return m_data.ulong;
-
     case e_slonglong:
     case e_ulonglong:
-        return m_data.ulonglong;
-
+    case e_sint128:
+    case e_uint128:
+        return *m_integer.getRawData();
     case e_float:
-        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;
-
+        return (uint64_t)m_float.convertToFloat();
     case e_double:
-        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;
-
+        return (uint64_t)m_float.convertToDouble();
     case e_long_double:
-        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;
+        llvm::APInt ldbl_val = m_float.bitcastToAPInt();
+        return *ldbl_val.getRawData();
     }
     return fail_value;
 }
 
 
 
 long long
 Scalar::SLongLong(long long fail_value) const
 {
     switch (m_type)
     {
     case e_void:        break;
-    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;
+    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();
     }
     return fail_value;
 }
 
 
 unsigned long long
 Scalar::ULongLong(unsigned long long fail_value) const
 {
     switch (m_type)
     {
     case e_void:        break;
-    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;
+    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();
     }
     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
 {
     switch (m_type)
     {
     case e_void:        break;
-    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;
+    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();
     }
     return fail_value;
 }
 
 
 double
 Scalar::Double(double fail_value) const
 {
     switch (m_type)
     {
     case e_void:        break;
-    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;
+    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();
     }
     return fail_value;
 }
 
 
 long double
 Scalar::LongDouble(long double fail_value) const
 {
     switch (m_type)
     {
     case e_void:        break;
-    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;
+    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();
     }
     return fail_value;
 }
 
 
 Scalar&
 Scalar::operator+= (const Scalar& rhs)
 {
     Scalar temp_value;
     const Scalar* a;
     const Scalar* b;
     if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) != Scalar::e_void)
     {
         switch (m_type)
             {
              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;
+             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;
+             }
         }
     }
     return *this;
 }
 
 Scalar&
 Scalar::operator<<= (const Scalar& rhs)
 {
     switch (m_type)
     {
     case e_void:
     case e_float:
     case e_double:
     case e_long_double:
         m_type = e_void;
         break;
 
     case e_sint:
-        switch (rhs.m_type)
-        {
-        case e_void:
-        case e_float:
-        case e_double:
-        case e_long_double:
-            m_type = e_void;
-            break;
-        case e_sint:            m_data.sint <<= rhs.m_data.sint;        break;
-        case e_uint:            m_data.sint <<= rhs.m_data.uint;        break;
-        case e_slong:           m_data.sint <<= rhs.m_data.slong;       break;
-        case e_ulong:           m_data.sint <<= rhs.m_data.ulong;       break;
-        case e_slonglong:       m_data.sint <<= rhs.m_data.slonglong;   break;
-        case e_ulonglong:       m_data.sint <<= rhs.m_data.ulonglong;   break;
-        }
-        break;
-
     case e_uint:
-        switch (rhs.m_type)
-        {
-        case e_void:
-        case e_float:
-        case e_double:
-        case e_long_double:
-            m_type = e_void;
-            break;
-        case e_sint:            m_data.uint <<= rhs.m_data.sint;        break;
-        case e_uint:            m_data.uint <<= rhs.m_data.uint;        break;
-        case e_slong:           m_data.uint <<= rhs.m_data.slong;       break;
-        case e_ulong:           m_data.uint <<= rhs.m_data.ulong;       break;
-        case e_slonglong:       m_data.uint <<= rhs.m_data.slonglong;   break;
-        case e_ulonglong:       m_data.uint <<= rhs.m_data.ulonglong;   break;
-        }
-        break;
-
     case e_slong:
-        switch (rhs.m_type)
-        {
-        case e_void:
-        case e_float:
-        case e_double:
-        case e_long_double:
-            m_type = e_void;
-            break;
-        case e_sint:            m_data.slong <<= rhs.m_data.sint;       break;
-        case e_uint:            m_data.slong <<= rhs.m_data.uint;       break;
-        case e_slong:           m_data.slong <<= rhs.m_data.slong;      break;
-        case e_ulong:           m_data.slong <<= rhs.m_data.ulong;      break;
-        case e_slonglong:       m_data.slong <<= rhs.m_data.slonglong;  break;
-        case e_ulonglong:       m_data.slong <<= rhs.m_data.ulonglong;  break;
-        }
-        break;
-
     case e_ulong:
-        switch (rhs.m_type)
-        {
-        case e_void:
-        case e_float:
-        case e_double:
-        case e_long_double:
-            m_type = e_void;
-            break;
-        case e_sint:            m_data.ulong <<= rhs.m_data.sint;       break;
-        case e_uint:            m_data.ulong <<= rhs.m_data.uint;       break;
-        case e_slong:           m_data.ulong <<= rhs.m_data.slong;      break;
-        case e_ulong:           m_data.ulong <<= rhs.m_data.ulong;      break;
-        case e_slonglong:       m_data.ulong <<= rhs.m_data.slonglong;  break;
-        case e_ulonglong:       m_data.ulong <<= rhs.m_data.ulonglong;  break;
-        }
-        break;
     case e_slonglong:
+    case e_ulonglong:
+    case e_sint128:
+    case e_uint128:
         switch (rhs.m_type)
         {
              case e_void:
              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_sint:
+             case e_uint:
+             case e_slong:
+             case e_ulong:
+             case e_slonglong:
              case e_ulonglong:
-        switch (rhs.m_type)
+             case e_sint128:
+             case e_uint128:
              {
-        case e_void:
-        case e_float:
-        case e_double:
-        case e_long_double:
-            m_type = e_void;
+                 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;
     }
     return *this;
 }
 
 bool
 Scalar::ShiftRightLogical(const Scalar& rhs)
 {
     switch (m_type)
     {
     case e_void:
     case e_float:
     case e_double:
     case e_long_double:
         m_type = e_void;
         break;
 
     case e_sint:
     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:
         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;
+        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;
         }
         break;
     }
     return m_type != e_void;
 }
 
 
 Scalar&
 Scalar::operator>>= (const Scalar& rhs)
 {
     switch (m_type)
     {
     case e_void:
     case e_float:
     case e_double:
     case e_long_double:
         m_type = e_void;
         break;
 
     case e_sint:
-        switch (rhs.m_type)
-        {
-        case e_void:
-        case e_float:
-        case e_double:
-        case e_long_double:
-            m_type = e_void;
-            break;
-        case e_sint:            m_data.sint >>= rhs.m_data.sint;        break;
-        case e_uint:            m_data.sint >>= rhs.m_data.uint;        break;
-        case e_slong:           m_data.sint >>= rhs.m_data.slong;       break;
-        case e_ulong:           m_data.sint >>= rhs.m_data.ulong;       break;
-        case e_slonglong:       m_data.sint >>= rhs.m_data.slonglong;   break;
-        case e_ulonglong:       m_data.sint >>= rhs.m_data.ulonglong;   break;
-        }
-        break;
-
     case e_uint:
-        switch (rhs.m_type)
-        {
-        case e_void:
-        case e_float:
-        case e_double:
-        case e_long_double:
-            m_type = e_void;
-            break;
-        case e_sint:            m_data.uint >>= rhs.m_data.sint;        break;
-        case e_uint:            m_data.uint >>= rhs.m_data.uint;        break;
-        case e_slong:           m_data.uint >>= rhs.m_data.slong;       break;
-        case e_ulong:           m_data.uint >>= rhs.m_data.ulong;       break;
-        case e_slonglong:       m_data.uint >>= rhs.m_data.slonglong;   break;
-        case e_ulonglong:       m_data.uint >>= rhs.m_data.ulonglong;   break;
-        }
-        break;
-
     case e_slong:
-        switch (rhs.m_type)
-        {
-        case e_void:
-        case e_float:
-        case e_double:
-        case e_long_double:
-            m_type = e_void;
-            break;
-        case e_sint:            m_data.slong >>= rhs.m_data.sint;       break;
-        case e_uint:            m_data.slong >>= rhs.m_data.uint;       break;
-        case e_slong:           m_data.slong >>= rhs.m_data.slong;      break;
-        case e_ulong:           m_data.slong >>= rhs.m_data.ulong;      break;
-        case e_slonglong:       m_data.slong >>= rhs.m_data.slonglong;  break;
-        case e_ulonglong:       m_data.slong >>= rhs.m_data.ulonglong;  break;
-        }
-        break;
-
     case e_ulong:
-        switch (rhs.m_type)
-        {
-        case e_void:
-        case e_float:
-        case e_double:
-        case e_long_double:
-            m_type = e_void;
-            break;
-        case e_sint:            m_data.ulong >>= rhs.m_data.sint;       break;
-        case e_uint:            m_data.ulong >>= rhs.m_data.uint;       break;
-        case e_slong:           m_data.ulong >>= rhs.m_data.slong;      break;
-        case e_ulong:           m_data.ulong >>= rhs.m_data.ulong;      break;
-        case e_slonglong:       m_data.ulong >>= rhs.m_data.slonglong;  break;
-        case e_ulonglong:       m_data.ulong >>= rhs.m_data.ulonglong;  break;
-        }
-        break;
     case e_slonglong:
+    case e_ulonglong:
+    case e_sint128:
+    case e_uint128:
         switch (rhs.m_type)
         {
         case e_void:
         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_sint:
+        case e_uint:
+        case e_slong:
+        case e_ulong:
+        case e_slonglong:
         case e_ulonglong:
-        switch (rhs.m_type)
+             case e_sint128:
+             case e_uint128:
              {
-        case e_void:
-        case e_float:
-        case e_double:
-        case e_long_double:
-            m_type = e_void;
+                 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;
     }
     return *this;
 }
 
 
 Scalar&
 Scalar::operator&= (const Scalar& rhs)
 {
     switch (m_type)
     {
     case e_void:
     case e_float:
     case e_double:
     case e_long_double:
         m_type = e_void;
         break;
 
     case e_sint:
-        switch (rhs.m_type)
-        {
-        case e_void:
-        case e_float:
-        case e_double:
-        case e_long_double:
-            m_type = e_void;
-            break;
-        case e_sint:            m_data.sint &= rhs.m_data.sint;         break;
-        case e_uint:            m_data.sint &= rhs.m_data.uint;         break;
-        case e_slong:           m_data.sint &= rhs.m_data.slong;        break;
-        case e_ulong:           m_data.sint &= rhs.m_data.ulong;        break;
-        case e_slonglong:       m_data.sint &= rhs.m_data.slonglong;    break;
-        case e_ulonglong:       m_data.sint &= rhs.m_data.ulonglong;    break;
-        }
-        break;
-
     case e_uint:
-        switch (rhs.m_type)
-        {
-        case e_void:
-        case e_float:
-        case e_double:
-        case e_long_double:
-            m_type = e_void;
-            break;
-        case e_sint:            m_data.uint &= rhs.m_data.sint;         break;
-        case e_uint:            m_data.uint &= rhs.m_data.uint;         break;
-        case e_slong:           m_data.uint &= rhs.m_data.slong;        break;
-        case e_ulong:           m_data.uint &= rhs.m_data.ulong;        break;
-        case e_slonglong:       m_data.uint &= rhs.m_data.slonglong;    break;
-        case e_ulonglong:       m_data.uint &= rhs.m_data.ulonglong;    break;
-        }
-        break;
-
     case e_slong:
-        switch (rhs.m_type)
-        {
-        case e_void:
-        case e_float:
-        case e_double:
-        case e_long_double:
-            m_type = e_void;
-            break;
-        case e_sint:            m_data.slong &= rhs.m_data.sint;        break;
-        case e_uint:            m_data.slong &= rhs.m_data.uint;        break;
-        case e_slong:           m_data.slong &= rhs.m_data.slong;       break;
-        case e_ulong:           m_data.slong &= rhs.m_data.ulong;       break;
-        case e_slonglong:       m_data.slong &= rhs.m_data.slonglong;   break;
-        case e_ulonglong:       m_data.slong &= rhs.m_data.ulonglong;   break;
-        }
-        break;
-
     case e_ulong:
-        switch (rhs.m_type)
-        {
-        case e_void:
-        case e_float:
-        case e_double:
-        case e_long_double:
-            m_type = e_void;
-            break;
-        case e_sint:            m_data.ulong &= rhs.m_data.sint;        break;
-        case e_uint:            m_data.ulong &= rhs.m_data.uint;        break;
-        case e_slong:           m_data.ulong &= rhs.m_data.slong;       break;
-        case e_ulong:           m_data.ulong &= rhs.m_data.ulong;       break;
-        case e_slonglong:       m_data.ulong &= rhs.m_data.slonglong;   break;
-        case e_ulonglong:       m_data.ulong &= rhs.m_data.ulonglong;   break;
-        }
-        break;
     case e_slonglong:
+    case e_ulonglong:
+    case e_sint128:
+    case e_uint128:
         switch (rhs.m_type)
         {
         case e_void:
         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_sint:
+        case e_uint:
+        case e_slong:
+        case e_ulong:
+        case e_slonglong:
         case e_ulonglong:
-        switch (rhs.m_type)
+             case e_sint128:
+             case e_uint128:
              {
-        case e_void:
-        case e_float:
-        case e_double:
-        case e_long_double:
-            m_type = e_void;
+                 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;
     }
     return *this;
 }
 
 
 
 bool
 Scalar::AbsoluteValue()
 {
     switch (m_type)
     {
     case e_void:
         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:
-        if (m_data.slonglong < 0)
-            m_data.slonglong = -m_data.slonglong;
+    case e_sint128:
+        if (m_integer.isNegative())
+            m_integer = -m_integer;
         return true;
 
     case e_uint:
     case e_ulong:
     case e_ulonglong:   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;
+    case e_uint128:
+    case e_float:
+    case e_double:
+    case e_long_double:
+        m_float.clearSign(); 
+        return true;
     }
     return false;
 }
 
 
 bool
 Scalar::UnaryNegate()
 {
     switch (m_type)
     {
     case e_void:        break;
-    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;
+    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;
     }
     return false;
 }
 
 bool
 Scalar::OnesComplement()
 {
     switch (m_type)
     {
-    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_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_void:
     case e_float:
     case e_double:
     case e_long_double:
         break;
     }
     return false;
 }
 
 
 const Scalar
 lldb_private::operator+ (const Scalar& lhs, const Scalar& rhs)
 {
     Scalar result;
     Scalar temp_value;
     const Scalar* a;
     const Scalar* b;
     if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
     {
         switch (result.m_type)
         {
         case Scalar::e_void:            break;
-        case Scalar::e_sint:            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;
+        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;
         }
     }
     return result;
 }
 
 
 const Scalar
 lldb_private::operator- (const Scalar& lhs, const Scalar& rhs)
 {
     Scalar result;
     Scalar temp_value;
     const Scalar* a;
     const Scalar* b;
     if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
     {
         switch (result.m_type)
         {
         case Scalar::e_void:            break;
-        case Scalar::e_sint:            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;
+        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;
         }
     }
     return result;
 }
 
 const Scalar
 lldb_private::operator/ (const Scalar& lhs, const Scalar& rhs)
 {
     Scalar result;
     Scalar temp_value;
     const Scalar* a;
     const Scalar* b;
     if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
     {
         switch (result.m_type)
         {
         case Scalar::e_void:            break;
-
-        case Scalar::e_sint:            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;
+        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;
         }
     }
     // For division only, the only way it should make it here is if a promotion failed,
     // or if we are trying to do a divide by zero.
     result.m_type = Scalar::e_void;
     return result;
 }
 
 const Scalar
 lldb_private::operator* (const Scalar& lhs, const Scalar& rhs)
 {
     Scalar result;
     Scalar temp_value;
     const Scalar* a;
     const Scalar* b;
     if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
     {
         switch (result.m_type)
         {
         case Scalar::e_void:            break;
-        case Scalar::e_sint:            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;
+        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;
         }
     }
     return result;
 }
 
 const Scalar
 lldb_private::operator& (const Scalar& lhs, const Scalar& rhs)
 {
     Scalar result;
     Scalar temp_value;
     const Scalar* a;
     const Scalar* b;
     if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
     {
         switch (result.m_type)
         {
-        case Scalar::e_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_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_void:
         case Scalar::e_float:
         case Scalar::e_double:
         case Scalar::e_long_double:
             // No bitwise AND on floats, doubles of long doubles
             result.m_type = Scalar::e_void;
             break;
         }
     }
     return result;
 }
 
 const Scalar
 lldb_private::operator| (const Scalar& lhs, const Scalar& rhs)
 {
     Scalar result;
     Scalar temp_value;
     const Scalar* a;
     const Scalar* b;
     if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
     {
         switch (result.m_type)
         {
-        case Scalar::e_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_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_void:
         case Scalar::e_float:
         case Scalar::e_double:
         case Scalar::e_long_double:
             // No bitwise AND on floats, doubles of long doubles
             result.m_type = Scalar::e_void;
             break;
lldb_private::operator% (const Scalar& lhs, const Scalar& rhs)
     Scalar temp_value;
     const Scalar* a;
     const Scalar* b;
     if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
     {
         switch (result.m_type)
         {
         default:                    break;
-        case Scalar::e_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_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;
+             }
         }
     }
     result.m_type = Scalar::e_void;
     return result;
 }
 
 const Scalar
 lldb_private::operator^ (const Scalar& lhs, const Scalar& rhs)
 {
     Scalar result;
     Scalar temp_value;
     const Scalar* a;
     const Scalar* b;
     if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
     {
         switch (result.m_type)
         {
-        case Scalar::e_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_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_void:
         case Scalar::e_float:
         case Scalar::e_double:
         case Scalar::e_long_double:
             // No bitwise AND on floats, doubles of long doubles
             result.m_type = Scalar::e_void;
             break;
lldb_private::operator>> (const Scalar& lhs, const Scalar &rhs)
     result >>= rhs;
     return result;
 }
 
 // Return the raw unsigned integer without any casting or conversion
 unsigned int
 Scalar::RawUInt () const
 {
-    return m_data.uint;
+    return *(const uint_t *) m_integer.getRawData();
 }
 
 // Return the raw unsigned long without any casting or conversion
 unsigned long
 Scalar::RawULong () const
 {
-    return m_data.ulong;
+    return *(const ulong_t *) m_integer.getRawData();
 }
 
 // Return the raw unsigned long long without any casting or conversion
 unsigned long long
 Scalar::RawULongLong () const
 {
-    return m_data.ulonglong;
+    return *(const ulonglong_t *) m_integer.getRawData();
 }
 
 
 Error
 Scalar::SetValueFromCString (const char *value_str, Encoding encoding, size_t byte_size)
 {
     Error error;
     if (value_str == NULL || value_str[0] == '\0')
case eEncodingUint:
                 error.SetErrorStringWithFormat ("'%s' is not a valid unsigned integer string value", value_str);
             else if (!UIntValueIsValidForSize (uval64, byte_size))
                 error.SetErrorStringWithFormat("value 0x%" PRIx64 " is too large to fit in a %" PRIu64 " byte unsigned integer value", uval64, (uint64_t)byte_size);
             else
             {
                 m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize (byte_size);
                 switch (m_type)
                 {
-                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;
+                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;
                 default:
                     error.SetErrorStringWithFormat("unsupported unsigned integer byte size: %" PRIu64 "", (uint64_t)byte_size);
                     break;
                 }
             }
         }
         else
         {
case eEncodingSint:
                 error.SetErrorStringWithFormat ("'%s' is not a valid signed integer string value", value_str);
             else if (!SIntValueIsValidForSize (sval64, byte_size))
                 error.SetErrorStringWithFormat("value 0x%" PRIx64 " is too large to fit in a %" PRIu64 " byte signed integer value", sval64, (uint64_t)byte_size);
             else
             {
                 m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize (byte_size);
                 switch (m_type)
                 {
-                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;
+                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;
                 default:
                     error.SetErrorStringWithFormat("unsupported signed integer byte size: %" PRIu64 "", (uint64_t)byte_size);
                     break;
                 }
             }
         }
         else
         {
             error.SetErrorStringWithFormat("unsupported signed integer byte size: %" PRIu64 "", (uint64_t)byte_size);
             return error;
         }
         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", &m_data.flt) == 1)
+            if (::sscanf (value_str, "%f", &f_val) == 1)
+            {
+                m_float = llvm::APFloat(f_val);
                 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", &m_data.dbl) == 1)
+            if (::sscanf (value_str, "%lf", &d_val) == 1)
+            {
+                m_float = llvm::APFloat(d_val);
                 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", &m_data.ldbl) == 1)
+            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));
                 m_type = e_long_double;
+            }
             else
                 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
         }
         else
         {
             error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "", (uint64_t)byte_size);
             return error;
         }
Scalar::SetValueFromCString (const char *value_str, Encoding encoding, size_t byte_size)
     return error;
 }
 
 Error
 Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t byte_size)
 {
     Error error;
     
+    type128 int128;
     switch (encoding)
     {
     case lldb::eEncodingInvalid:
         error.SetErrorString ("invalid encoding");
         break;
     case lldb::eEncodingVector:
         error.SetErrorString ("vector encoding unsupported");
         break;
     case lldb::eEncodingUint:
         {
             lldb::offset_t offset = 0;
             
             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 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;
+            }
             default:
                 error.SetErrorStringWithFormat("unsupported unsigned integer byte size: %" PRIu64 "", (uint64_t)byte_size);
                 break;
             }
         }
         break;
     case lldb::eEncodingSint:
         {
             lldb::offset_t offset = 0;
             
             switch (byte_size)
             {
             case 1: operator=((int8_t)data.GetU8(&offset)); break;
             case 2: operator=((int16_t)data.GetU16(&offset)); break;
             case 4: operator=((int32_t)data.GetU32(&offset)); break;
             case 8: operator=((int64_t)data.GetU64(&offset)); break;
+            case 16:
+            {
+                if (data.GetByteOrder() == eByteOrderBig)
+                {
+                    int128.x[1] = (uint64_t)data.GetU64 (&offset);
+                    int128.x[0] = (uint64_t)data.GetU64 (&offset + 1);
+                }
+                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;
             }
         }
         break;
     case lldb::eEncodingIEEE754:
         {
if (sign_bit_pos < max_bit_pos)
         case Scalar::e_void:
         case Scalar::e_float:
         case Scalar::e_double:
         case Scalar::e_long_double: 
             return false;
             
         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))
             {
-                unsigned long long sign_bit = 1ull << sign_bit_pos;
-                if (m_data.ulonglong & sign_bit)
+                llvm::APInt sign_bit = llvm::APInt::getSignBit(sign_bit_pos + 1);
+                llvm::APInt bitwize_and = m_integer & sign_bit;
+                if (bitwize_and.getBoolValue())
                 {
-                    const unsigned long long mask = ~(sign_bit) + 1ull;
-                    m_data.ulonglong |= mask;
+                    const llvm::APInt mask = ~(sign_bit) + llvm::APInt(m_integer.getBitWidth(), 1); 
+                    m_integer |= mask;
                 }
                 return true;
             }
             break;
         }
     }
     return false;
 }

 Scalar::ExtractBitfield (uint32_t bit_size, 
                          uint32_t bit_offset)
 {
     if (bit_size == 0)
         return true;
 
     uint32_t msbit = bit_offset + bit_size - 1;
     uint32_t lsbit = bit_offset;
+    uint64_t result;
     switch (m_type)
     {
         case Scalar::e_void:
             break;
             
         case e_float:
-            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;
+            result = SignedBits ((uint64_t )m_float.convertToFloat(), msbit, lsbit);
+            m_float = llvm::APFloat((float_t)result);
             return true;
-            
         case e_double:
-            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;
-            
+            result = SignedBits ((uint64_t )m_float.convertToDouble(), msbit, lsbit);
+            m_float = llvm::APFloat((double_t)result);
         case e_long_double:
-            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);
+            m_integer = m_float.bitcastToAPInt();
+            result = SignedBits (*m_integer.getRawData(), msbit, lsbit);
+            if(m_ieee_quad)
+                m_float = llvm::APFloat(llvm::APFloat::IEEEquad, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&result)->x));
             else
-                return false;
+                m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&result)->x));
             return true;
             
         case Scalar::e_sint:
-            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);
+        case Scalar::e_sint128:
+            m_integer = SignedBits (*m_integer.getRawData(), msbit, lsbit);
             return true;
 
+        case Scalar::e_uint:
+        case Scalar::e_ulong:
         case Scalar::e_ulonglong:
-            m_data.ulonglong = (ulonglong_t)UnsignedBits (m_data.ulonglong, msbit, lsbit);
+        case Scalar::e_uint128:
+            m_integer = UnsignedBits (*m_integer.getRawData(), msbit, lsbit);
             return true;
     }
     return false;
 }
 
 
 
 
 
 bool
 lldb_private::operator== (const Scalar& lhs, const Scalar& rhs)
 {
     // If either entry is void then we can just compare the types
     if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
         return lhs.m_type == rhs.m_type;
 
     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:            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;
+    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;
     }
     return false;
 }
 
 bool
 lldb_private::operator!= (const Scalar& lhs, const Scalar& rhs)
 {
     // If either entry is void then we can just compare the types
     if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
         return lhs.m_type != rhs.m_type;
 
     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:            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;
+    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;
     }
     return true;
 }
 
 bool
 lldb_private::operator< (const Scalar& lhs, const Scalar& rhs)
 {
     if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
         return false;
 
     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:            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;
+    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;
     }
     return false;
 }
 
 bool
 lldb_private::operator<= (const Scalar& lhs, const Scalar& rhs)
 {
     if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
         return false;
 
     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:            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;
+    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;
     }
     return false;
 }
 
 
 bool
 lldb_private::operator> (const Scalar& lhs, const Scalar& rhs)
 {
     if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
         return false;
 
     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:            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;
+        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;
     }
     return false;
 }
 
 bool
 lldb_private::operator>= (const Scalar& lhs, const Scalar& rhs)
 {
     if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
         return false;
 
     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:            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;
+        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;
     }
     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;
+    }
+}

source/Core/ValueObject.cpp

ValueObject::SetValueFromCString (const char *value_str, Error& error)
 
     Value::ValueType value_type = m_value.GetValueType();
     
     if (value_type == Value::eValueTypeScalar)
     {
         // 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 <= Scalar::GetMaxByteSize())
+    else if (byte_size <= 16)
     {
         // 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.
         Scalar new_scalar;
         error = new_scalar.SetValueFromCString (value_str, encoding, byte_size);
         if (error.Success())
         {
             switch (value_type)

source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp

 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Symbol/UnwindPlan.h"
 
 #include "llvm/ADT/STLExtras.h"
 
 #include "Plugins/Process/Utility/InstructionUtils.h"
-#include "Plugins/Process/Utility/RegisterContext_mips64.h"  //mips32 has same registers nos as mips64
+#include "Plugins/Process/Utility/RegisterContext_mips.h"  //mips32 has same registers nos as mips64
 
 using namespace lldb;
 using namespace lldb_private;
 
 #define UInt(x) ((uint64_t)x)
 #define integer int64_t
 
 
switch (reg_num)
         case gcc_dwarf_r30_mips:      return "fp";
         case gcc_dwarf_ra_mips:       return "ra";
         case gcc_dwarf_sr_mips:       return "sr";
         case gcc_dwarf_lo_mips:       return "lo";
         case gcc_dwarf_hi_mips:       return "hi";
         case gcc_dwarf_bad_mips:      return "bad";
         case gcc_dwarf_cause_mips:    return "cause";
         case gcc_dwarf_pc_mips:       return "pc";
-        case gcc_dwarf_f0_mips:       return "fp_reg[0]";
-        case gcc_dwarf_f1_mips:       return "fp_reg[1]";
-        case gcc_dwarf_f2_mips:       return "fp_reg[2]";
-        case gcc_dwarf_f3_mips:       return "fp_reg[3]";
-        case gcc_dwarf_f4_mips:       return "fp_reg[4]";
-        case gcc_dwarf_f5_mips:       return "fp_reg[5]";
-        case gcc_dwarf_f6_mips:       return "fp_reg[6]";
-        case gcc_dwarf_f7_mips:       return "fp_reg[7]";
-        case gcc_dwarf_f8_mips:       return "fp_reg[8]";
-        case gcc_dwarf_f9_mips:       return "fp_reg[9]";
-        case gcc_dwarf_f10_mips:      return "fp_reg[10]";
-        case gcc_dwarf_f11_mips:      return "fp_reg[11]";
-        case gcc_dwarf_f12_mips:      return "fp_reg[12]";
-        case gcc_dwarf_f13_mips:      return "fp_reg[13]";
-        case gcc_dwarf_f14_mips:      return "fp_reg[14]";
-        case gcc_dwarf_f15_mips:      return "fp_reg[15]";
-        case gcc_dwarf_f16_mips:      return "fp_reg[16]";
-        case gcc_dwarf_f17_mips:      return "fp_reg[17]";
-        case gcc_dwarf_f18_mips:      return "fp_reg[18]";
-        case gcc_dwarf_f19_mips:      return "fp_reg[19]";
-        case gcc_dwarf_f20_mips:      return "fp_reg[20]";
-        case gcc_dwarf_f21_mips:      return "fp_reg[21]";
-        case gcc_dwarf_f22_mips:      return "fp_reg[22]";
-        case gcc_dwarf_f23_mips:      return "fp_reg[23]";
-        case gcc_dwarf_f24_mips:      return "fp_reg[24]";
-        case gcc_dwarf_f25_mips:      return "fp_reg[25]";
-        case gcc_dwarf_f26_mips:      return "fp_reg[26]";
-        case gcc_dwarf_f27_mips:      return "fp_reg[27]";
-        case gcc_dwarf_f28_mips:      return "fp_reg[28]";
-        case gcc_dwarf_f29_mips:      return "fp_reg[29]";
-        case gcc_dwarf_f30_mips:      return "fp_reg[30]";
-        case gcc_dwarf_f31_mips:      return "fp_reg[31]";
+        case gcc_dwarf_f0_mips:       return "f0";
+        case gcc_dwarf_f1_mips:       return "f1";
+        case gcc_dwarf_f2_mips:       return "f2";
+        case gcc_dwarf_f3_mips:       return "f3";
+        case gcc_dwarf_f4_mips:       return "f4";
+        case gcc_dwarf_f5_mips:       return "f5";
+        case gcc_dwarf_f6_mips:       return "f6";
+        case gcc_dwarf_f7_mips:       return "f7";
+        case gcc_dwarf_f8_mips:       return "f8";
+        case gcc_dwarf_f9_mips:       return "f9";
+        case gcc_dwarf_f10_mips:      return "f10";
+        case gcc_dwarf_f11_mips:      return "f11";
+        case gcc_dwarf_f12_mips:      return "f12";
+        case gcc_dwarf_f13_mips:      return "f13";
+        case gcc_dwarf_f14_mips:      return "f14";
+        case gcc_dwarf_f15_mips:      return "f15";
+        case gcc_dwarf_f16_mips:      return "f16";
+        case gcc_dwarf_f17_mips:      return "f17";
+        case gcc_dwarf_f18_mips:      return "f18";
+        case gcc_dwarf_f19_mips:      return "f19";
+        case gcc_dwarf_f20_mips:      return "f20";
+        case gcc_dwarf_f21_mips:      return "f21";
+        case gcc_dwarf_f22_mips:      return "f22";
+        case gcc_dwarf_f23_mips:      return "f23";
+        case gcc_dwarf_f24_mips:      return "f24";
+        case gcc_dwarf_f25_mips:      return "f25";
+        case gcc_dwarf_f26_mips:      return "f26";
+        case gcc_dwarf_f27_mips:      return "f27";
+        case gcc_dwarf_f28_mips:      return "f28";
+        case gcc_dwarf_f29_mips:      return "f29";
+        case gcc_dwarf_f30_mips:      return "f30";
+        case gcc_dwarf_f31_mips:      return "f31";
         case gcc_dwarf_fcsr_mips:     return "fcsr";
         case gcc_dwarf_fir_mips:      return "fir";
     }
     return nullptr;
 }
 
 bool
 EmulateInstructionMIPS::GetRegisterInfo (RegisterKind reg_kind, uint32_t reg_num, RegisterInfo &reg_info)

source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp

 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Symbol/UnwindPlan.h"
 
 #include "llvm/ADT/STLExtras.h"
 
 #include "Plugins/Process/Utility/InstructionUtils.h"
-#include "Plugins/Process/Utility/RegisterContext_mips64.h"
+#include "Plugins/Process/Utility/RegisterContext_mips.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 #define UInt(x) ((uint64_t)x)
 #define integer int64_t
 
 
switch (reg_num)
         case gcc_dwarf_r30_mips64:      return "fp";
         case gcc_dwarf_ra_mips64:       return "ra";
         case gcc_dwarf_sr_mips64:       return "sr";
         case gcc_dwarf_lo_mips64:       return "lo";
         case gcc_dwarf_hi_mips64:       return "hi";
         case gcc_dwarf_bad_mips64:      return "bad";
         case gcc_dwarf_cause_mips64:    return "cause";
         case gcc_dwarf_pc_mips64:       return "pc";
-        case gcc_dwarf_f0_mips64:       return "fp_reg[0]";
-        case gcc_dwarf_f1_mips64:       return "fp_reg[1]";
-        case gcc_dwarf_f2_mips64:       return "fp_reg[2]";
-        case gcc_dwarf_f3_mips64:       return "fp_reg[3]";
-        case gcc_dwarf_f4_mips64:       return "fp_reg[4]";
-        case gcc_dwarf_f5_mips64:       return "fp_reg[5]";
-        case gcc_dwarf_f6_mips64:       return "fp_reg[6]";
-        case gcc_dwarf_f7_mips64:       return "fp_reg[7]";
-        case gcc_dwarf_f8_mips64:       return "fp_reg[8]";
-        case gcc_dwarf_f9_mips64:       return "fp_reg[9]";
-        case gcc_dwarf_f10_mips64:      return "fp_reg[10]";
-        case gcc_dwarf_f11_mips64:      return "fp_reg[11]";
-        case gcc_dwarf_f12_mips64:      return "fp_reg[12]";
-        case gcc_dwarf_f13_mips64:      return "fp_reg[13]";
-        case gcc_dwarf_f14_mips64:      return "fp_reg[14]";
-        case gcc_dwarf_f15_mips64:      return "fp_reg[15]";
-        case gcc_dwarf_f16_mips64:      return "fp_reg[16]";
-        case gcc_dwarf_f17_mips64:      return "fp_reg[17]";
-        case gcc_dwarf_f18_mips64:      return "fp_reg[18]";
-        case gcc_dwarf_f19_mips64:      return "fp_reg[19]";
-        case gcc_dwarf_f20_mips64:      return "fp_reg[20]";
-        case gcc_dwarf_f21_mips64:      return "fp_reg[21]";
-        case gcc_dwarf_f22_mips64:      return "fp_reg[22]";
-        case gcc_dwarf_f23_mips64:      return "fp_reg[23]";
-        case gcc_dwarf_f24_mips64:      return "fp_reg[24]";
-        case gcc_dwarf_f25_mips64:      return "fp_reg[25]";
-        case gcc_dwarf_f26_mips64:      return "fp_reg[26]";
-        case gcc_dwarf_f27_mips64:      return "fp_reg[27]";
-        case gcc_dwarf_f28_mips64:      return "fp_reg[28]";
-        case gcc_dwarf_f29_mips64:      return "fp_reg[29]";
-        case gcc_dwarf_f30_mips64:      return "fp_reg[30]";
-        case gcc_dwarf_f31_mips64:      return "fp_reg[31]";
+        case gcc_dwarf_f0_mips64:       return "f0";
+        case gcc_dwarf_f1_mips64:       return "f1";
+        case gcc_dwarf_f2_mips64:       return "f2";
+        case gcc_dwarf_f3_mips64:       return "f3";
+        case gcc_dwarf_f4_mips64:       return "f4";
+        case gcc_dwarf_f5_mips64:       return "f5";
+        case gcc_dwarf_f6_mips64:       return "f6";
+        case gcc_dwarf_f7_mips64:       return "f7";
+        case gcc_dwarf_f8_mips64:       return "f8";
+        case gcc_dwarf_f9_mips64:       return "f9";
+        case gcc_dwarf_f10_mips64:      return "f10";
+        case gcc_dwarf_f11_mips64:      return "f11";
+        case gcc_dwarf_f12_mips64:      return "f12";
+        case gcc_dwarf_f13_mips64:      return "f13";
+        case gcc_dwarf_f14_mips64:      return "f14";
+        case gcc_dwarf_f15_mips64:      return "f15";
+        case gcc_dwarf_f16_mips64:      return "f16";
+        case gcc_dwarf_f17_mips64:      return "f17";
+        case gcc_dwarf_f18_mips64:      return "f18";
+        case gcc_dwarf_f19_mips64:      return "f19";
+        case gcc_dwarf_f20_mips64:      return "f20";
+        case gcc_dwarf_f21_mips64:      return "f21";
+        case gcc_dwarf_f22_mips64:      return "f22";
+        case gcc_dwarf_f23_mips64:      return "f23";
+        case gcc_dwarf_f24_mips64:      return "f24";
+        case gcc_dwarf_f25_mips64:      return "f25";
+        case gcc_dwarf_f26_mips64:      return "f26";
+        case gcc_dwarf_f27_mips64:      return "f27";
+        case gcc_dwarf_f28_mips64:      return "f28";
+        case gcc_dwarf_f29_mips64:      return "f29";
+        case gcc_dwarf_f30_mips64:      return "f30";
+        case gcc_dwarf_f31_mips64:      return "f31";
         case gcc_dwarf_fcsr_mips64:     return "fcsr";
         case gcc_dwarf_fir_mips64:      return "fir";
     }
     return nullptr;
 }
 
 bool
 EmulateInstructionMIPS64::GetRegisterInfo (RegisterKind reg_kind, uint32_t reg_num, RegisterInfo &reg_info)

source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp

NativeRegisterContextLinux::WriteGPR()
     return DoWriteGPR(buf, buf_size);
 }
 
 Error
 NativeRegisterContextLinux::ReadFPR()
 {
     void* buf = GetFPRBuffer();
     if (!buf)
-        return Error("GPR buffer is NULL");
+        return Error("FPR buffer is NULL");
     size_t buf_size = GetFPRSize();
 
     return DoReadFPR(buf, buf_size);
 }
 
 Error
 NativeRegisterContextLinux::WriteFPR()
 {
     void* buf = GetFPRBuffer();
     if (!buf)
-        return Error("GPR buffer is NULL");
+        return Error("FPR buffer is NULL");
     size_t buf_size = GetFPRSize();
 
     return DoWriteFPR(buf, buf_size);
 }
 
 Error
 NativeRegisterContextLinux::ReadRegisterSet(void *buf, size_t buf_size, unsigned int regset)
 {

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h

 //===-- NativeRegisterContextLinux_mips64.h ---------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #if defined (__mips__)
 
 #ifndef lldb_NativeRegisterContextLinux_mips64_h
 #define lldb_NativeRegisterContextLinux_mips64_h
 
 #include "Plugins/Process/Linux/NativeRegisterContextLinux.h"
-#include "Plugins/Process/Utility/RegisterContext_mips64.h"
-#include "Plugins/Process/Utility/lldb-mips64-register-enums.h"
+#include "Plugins/Process/Utility/RegisterContext_mips.h"
+#include "Plugins/Process/Utility/lldb-mips-linux-register-enums.h"
 
 #define MAX_NUM_WP 8
 
 namespace lldb_private {
 namespace process_linux {
 
     class NativeProcessLinux;
 
public:
 
         Error
         ReadAllRegisterValues (lldb::DataBufferSP &data_sp) override;
 
         Error
         WriteAllRegisterValues (const lldb::DataBufferSP &data_sp) override;
 
         Error
-        ReadFPR() override;
+        ReadCP1();
 
         Error
-        WriteFPR() override;
+        WriteCP1();
 
         Error
         IsWatchpointHit (uint32_t wp_index, bool &is_hit) override;
 
         Error
         GetWatchpointHitIndex(uint32_t &wp_index, lldb::addr_t trap_addr) override;
 
         Error
protected:
 
         Error
         DoWriteWatchPointRegisterValue(lldb::tid_t tid, void* watch_readback);
 
         bool
         IsFR0();
 
         bool
+        IsFRE();
+
+        bool
         IsFPR(uint32_t reg_index) const;
 
+        bool
+        IsMSA(uint32_t reg_index) const;
+
+        bool
+        IsMSAAvailable();
+
         void*
-        GetGPRBuffer() override { return &m_gpr_mips64; }
+        GetGPRBuffer() override { return &m_gpr; }
 
         void*
         GetFPRBuffer() override { return &m_fpr; }
 
         size_t
-        GetFPRSize() override { return sizeof(FPR_mips); }
+        GetFPRSize() override { return sizeof(FPR_linux_mips); }
 
     private:
         // Info about register ranges.
         struct RegInfo
         {
             uint32_t num_registers;
             uint32_t num_gpr_registers;
             uint32_t num_fpr_registers;
 
             uint32_t last_gpr;
             uint32_t first_fpr;
             uint32_t last_fpr;
+            uint32_t first_msa;
+            uint32_t last_msa;
         };
 
         RegInfo m_reg_info;
 
-        uint64_t m_gpr_mips64[k_num_gpr_registers_mips64];
+        GPR_linux_mips m_gpr;
 
-        FPR_mips m_fpr;
+        FPR_linux_mips m_fpr;
+
+        MSA_linux_mips m_msa;
 
         lldb::addr_t hw_addr_map[MAX_NUM_WP];
+
+        IOVEC_mips m_iovec;
     };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef lldb_NativeRegisterContextLinux_mips64_h
 
 #endif // defined (__mips__)

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

 #include "lldb/Core/Log.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Host/HostInfo.h"
 
 #include "Plugins/Process/Linux/NativeProcessLinux.h"
 #include "Plugins/Process/Linux/Procfs.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_mips64.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_mips.h"
+#define NT_MIPS_MSA 0x600
+#define CONFIG5_FRE (1 << 8)
+#define SR_FR (1 << 26)
+#define NUM_REGISTERS 32
 
 #include <sys/ptrace.h>
 #include <asm/ptrace.h>
 
 #ifndef PTRACE_GET_WATCH_REGS
 enum pt_watch_style
 {
     pt_watch_style_mips32,
g_gp_regnums_mips[] =
         gpr_r24_mips,
         gpr_r25_mips,
         gpr_r26_mips,
         gpr_r27_mips,
         gpr_gp_mips,
         gpr_sp_mips,
         gpr_r30_mips,
         gpr_ra_mips,
+        gpr_sr_mips,
         gpr_mullo_mips,
         gpr_mulhi_mips,
-        gpr_pc_mips,
         gpr_badvaddr_mips,
-        gpr_sr_mips,
         gpr_cause_mips,
+        gpr_pc_mips,
+        gpr_config5_mips,
         LLDB_INVALID_REGNUM     // register sets need to end with this flag
     };
 
     static_assert((sizeof(g_gp_regnums_mips) / sizeof(g_gp_regnums_mips[0])) - 1 == k_num_gpr_registers_mips,
                   "g_gp_regnums_mips has wrong number of register infos");
 
     // mips floating point registers.
     const uint32_t
g_fp_regnums_mips[] =
         fpr_f26_mips,
         fpr_f27_mips,
         fpr_f28_mips,
         fpr_f29_mips,
         fpr_f30_mips,
         fpr_f31_mips,
         fpr_fcsr_mips,
         fpr_fir_mips,
+        fpr_config5_mips,
         LLDB_INVALID_REGNUM     // register sets need to end with this flag
     };
 
     static_assert((sizeof(g_fp_regnums_mips) / sizeof(g_fp_regnums_mips[0])) - 1 == k_num_fpr_registers_mips,
                   "g_fp_regnums_mips has wrong number of register infos");
 
+    // mips MSA registers.
+    const uint32_t
+    g_msa_regnums_mips[] =
+    {
+        msa_w0_mips,
+        msa_w1_mips,
+        msa_w2_mips,
+        msa_w3_mips,
+        msa_w4_mips,
+        msa_w5_mips,
+        msa_w6_mips,
+        msa_w7_mips,
+        msa_w8_mips,
+        msa_w9_mips,
+        msa_w10_mips,
+        msa_w11_mips,
+        msa_w12_mips,
+        msa_w13_mips,
+        msa_w14_mips,
+        msa_w15_mips,
+        msa_w16_mips,
+        msa_w17_mips,
+        msa_w18_mips,
+        msa_w19_mips,
+        msa_w20_mips,
+        msa_w21_mips,
+        msa_w22_mips,
+        msa_w23_mips,
+        msa_w24_mips,
+        msa_w25_mips,
+        msa_w26_mips,
+        msa_w27_mips,
+        msa_w28_mips,
+        msa_w29_mips,
+        msa_w30_mips,
+        msa_w31_mips,
+        msa_fcsr_mips,
+        msa_fir_mips,
+        msa_mcsr_mips,
+        msa_mir_mips,
+        msa_config5_mips,
+        LLDB_INVALID_REGNUM     // register sets need to end with this flag
+    };
+
+    static_assert((sizeof(g_msa_regnums_mips) / sizeof(g_msa_regnums_mips[0])) - 1 == k_num_msa_registers_mips,
+                  "g_msa_regnums_mips has wrong number of register infos");
+
     // mips64 general purpose registers.
     const uint32_t
     g_gp_regnums_mips64[] =
     {
         gpr_zero_mips64,
         gpr_r1_mips64,
         gpr_r2_mips64,
         gpr_r3_mips64,
g_gp_regnums_mips64[] =
         gpr_r24_mips64,
         gpr_r25_mips64,
         gpr_r26_mips64,
         gpr_r27_mips64,
         gpr_gp_mips64,
         gpr_sp_mips64,
         gpr_r30_mips64,
         gpr_ra_mips64,
+        gpr_sr_mips64,
         gpr_mullo_mips64,
         gpr_mulhi_mips64,
-        gpr_pc_mips64,
         gpr_badvaddr_mips64,
-        gpr_sr_mips64,
         gpr_cause_mips64,
-        gpr_ic_mips64,
-        gpr_dummy_mips64,
+        gpr_pc_mips64,
+        gpr_config5_mips64,
         LLDB_INVALID_REGNUM     // register sets need to end with this flag
     };
 
     static_assert((sizeof(g_gp_regnums_mips64) / sizeof(g_gp_regnums_mips64[0])) - 1 == k_num_gpr_registers_mips64,
                   "g_gp_regnums_mips64 has wrong number of register infos");
 
     // mips64 floating point registers.
     const uint32_t
g_fp_regnums_mips64[] =
         fpr_f26_mips64,
         fpr_f27_mips64,
         fpr_f28_mips64,
         fpr_f29_mips64,
         fpr_f30_mips64,
         fpr_f31_mips64,
         fpr_fcsr_mips64,
         fpr_fir_mips64,
+        fpr_config5_mips64,
         LLDB_INVALID_REGNUM     // register sets need to end with this flag
     };
 
     static_assert((sizeof(g_fp_regnums_mips64) / sizeof(g_fp_regnums_mips64[0])) - 1 == k_num_fpr_registers_mips64,
                   "g_fp_regnums_mips64 has wrong number of register infos");
 
+    // mips64 MSA registers.
+    const uint32_t
+    g_msa_regnums_mips64[] =
+    {
+        msa_w0_mips64,
+        msa_w1_mips64,
+        msa_w2_mips64,
+        msa_w3_mips64,
+        msa_w4_mips64,
+        msa_w5_mips64,
+        msa_w6_mips64,
+        msa_w7_mips64,
+        msa_w8_mips64,
+        msa_w9_mips64,
+        msa_w10_mips64,
+        msa_w11_mips64,
+        msa_w12_mips64,
+        msa_w13_mips64,
+        msa_w14_mips64,
+        msa_w15_mips64,
+        msa_w16_mips64,
+        msa_w17_mips64,
+        msa_w18_mips64,
+        msa_w19_mips64,
+        msa_w20_mips64,
+        msa_w21_mips64,
+        msa_w22_mips64,
+        msa_w23_mips64,
+        msa_w24_mips64,
+        msa_w25_mips64,
+        msa_w26_mips64,
+        msa_w27_mips64,
+        msa_w28_mips64,
+        msa_w29_mips64,
+        msa_w30_mips64,
+        msa_w31_mips64,
+        msa_fcsr_mips64,
+        msa_fir_mips64,
+        msa_mcsr_mips64,
+        msa_mir_mips64,
+        msa_config5_mips64,
+        LLDB_INVALID_REGNUM     // register sets need to end with this flag
+    };
+
+    static_assert((sizeof(g_msa_regnums_mips64) / sizeof(g_msa_regnums_mips64[0])) - 1 == k_num_msa_registers_mips64,
+                  "g_msa_regnums_mips64 has wrong number of register infos");
+
     // Number of register sets provided by this context.
     enum
     {
-        k_num_register_sets = 2
+        k_num_register_sets = 3
     };
 
     // Register sets for mips.
     static const RegisterSet
     g_reg_sets_mips[k_num_register_sets] =
     {
         { "General Purpose Registers",  "gpr", k_num_gpr_registers_mips, g_gp_regnums_mips },
-        { "Floating Point Registers",   "fpu", k_num_fpr_registers_mips, g_fp_regnums_mips }
+        { "Floating Point Registers",   "fpu", k_num_fpr_registers_mips, g_fp_regnums_mips },
+        { "MSA Registers",              "msa", k_num_msa_registers_mips, g_msa_regnums_mips }
     };
 
     // Register sets for mips64.
     static const RegisterSet
     g_reg_sets_mips64[k_num_register_sets] =
     {
         { "General Purpose Registers",  "gpr", k_num_gpr_registers_mips64, g_gp_regnums_mips64 },
-        { "Floating Point Registers",   "fpu", k_num_fpr_registers_mips64, g_fp_regnums_mips64 }
+        { "Floating Point Registers",   "fpu", k_num_fpr_registers_mips64, g_fp_regnums_mips64 },
+        { "MSA Registers",              "msa", k_num_msa_registers_mips64, g_msa_regnums_mips64 },
     };
 
 } // end of anonymous namespace
 
 NativeRegisterContextLinux*
 NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(const ArchSpec& target_arch,
                                                                  NativeThreadProtocol &native_thread,
                                                                  uint32_t concrete_frame_idx)
 {
     return new NativeRegisterContextLinux_mips64(target_arch, native_thread, concrete_frame_idx);
 }
 
-#define REG_CONTEXT_SIZE (GetRegisterInfoInterface ().GetGPRSize () + sizeof(FPR_mips))
+#define REG_CONTEXT_SIZE (GetRegisterInfoInterface ().GetGPRSize () + sizeof(FPR_linux_mips) + sizeof(MSA_linux_mips))
 
 // ----------------------------------------------------------------------------
 // NativeRegisterContextLinux_mips64 members.
 // ----------------------------------------------------------------------------
 
 static RegisterInfoInterface*
 CreateRegisterInfoInterface(const ArchSpec& target_arch)
 {
switch (target_arch.GetMachine ())
         case llvm::Triple::mips:
         case llvm::Triple::mipsel:
             m_reg_info.num_registers        = k_num_registers_mips;
             m_reg_info.num_gpr_registers    = k_num_gpr_registers_mips;
             m_reg_info.num_fpr_registers    = k_num_fpr_registers_mips;
             m_reg_info.last_gpr             = k_last_gpr_mips;
             m_reg_info.first_fpr            = k_first_fpr_mips;
             m_reg_info.last_fpr             = k_last_fpr_mips;
+            m_reg_info.first_msa            = k_first_msa_mips;
+            m_reg_info.last_msa             = k_last_msa_mips;
             break;
         case llvm::Triple::mips64:
         case llvm::Triple::mips64el:
             m_reg_info.num_registers        = k_num_registers_mips64;
             m_reg_info.num_gpr_registers    = k_num_gpr_registers_mips64;
             m_reg_info.num_fpr_registers    = k_num_fpr_registers_mips64;
             m_reg_info.last_gpr             = k_last_gpr_mips64;
             m_reg_info.first_fpr            = k_first_fpr_mips64;
             m_reg_info.last_fpr             = k_last_fpr_mips64;
+            m_reg_info.first_msa            = k_first_msa_mips64;
+            m_reg_info.last_msa             = k_last_msa_mips64;
             break;
         default:
             assert(false && "Unhandled target architecture.");
             break;
     }
 
-    // Clear out the FPR state.
-    ::memset(&m_fpr, 0, sizeof(FPR_mips));
+    // Initialize m_iovec to point to the buffer and buffer size
+    // using the conventions of Berkeley style UIO structures, as required
+    // by PTRACE extensions.
+    m_iovec.iov_base = &m_msa;
+    m_iovec.iov_len = sizeof(MSA_linux_mips);
 
     // init h/w watchpoint addr map
     for (int index = 0;index <= MAX_NUM_WP; index++)
         hw_addr_map[index] = LLDB_INVALID_ADDRESS;
+
+    ::memset(&m_gpr, 0, sizeof(GPR_linux_mips));
+    ::memset(&m_fpr, 0, sizeof(FPR_linux_mips));
+    ::memset(&m_msa, 0, sizeof(MSA_linux_mips));
 }
 
 uint32_t
 NativeRegisterContextLinux_mips64::GetRegisterSetCount () const
 {
     return k_num_register_sets;
 }
 
NativeRegisterContextLinux_mips64::ReadRegister (const RegisterInfo *reg_info, RegisterValue &reg_value)
     const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
     if (reg == LLDB_INVALID_REGNUM)
     {
         // This is likely an internal register for lldb use only and should not be directly queried.
         error.SetErrorStringWithFormat ("register \"%s\" is an internal-only lldb register, cannot read directly", reg_info->name);
         return error;
     }
 
-    if (IsFPR(reg))
+    if (IsMSA(reg) && !IsMSAAvailable())
+    {
+        error.SetErrorString ("MSA not available on this processor");
+        return error;
+    }
+
+    if (IsMSA(reg) || IsFPR(reg))
     {
-        error = ReadFPR();
+        uint8_t *src;
+        type128 int128;
+
+        error = ReadCP1();
+
         if (!error.Success())
         {
-            error.SetErrorString ("failed to read floating point register");
+            error.SetErrorString ("failed to read co-processor 1 register");
             return error;
         }
-        assert (reg_info->byte_offset < sizeof(FPR_mips));
-        uint8_t *src = (uint8_t *)&m_fpr + reg_info->byte_offset;
+
+        if (IsFPR(reg))
+        {
+            assert (reg_info->byte_offset < sizeof(UserArea));
+            src = (uint8_t *)&m_fpr + reg_info->byte_offset - (sizeof(m_gpr));
+        }
+        else
+        {
+            assert (reg_info->byte_offset < sizeof(UserArea));
+            src = (uint8_t *)&m_msa + reg_info->byte_offset - (sizeof(m_gpr) + sizeof(m_fpr));
+        }
+        int128.x[0] = *(uint64_t *)src;
+        int128.x[1] = *(uint64_t *)(src + 8); 
+        llvm::APInt rhs = llvm::APInt(128, 2, int128.x);
         switch (reg_info->byte_size)
         {
             case 4:
                 reg_value.SetUInt32(*(uint32_t *)src);
                 break;
             case 8:
                 reg_value.SetUInt64(*(uint64_t *)src);
                 break;
+            case 16:
+                reg_value.SetUInt128(rhs);
+                break;
             default:
                 assert(false && "Unhandled data size.");
                 error.SetErrorStringWithFormat ("unhandled byte size: %" PRIu32, reg_info->byte_size);
                 break;
         }
     }
     else
     {
NativeRegisterContextLinux_mips64::WriteRegister (const RegisterInfo *reg_info, const RegisterValue &reg_value)
 
     assert (reg_info && "reg_info is null");
 
     const uint32_t reg_index = reg_info->kinds[lldb::eRegisterKindLLDB];
 
     if (reg_index == LLDB_INVALID_REGNUM)
         return Error ("no lldb regnum for %s", reg_info && reg_info->name ? reg_info->name : "<unknown register>");
 
+    if (IsMSA(reg_index) && !IsMSAAvailable())
+    {
+        error.SetErrorString ("MSA not available on this processor");
+        return error;
+    }
+
+    if (IsFPR(reg_index) || IsMSA(reg_index))
+    {
+        uint8_t *dst;
+        const uint64_t *src;
+
+        // Initialise the FP and MSA buffers by reading all co-processor 1 registers
+        ReadCP1();
+
         if (IsFPR(reg_index))
         {
-        assert (reg_info->byte_offset < sizeof(FPR_mips));
-        uint8_t *dst = (uint8_t *)&m_fpr + reg_info->byte_offset;
+            assert (reg_info->byte_offset < sizeof(UserArea));
+            dst = (uint8_t *)&m_fpr + reg_info->byte_offset - (sizeof(m_gpr));
+        }
+        else
+        {
+            assert (reg_info->byte_offset < sizeof(UserArea));
+            dst = (uint8_t *)&m_msa + reg_info->byte_offset - (sizeof(m_gpr) + sizeof(m_fpr));
+        }
+        llvm::APInt lhs;
+        llvm::APInt fail_value = llvm::APInt::getMaxValue(128);
         switch (reg_info->byte_size)
         {
             case 4:
                 *(uint32_t *)dst = reg_value.GetAsUInt32();
                 break;
             case 8:
                 *(uint64_t *)dst = reg_value.GetAsUInt64();
                 break;
+            case 16:
+                lhs = reg_value.GetAsUInt128(fail_value);
+                src = lhs.getRawData();
+                *(uint64_t *)dst = *src; 
+                *(uint64_t *)(dst + 8) = *(src + 1);
+                break;
             default:
                 assert(false && "Unhandled data size.");
                 error.SetErrorStringWithFormat ("unhandled byte size: %" PRIu32, reg_info->byte_size);
                 break;
         }
-        error = WriteFPR();
+        error = WriteCP1();
         if (!error.Success())
         {
-            error.SetErrorString ("failed to write floating point register");
+            error.SetErrorString ("failed to write co-processor 1 register");
             return error;
         }
     }
     else
     {
         error = WriteRegisterRaw(reg_index, reg_value);
     }
 
NativeRegisterContextLinux_mips64::ReadAllRegisterValues (lldb::DataBufferSP &data_sp)
 
     error = ReadGPR();
     if (!error.Success())
     {
         error.SetErrorString ("ReadGPR() failed");
         return error;
     }
 
-    error = ReadFPR();
+    error = ReadCP1();
     if (!error.Success())
     {
-        error.SetErrorString ("ReadFPR() failed");
+        error.SetErrorString ("ReadCP1() failed");
         return error;
     }
 
     uint8_t *dst = data_sp->GetBytes ();
     if (dst == nullptr)
     {
         error.SetErrorStringWithFormat ("DataBufferHeap instance of size %" PRIu64 " returned a null pointer", REG_CONTEXT_SIZE);
         return error;
     }
 
-    ::memcpy (dst, &m_gpr_mips64, GetRegisterInfoInterface ().GetGPRSize ());
+    ::memcpy (dst, &m_gpr, GetRegisterInfoInterface ().GetGPRSize ());
     dst += GetRegisterInfoInterface ().GetGPRSize ();
 
-    ::memcpy (dst, &m_fpr, sizeof(FPR_mips));
+    ::memcpy (dst, &m_fpr, GetFPRSize ());
+    dst += GetFPRSize ();
+
+    ::memcpy (dst, &m_msa, sizeof(MSA_linux_mips));
 
     return error;
 }
 
 Error
 NativeRegisterContextLinux_mips64::WriteAllRegisterValues (const lldb::DataBufferSP &data_sp)
 {
     Error error;
NativeRegisterContextLinux_mips64::WriteAllRegisterValues (const lldb::DataBufferSP &data_sp)
 
 
     uint8_t *src = data_sp->GetBytes ();
     if (src == nullptr)
     {
         error.SetErrorStringWithFormat ("NativeRegisterContextLinux_mips64::%s DataBuffer::GetBytes() returned a null pointer", __FUNCTION__);
         return error;
     }
-    ::memcpy (&m_gpr_mips64, src, GetRegisterInfoInterface ().GetGPRSize ());
+
+    ::memcpy (&m_gpr, src, GetRegisterInfoInterface ().GetGPRSize ());
     src += GetRegisterInfoInterface ().GetGPRSize ();
 
-    ::memcpy (&m_fpr, src, sizeof(FPR_mips));
+    ::memcpy (&m_fpr, src, GetFPRSize ());
+    src += GetFPRSize ();
+
+    ::memcpy (&m_msa, src, sizeof(MSA_linux_mips));
 
     error = WriteGPR();
     if (!error.Success())
     {
         error.SetErrorStringWithFormat ("NativeRegisterContextLinux_mips64::%s WriteGPR() failed", __FUNCTION__);
         return error;
     }
 
-    error = WriteFPR();
+    error = WriteCP1();
     if (!error.Success())
     {
-        error.SetErrorStringWithFormat ("NativeRegisterContextLinux_mips64::%s WriteFPR() failed", __FUNCTION__);
+        error.SetErrorStringWithFormat ("NativeRegisterContextLinux_mips64::%s WriteCP1() failed", __FUNCTION__);
         return error;
     }
 
     return error;
 }
 
 Error
-NativeRegisterContextLinux_mips64::ReadFPR()
+NativeRegisterContextLinux_mips64::ReadCP1()
 {
-    void* buf = GetFPRBuffer();
-    if (!buf)
-        return Error("FPR buffer is NULL");
+    Error error;
+
+    uint8_t *src, *dst;
+
+    lldb::ByteOrder byte_order = GetByteOrder();
 
-    Error error = NativeRegisterContextLinux::ReadFPR();
+    uint32_t IsBigEndian = (byte_order == lldb::eByteOrderBig);
 
-    if (IsFR0())
+    if (IsMSAAvailable())
     {
-         for (int i = 0; i < 16; i++)
+        error = NativeRegisterContextLinux::ReadRegisterSet(&m_iovec, sizeof(MSA_linux_mips), NT_MIPS_MSA);
+        src = (uint8_t *)&m_msa + (IsBigEndian * 8);
+        dst = (uint8_t *)&m_fpr;
+        for ( int i = 0; i < NUM_REGISTERS; i++)
+        {
+            // Copy fp values from msa buffer fetched via ptrace
+            *(uint64_t *) dst = *(uint64_t *) src;
+            src = src + 16;
+            dst = dst + 8;
+        }
+        m_fpr.fir = m_msa.fir;
+        m_fpr.fcsr = m_msa.fcsr;
+        m_fpr.config5 = m_msa.config5;
+    }
+    else
+    {
+        error = NativeRegisterContextLinux::ReadFPR();
+    }
+
+    if (IsFR0() || IsFRE())
+    {
+         src = (uint8_t *)&m_fpr + 4 + (IsBigEndian * 4);
+         dst = (uint8_t *)&m_fpr + 8 + (IsBigEndian * 4);
+         for (int i = 0; i < (NUM_REGISTERS / 2); i++)
          {
               // copy odd single from top of neighbouring even double
-              uint8_t * src = (uint8_t *)buf + 4 + (i * 16);
-              uint8_t * dst = (uint8_t *)buf + 8 + (i * 16);
               *(uint32_t *) dst = *(uint32_t *) src;
+              src = src + 16;
+              dst = dst + 16;
          }
     }
 
     return error;
 }
 
 Error
-NativeRegisterContextLinux_mips64::WriteFPR()
+NativeRegisterContextLinux_mips64::WriteCP1()
 {
-    void* buf = GetFPRBuffer();
-    if (!buf)
-        return Error("FPR buffer is NULL");
+    Error error;
 
-    if (IsFR0())
+    uint8_t *src, *dst;
+
+    lldb::ByteOrder byte_order = GetByteOrder();
+
+    uint32_t IsBigEndian = (byte_order == lldb::eByteOrderBig);
+
+    if (IsFR0() || IsFRE())
     {
-         for (int i = 0; i < 16; i++)
-         {
+        src = (uint8_t *)&m_fpr + 8 + (IsBigEndian * 4);
+        dst = (uint8_t *)&m_fpr + 4 + (IsBigEndian * 4);
+        for (int i = 0; i < (NUM_REGISTERS / 2); i++)
              // copy odd single to top of neighbouring even double
-             uint8_t * src = (uint8_t *)buf + 8 + (i * 16);
-             uint8_t * dst = (uint8_t *)buf + 4 + (i * 16);
              *(uint32_t *) dst = *(uint32_t *) src;
-         }
+             src = src + 16;
+             dst = dst + 16;
+        }
+    }
+
+    if (IsMSAAvailable())
+    {
+        dst = (uint8_t *)&m_msa + (IsBigEndian * 8);
+        src = (uint8_t *)&m_fpr;
+        for (int i = 0; i < NUM_REGISTERS; i++)
+        {
+            // Copy fp values to msa buffer for ptrace
+            *(uint64_t *) dst = *(uint64_t *) src;
+            dst = dst + 16;
+            src = src + 8;
+        }
+        m_msa.fir = m_fpr.fir;
+        m_msa.fcsr = m_fpr.fcsr;
+        m_msa.config5 = m_fpr.config5;
+        error = NativeRegisterContextLinux::WriteRegisterSet(&m_iovec, sizeof(MSA_linux_mips), NT_MIPS_MSA);
+    else
+    {
+        error = NativeRegisterContextLinux::WriteFPR();
     }
 
-    return NativeRegisterContextLinux::WriteFPR();
+    return error;
 }
 
 bool
 NativeRegisterContextLinux_mips64::IsFR0()
 {
-    const RegisterInfo *const reg_info_p = GetRegisterInfoAtIndex (36); // Status Register is at index 36 of the register array
+    const RegisterInfo *const reg_info_p = GetRegisterInfoAtIndex (gpr_sr_mips64);
 
     RegisterValue reg_value;
     ReadRegister (reg_info_p, reg_value);
 
     uint64_t value = reg_value.GetAsUInt64();
 
-    return (!(value & 0x4000000));
+    return (!(value & SR_FR));
+}
+
+bool
+NativeRegisterContextLinux_mips64::IsFRE()
+{
+    const RegisterInfo *const reg_info_p = GetRegisterInfoAtIndex (gpr_config5_mips64);
+
+    RegisterValue reg_value;
+    ReadRegister (reg_info_p, reg_value);
+
+    uint64_t config5 = reg_value.GetAsUInt64();
+
+    return (config5 & CONFIG5_FRE);
 }
 
 bool
 NativeRegisterContextLinux_mips64::IsFPR(uint32_t reg_index) const
 {
     return (m_reg_info.first_fpr <= reg_index && reg_index <= m_reg_info.last_fpr);
 }
 
if(vacant_watches > 0)
                     addr = break_addr;
                 }
             }
         }
     }
     return 0;
 }
 
+bool
+NativeRegisterContextLinux_mips64::IsMSA(uint32_t reg_index) const
+{
+    return (m_reg_info.first_msa <= reg_index && reg_index <= m_reg_info.last_msa);
+}
+
+bool
+NativeRegisterContextLinux_mips64::IsMSAAvailable()
+{
+    Error error = NativeRegisterContextLinux::ReadRegisterSet(&m_msa, sizeof(MSA_linux_mips), NT_MIPS_MSA);
+
+    if (error.Success() && m_msa.mir)
+    {
+        return true;
+    }
+
+    return false;
+}
+
 Error
 NativeRegisterContextLinux_mips64::IsWatchpointHit (uint32_t wp_index, bool &is_hit)
 {
     if (wp_index >= NumSupportedHardwareWatchpoints())
         return Error("Watchpoint index out of range");
 
     // reading the current state of watch regs
     struct pt_watch_regs watch_readback;
NativeRegisterContextLinux_mips64::NumSupportedHardwareWatchpoints ()
     return num_valid;
 }
 Error
 NativeRegisterContextLinux_mips64::DoReadRegisterValue(uint32_t offset,
                                                        const char* reg_name,
                                                        uint32_t size,
                                                        RegisterValue &value)
 {
-    elf_gregset_t regs;
+    GPR_linux_mips regs;
+    ::memset(&regs, 0, sizeof(GPR_linux_mips));
     Error error = NativeProcessLinux::PtraceWrapper(PTRACE_GETREGS, m_thread.GetID(), NULL, &regs, sizeof regs);
     if (error.Success())
     {
         lldb_private::ArchSpec arch;
         if (m_thread.GetProcess()->GetArchitecture(arch))
-            value.SetBytes((void *)(((unsigned char *)(regs)) + offset), 8, arch.GetByteOrder());
+            value.SetBytes((void *)(((unsigned char *)(&regs)) + offset), 8, arch.GetByteOrder());
         else
             error.SetErrorString("failed to get architecture");
     }
     return error;
 }
 
 Error
 NativeRegisterContextLinux_mips64::DoWriteRegisterValue(uint32_t offset,

source/Plugins/Process/Utility/RegisterContextFreeBSD_mips64.cpp

typedef struct _GPR
     uint64_t sr;
     uint64_t mullo;
     uint64_t mulhi;
     uint64_t badvaddr;
     uint64_t cause;
     uint64_t pc;
     uint64_t ic;
     uint64_t dummy;
-} GPR;
+} GPR_freebsd_mips;
 
 //---------------------------------------------------------------------------
 // Include RegisterInfos_mips64 to declare our g_register_infos_mips64 structure.
 //---------------------------------------------------------------------------
 #define DECLARE_REGISTER_INFOS_MIPS64_STRUCT
 #include "RegisterInfos_mips64.h"
 #undef DECLARE_REGISTER_INFOS_MIPS64_STRUCT
 
 RegisterContextFreeBSD_mips64::RegisterContextFreeBSD_mips64(const ArchSpec &target_arch) :
     RegisterInfoInterface(target_arch)
 {
 }
 
 size_t
 RegisterContextFreeBSD_mips64::GetGPRSize() const
 {
-    return sizeof(GPR);
+    return sizeof(GPR_freebsd_mips);
 }
 
 const RegisterInfo *
 RegisterContextFreeBSD_mips64::GetRegisterInfo() const
 {
     assert (m_target_arch.GetCore() == ArchSpec::eCore_mips64);
     return g_register_infos_mips64;
 }
 
 uint32_t
 RegisterContextFreeBSD_mips64::GetRegisterCount () const
 {
     return static_cast<uint32_t> (sizeof (g_register_infos_mips64) / sizeof (g_register_infos_mips64 [0]));
 }
 
 

source/Plugins/Process/Utility/RegisterContextLinux_mips.h

public:
     size_t
     GetGPRSize() const override;
 
     const lldb_private::RegisterInfo *
     GetRegisterInfo() const override;
 
     uint32_t
     GetRegisterCount () const override;
+
+    uint32_t
+    GetUserRegisterCount () const override;
 };
 
 #endif

source/Plugins/Process/Utility/RegisterContextLinux_mips.cpp

 //===-- RegisterContextLinux_mips.cpp ------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 
 #include <vector>
 #include <stddef.h>
 
-// For GDB, GCC and DWARF Register numbers
 #include "RegisterContextLinux_mips.h"
 
 // Internal codes for mips registers
-#include "lldb-mips64-register-enums.h"
-#include "RegisterContext_mips64.h"
+#include "lldb-mips-linux-register-enums.h"
+
+// For GP and FP buffers
+#include "RegisterContext_mips.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
-// GP registers
-typedef struct _GPR
-{
-    uint32_t zero;
-    uint32_t r1;
-    uint32_t r2;
-    uint32_t r3;
-    uint32_t r4;
-    uint32_t r5;
-    uint32_t r6;
-    uint32_t r7;
-    uint32_t r8;
-    uint32_t r9;
-    uint32_t r10;
-    uint32_t r11;
-    uint32_t r12;
-    uint32_t r13;
-    uint32_t r14;
-    uint32_t r15;
-    uint32_t r16;
-    uint32_t r17;
-    uint32_t r18;
-    uint32_t r19;
-    uint32_t r20;
-    uint32_t r21;
-    uint32_t r22;
-    uint32_t r23;
-    uint32_t r24;
-    uint32_t r25;
-    uint32_t r26;
-    uint32_t r27;
-    uint32_t gp;
-    uint32_t sp;
-    uint32_t r30;
-    uint32_t ra;
-    uint32_t mullo;
-    uint32_t mulhi;
-    uint32_t pc;
-    uint32_t badvaddr;
-    uint32_t sr;
-    uint32_t cause;
-} GPR;
-
 //---------------------------------------------------------------------------
 // Include RegisterInfos_mips to declare our g_register_infos_mips structure.
 //---------------------------------------------------------------------------
 #define DECLARE_REGISTER_INFOS_MIPS_STRUCT
 #include "RegisterInfos_mips.h"
 #undef DECLARE_REGISTER_INFOS_MIPS_STRUCT
 
 RegisterContextLinux_mips::RegisterContextLinux_mips(const ArchSpec &target_arch) :
     RegisterInfoInterface(target_arch)
 {
 }
 
 size_t
 RegisterContextLinux_mips::GetGPRSize() const
 {
-    return sizeof(GPR);
+    return sizeof(GPR_linux_mips);
 }
 
 const RegisterInfo *
 RegisterContextLinux_mips::GetRegisterInfo() const
 {
     switch (m_target_arch.GetMachine())
     {
         case llvm::Triple::mips:
         case llvm::Triple::mipsel:
             return g_register_infos_mips;
         default:
             assert(false && "Unhandled target architecture.");
             return NULL;
     }
 }
 
 uint32_t
 RegisterContextLinux_mips::GetRegisterCount () const
 {
     return static_cast<uint32_t> (sizeof (g_register_infos_mips) / sizeof (g_register_infos_mips [0]));
 }
+
+uint32_t
+RegisterContextLinux_mips::GetUserRegisterCount () const
+{
+    return static_cast<uint32_t> (k_num_user_registers_mips);
+}

source/Plugins/Process/Utility/RegisterContextLinux_mips64.h

public:
     GetGPRSize() const override;
 
     const lldb_private::RegisterInfo *
     GetRegisterInfo() const override;
 
     uint32_t
     GetRegisterCount () const override;
 
+    uint32_t
+    GetUserRegisterCount () const override;
+
 private:
     const lldb_private::RegisterInfo *m_register_info_p;
     uint32_t m_register_info_count;
+    uint32_t m_user_register_count;
 };
 
 #endif
 
 #endif

source/Plugins/Process/Utility/RegisterContextLinux_mips64.cpp

 //===-- RegisterContextLinux_mips64.cpp ------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 
 #if defined (__mips__)
 
 #include <vector>
 #include <stddef.h>
 
-// For GDB, GCC and DWARF Register numbers
 #include "RegisterContextLinux_mips64.h"
 
-// Internal codes for all mips64 registers
-#include "lldb-mips64-register-enums.h"
-#include "RegisterContext_mips64.h"
+// For GP and FP buffers
+#include "RegisterContext_mips.h"
+
+// Internal codes for all mips32 and mips64 registers
+#include "lldb-mips-linux-register-enums.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-// GP registers
-typedef struct _GPR
-{
-    uint64_t zero;
-    uint64_t r1;
-    uint64_t r2;
-    uint64_t r3;
-    uint64_t r4;
-    uint64_t r5;
-    uint64_t r6;
-    uint64_t r7;
-    uint64_t r8;
-    uint64_t r9;
-    uint64_t r10;
-    uint64_t r11;
-    uint64_t r12;
-    uint64_t r13;
-    uint64_t r14;
-    uint64_t r15;
-    uint64_t r16;
-    uint64_t r17;
-    uint64_t r18;
-    uint64_t r19;
-    uint64_t r20;
-    uint64_t r21;
-    uint64_t r22;
-    uint64_t r23;
-    uint64_t r24;
-    uint64_t r25;
-    uint64_t r26;
-    uint64_t r27;
-    uint64_t gp;
-    uint64_t sp;
-    uint64_t r30;
-    uint64_t ra;
-    uint64_t mullo;
-    uint64_t mulhi;
-    uint64_t pc;
-    uint64_t badvaddr;
-    uint64_t sr;
-    uint64_t cause;
-    uint64_t ic;
-    uint64_t dummy;
-} GPR;
-
 //---------------------------------------------------------------------------
 // Include RegisterInfos_mips64 to declare our g_register_infos_mips64 structure.
 //---------------------------------------------------------------------------
 #define DECLARE_REGISTER_INFOS_MIPS64_STRUCT
+#define LINUX_MIPS64
 #include "RegisterInfos_mips64.h"
+#undef LINUX_MIPS64
 #undef DECLARE_REGISTER_INFOS_MIPS64_STRUCT
 
 //---------------------------------------------------------------------------
 // Include RegisterInfos_mips to declare our g_register_infos_mips structure.
 //---------------------------------------------------------------------------
 #define DECLARE_REGISTER_INFOS_MIPS_STRUCT
 #include "RegisterInfos_mips.h"
 #undef DECLARE_REGISTER_INFOS_MIPS_STRUCT
switch (target_arch.GetMachine())
         case llvm::Triple::mipsel:
             return static_cast<uint32_t> (sizeof (g_register_infos_mips) / sizeof (g_register_infos_mips [0]));
         default:
             assert(false && "Unhandled target architecture.");
             return 0;
     }
 }
 
+uint32_t
+GetUserRegisterInfoCount (const ArchSpec &target_arch)
+{
+    switch (target_arch.GetMachine())
+    {
+        case llvm::Triple::mips:
+        case llvm::Triple::mipsel:
+            return static_cast<uint32_t> (k_num_user_registers_mips);
+        case llvm::Triple::mips64el:
+        case llvm::Triple::mips64:
+            return static_cast<uint32_t> (k_num_user_registers_mips64);
+        default:
+            assert(false && "Unhandled target architecture.");
+            return 0;
+    }
+}
+
 RegisterContextLinux_mips64::RegisterContextLinux_mips64(const ArchSpec &target_arch) :
     lldb_private::RegisterInfoInterface(target_arch),
     m_register_info_p (GetRegisterInfoPtr (target_arch)),
-    m_register_info_count (GetRegisterInfoCount (target_arch))
+    m_register_info_count (GetRegisterInfoCount (target_arch)),
+    m_user_register_count (GetUserRegisterInfoCount (target_arch))
 {
 }
 
 size_t
 RegisterContextLinux_mips64::GetGPRSize() const
 {
-    return sizeof(GPR);
+    return sizeof(GPR_linux_mips);
 }
 
 const RegisterInfo *
 RegisterContextLinux_mips64::GetRegisterInfo() const
 {
     return m_register_info_p;
 }
 
 uint32_t
 RegisterContextLinux_mips64::GetRegisterCount () const
 {
     return m_register_info_count;
 }
 
+uint32_t
+RegisterContextLinux_mips64::GetUserRegisterCount () const
+{
+    return m_user_register_count;
+}
+
 #endif

source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.h

 //===-- RegisterContextPOSIX_mips64.h ---------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_RegisterContextPOSIX_mips64_H_
 #define liblldb_RegisterContextPOSIX_mips64_H_
 
 #include "lldb/Core/Log.h"
 #include "RegisterContextPOSIX.h"
-#include "RegisterContext_mips64.h"
-#include "lldb-mips64-register-enums.h"
+#include "RegisterContext_mips.h"
+#include "lldb-mips-freebsd-register-enums.h"
 
 using namespace lldb_private;
 
 class ProcessMonitor;
 
 class RegisterContextPOSIX_mips64
   : public lldb_private::RegisterContext
 {

source/Plugins/Process/Utility/RegisterContext_mips.h

+//===-- RegisterContext_mips.h --------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_RegisterContext_mips64_H_
+#define liblldb_RegisterContext_mips64_H_
+
+#if defined(__mips64)
+    #define ENABLE_128_BIT_SUPPORT 1
+#endif
+
+// GCC and DWARF Register numbers (eRegisterKindGCC & eRegisterKindDWARF)
+enum
+{
+    // GP Registers
+    gcc_dwarf_zero_mips = 0,
+    gcc_dwarf_r1_mips,
+    gcc_dwarf_r2_mips,
+    gcc_dwarf_r3_mips,
+    gcc_dwarf_r4_mips,
+    gcc_dwarf_r5_mips,
+    gcc_dwarf_r6_mips,
+    gcc_dwarf_r7_mips,
+    gcc_dwarf_r8_mips,
+    gcc_dwarf_r9_mips,
+    gcc_dwarf_r10_mips,
+    gcc_dwarf_r11_mips,
+    gcc_dwarf_r12_mips,
+    gcc_dwarf_r13_mips,
+    gcc_dwarf_r14_mips,
+    gcc_dwarf_r15_mips,
+    gcc_dwarf_r16_mips,
+    gcc_dwarf_r17_mips,
+    gcc_dwarf_r18_mips,
+    gcc_dwarf_r19_mips,
+    gcc_dwarf_r20_mips,
+    gcc_dwarf_r21_mips,
+    gcc_dwarf_r22_mips,
+    gcc_dwarf_r23_mips,
+    gcc_dwarf_r24_mips,
+    gcc_dwarf_r25_mips,
+    gcc_dwarf_r26_mips,
+    gcc_dwarf_r27_mips,
+    gcc_dwarf_gp_mips,
+    gcc_dwarf_sp_mips,
+    gcc_dwarf_r30_mips,
+    gcc_dwarf_ra_mips,
+    gcc_dwarf_sr_mips,
+    gcc_dwarf_lo_mips,
+    gcc_dwarf_hi_mips,
+    gcc_dwarf_bad_mips,
+    gcc_dwarf_cause_mips,
+    gcc_dwarf_pc_mips,
+    gcc_dwarf_f0_mips,
+    gcc_dwarf_f1_mips,
+    gcc_dwarf_f2_mips,
+    gcc_dwarf_f3_mips,
+    gcc_dwarf_f4_mips,
+    gcc_dwarf_f5_mips,
+    gcc_dwarf_f6_mips,
+    gcc_dwarf_f7_mips,
+    gcc_dwarf_f8_mips,
+    gcc_dwarf_f9_mips,
+    gcc_dwarf_f10_mips,
+    gcc_dwarf_f11_mips,
+    gcc_dwarf_f12_mips,
+    gcc_dwarf_f13_mips,
+    gcc_dwarf_f14_mips,
+    gcc_dwarf_f15_mips,
+    gcc_dwarf_f16_mips,
+    gcc_dwarf_f17_mips,
+    gcc_dwarf_f18_mips,
+    gcc_dwarf_f19_mips,
+    gcc_dwarf_f20_mips,
+    gcc_dwarf_f21_mips,
+    gcc_dwarf_f22_mips,
+    gcc_dwarf_f23_mips,
+    gcc_dwarf_f24_mips,
+    gcc_dwarf_f25_mips,
+    gcc_dwarf_f26_mips,
+    gcc_dwarf_f27_mips,
+    gcc_dwarf_f28_mips,
+    gcc_dwarf_f29_mips,
+    gcc_dwarf_f30_mips,
+    gcc_dwarf_f31_mips,
+    gcc_dwarf_fcsr_mips,
+    gcc_dwarf_fir_mips,
+    gcc_dwarf_w0_mips,
+    gcc_dwarf_w1_mips,
+    gcc_dwarf_w2_mips,
+    gcc_dwarf_w3_mips,
+    gcc_dwarf_w4_mips,
+    gcc_dwarf_w5_mips,
+    gcc_dwarf_w6_mips,
+    gcc_dwarf_w7_mips,
+    gcc_dwarf_w8_mips,
+    gcc_dwarf_w9_mips,
+    gcc_dwarf_w10_mips,
+    gcc_dwarf_w11_mips,
+    gcc_dwarf_w12_mips,
+    gcc_dwarf_w13_mips,
+    gcc_dwarf_w14_mips,
+    gcc_dwarf_w15_mips,
+    gcc_dwarf_w16_mips,
+    gcc_dwarf_w17_mips,
+    gcc_dwarf_w18_mips,
+    gcc_dwarf_w19_mips,
+    gcc_dwarf_w20_mips,
+    gcc_dwarf_w21_mips,
+    gcc_dwarf_w22_mips,
+    gcc_dwarf_w23_mips,
+    gcc_dwarf_w24_mips,
+    gcc_dwarf_w25_mips,
+    gcc_dwarf_w26_mips,
+    gcc_dwarf_w27_mips,
+    gcc_dwarf_w28_mips,
+    gcc_dwarf_w29_mips,
+    gcc_dwarf_w30_mips,
+    gcc_dwarf_w31_mips,
+    gcc_dwarf_mcsr_mips,
+    gcc_dwarf_mir_mips,
+    gcc_dwarf_config5_mips,
+    gcc_dwarf_ic_mips,
+    gcc_dwarf_dummy_mips
+};
+
+enum
+{
+    gcc_dwarf_zero_mips64 = 0,
+    gcc_dwarf_r1_mips64,
+    gcc_dwarf_r2_mips64,
+    gcc_dwarf_r3_mips64,
+    gcc_dwarf_r4_mips64,
+    gcc_dwarf_r5_mips64,
+    gcc_dwarf_r6_mips64,
+    gcc_dwarf_r7_mips64,
+    gcc_dwarf_r8_mips64,
+    gcc_dwarf_r9_mips64,
+    gcc_dwarf_r10_mips64,
+    gcc_dwarf_r11_mips64,
+    gcc_dwarf_r12_mips64,
+    gcc_dwarf_r13_mips64,
+    gcc_dwarf_r14_mips64,
+    gcc_dwarf_r15_mips64,
+    gcc_dwarf_r16_mips64,
+    gcc_dwarf_r17_mips64,
+    gcc_dwarf_r18_mips64,
+    gcc_dwarf_r19_mips64,
+    gcc_dwarf_r20_mips64,
+    gcc_dwarf_r21_mips64,
+    gcc_dwarf_r22_mips64,
+    gcc_dwarf_r23_mips64,
+    gcc_dwarf_r24_mips64,
+    gcc_dwarf_r25_mips64,
+    gcc_dwarf_r26_mips64,
+    gcc_dwarf_r27_mips64,
+    gcc_dwarf_gp_mips64,
+    gcc_dwarf_sp_mips64,
+    gcc_dwarf_r30_mips64,
+    gcc_dwarf_ra_mips64,
+    gcc_dwarf_sr_mips64,
+    gcc_dwarf_lo_mips64,
+    gcc_dwarf_hi_mips64,
+    gcc_dwarf_bad_mips64,
+    gcc_dwarf_cause_mips64,
+    gcc_dwarf_pc_mips64,
+    gcc_dwarf_f0_mips64,
+    gcc_dwarf_f1_mips64,
+    gcc_dwarf_f2_mips64,
+    gcc_dwarf_f3_mips64,
+    gcc_dwarf_f4_mips64,
+    gcc_dwarf_f5_mips64,
+    gcc_dwarf_f6_mips64,
+    gcc_dwarf_f7_mips64,
+    gcc_dwarf_f8_mips64,
+    gcc_dwarf_f9_mips64,
+    gcc_dwarf_f10_mips64,
+    gcc_dwarf_f11_mips64,
+    gcc_dwarf_f12_mips64,
+    gcc_dwarf_f13_mips64,
+    gcc_dwarf_f14_mips64,
+    gcc_dwarf_f15_mips64,
+    gcc_dwarf_f16_mips64,
+    gcc_dwarf_f17_mips64,
+    gcc_dwarf_f18_mips64,
+    gcc_dwarf_f19_mips64,
+    gcc_dwarf_f20_mips64,
+    gcc_dwarf_f21_mips64,
+    gcc_dwarf_f22_mips64,
+    gcc_dwarf_f23_mips64,
+    gcc_dwarf_f24_mips64,
+    gcc_dwarf_f25_mips64,
+    gcc_dwarf_f26_mips64,
+    gcc_dwarf_f27_mips64,
+    gcc_dwarf_f28_mips64,
+    gcc_dwarf_f29_mips64,
+    gcc_dwarf_f30_mips64,
+    gcc_dwarf_f31_mips64,
+    gcc_dwarf_fcsr_mips64,
+    gcc_dwarf_fir_mips64,
+    gcc_dwarf_ic_mips64,
+    gcc_dwarf_dummy_mips64,
+    gcc_dwarf_w0_mips64,
+    gcc_dwarf_w1_mips64,
+    gcc_dwarf_w2_mips64,
+    gcc_dwarf_w3_mips64,
+    gcc_dwarf_w4_mips64,
+    gcc_dwarf_w5_mips64,
+    gcc_dwarf_w6_mips64,
+    gcc_dwarf_w7_mips64,
+    gcc_dwarf_w8_mips64,
+    gcc_dwarf_w9_mips64,
+    gcc_dwarf_w10_mips64,
+    gcc_dwarf_w11_mips64,
+    gcc_dwarf_w12_mips64,
+    gcc_dwarf_w13_mips64,
+    gcc_dwarf_w14_mips64,
+    gcc_dwarf_w15_mips64,
+    gcc_dwarf_w16_mips64,
+    gcc_dwarf_w17_mips64,
+    gcc_dwarf_w18_mips64,
+    gcc_dwarf_w19_mips64,
+    gcc_dwarf_w20_mips64,
+    gcc_dwarf_w21_mips64,
+    gcc_dwarf_w22_mips64,
+    gcc_dwarf_w23_mips64,
+    gcc_dwarf_w24_mips64,
+    gcc_dwarf_w25_mips64,
+    gcc_dwarf_w26_mips64,
+    gcc_dwarf_w27_mips64,
+    gcc_dwarf_w28_mips64,
+    gcc_dwarf_w29_mips64,
+    gcc_dwarf_w30_mips64,
+    gcc_dwarf_w31_mips64,
+    gcc_dwarf_mcsr_mips64,
+    gcc_dwarf_mir_mips64,
+    gcc_dwarf_config5_mips64,
+};
+
+// GDB Register numbers (eRegisterKindGDB)
+enum
+{
+    gdb_zero_mips = 0,
+    gdb_r1_mips,
+    gdb_r2_mips,
+    gdb_r3_mips,
+    gdb_r4_mips,
+    gdb_r5_mips,
+    gdb_r6_mips,
+    gdb_r7_mips,
+    gdb_r8_mips,
+    gdb_r9_mips,
+    gdb_r10_mips,
+    gdb_r11_mips,
+    gdb_r12_mips,
+    gdb_r13_mips,
+    gdb_r14_mips,
+    gdb_r15_mips,
+    gdb_r16_mips,
+    gdb_r17_mips,
+    gdb_r18_mips,
+    gdb_r19_mips,
+    gdb_r20_mips,
+    gdb_r21_mips,
+    gdb_r22_mips,
+    gdb_r23_mips,
+    gdb_r24_mips,
+    gdb_r25_mips,
+    gdb_r26_mips,
+    gdb_r27_mips,
+    gdb_gp_mips,
+    gdb_sp_mips,
+    gdb_r30_mips,
+    gdb_ra_mips,
+    gdb_sr_mips,
+    gdb_lo_mips,
+    gdb_hi_mips,
+    gdb_bad_mips,
+    gdb_cause_mips,
+    gdb_pc_mips,
+    gdb_f0_mips,
+    gdb_f1_mips,
+    gdb_f2_mips,
+    gdb_f3_mips,
+    gdb_f4_mips,
+    gdb_f5_mips,
+    gdb_f6_mips,
+    gdb_f7_mips,
+    gdb_f8_mips,
+    gdb_f9_mips,
+    gdb_f10_mips,
+    gdb_f11_mips,
+    gdb_f12_mips,
+    gdb_f13_mips,
+    gdb_f14_mips,
+    gdb_f15_mips,
+    gdb_f16_mips,
+    gdb_f17_mips,
+    gdb_f18_mips,
+    gdb_f19_mips,
+    gdb_f20_mips,
+    gdb_f21_mips,
+    gdb_f22_mips,
+    gdb_f23_mips,
+    gdb_f24_mips,
+    gdb_f25_mips,
+    gdb_f26_mips,
+    gdb_f27_mips,
+    gdb_f28_mips,
+    gdb_f29_mips,
+    gdb_f30_mips,
+    gdb_f31_mips,
+    gdb_fcsr_mips,
+    gdb_fir_mips,
+    gdb_w0_mips,
+    gdb_w1_mips,
+    gdb_w2_mips,
+    gdb_w3_mips,
+    gdb_w4_mips,
+    gdb_w5_mips,
+    gdb_w6_mips,
+    gdb_w7_mips,
+    gdb_w8_mips,
+    gdb_w9_mips,
+    gdb_w10_mips,
+    gdb_w11_mips,
+    gdb_w12_mips,
+    gdb_w13_mips,
+    gdb_w14_mips,
+    gdb_w15_mips,
+    gdb_w16_mips,
+    gdb_w17_mips,
+    gdb_w18_mips,
+    gdb_w19_mips,
+    gdb_w20_mips,
+    gdb_w21_mips,
+    gdb_w22_mips,
+    gdb_w23_mips,
+    gdb_w24_mips,
+    gdb_w25_mips,
+    gdb_w26_mips,
+    gdb_w27_mips,
+    gdb_w28_mips,
+    gdb_w29_mips,
+    gdb_w30_mips,
+    gdb_w31_mips,
+    gdb_mcsr_mips,
+    gdb_mir_mips,
+    gdb_config5_mips,
+    gdb_ic_mips,
+    gdb_dummy_mips
+};
+
+enum
+{
+    gdb_zero_mips64 = 0,
+    gdb_r1_mips64,
+    gdb_r2_mips64,
+    gdb_r3_mips64,
+    gdb_r4_mips64,
+    gdb_r5_mips64,
+    gdb_r6_mips64,
+    gdb_r7_mips64,
+    gdb_r8_mips64,
+    gdb_r9_mips64,
+    gdb_r10_mips64,
+    gdb_r11_mips64,
+    gdb_r12_mips64,
+    gdb_r13_mips64,
+    gdb_r14_mips64,
+    gdb_r15_mips64,
+    gdb_r16_mips64,
+    gdb_r17_mips64,
+    gdb_r18_mips64,
+    gdb_r19_mips64,
+    gdb_r20_mips64,
+    gdb_r21_mips64,
+    gdb_r22_mips64,
+    gdb_r23_mips64,
+    gdb_r24_mips64,
+    gdb_r25_mips64,
+    gdb_r26_mips64,
+    gdb_r27_mips64,
+    gdb_gp_mips64,
+    gdb_sp_mips64,
+    gdb_r30_mips64,
+    gdb_ra_mips64,
+    gdb_sr_mips64,
+    gdb_lo_mips64,
+    gdb_hi_mips64,
+    gdb_bad_mips64,
+    gdb_cause_mips64,
+    gdb_pc_mips64,
+    gdb_f0_mips64,
+    gdb_f1_mips64,
+    gdb_f2_mips64,
+    gdb_f3_mips64,
+    gdb_f4_mips64,
+    gdb_f5_mips64,
+    gdb_f6_mips64,
+    gdb_f7_mips64,
+    gdb_f8_mips64,
+    gdb_f9_mips64,
+    gdb_f10_mips64,
+    gdb_f11_mips64,
+    gdb_f12_mips64,
+    gdb_f13_mips64,
+    gdb_f14_mips64,
+    gdb_f15_mips64,
+    gdb_f16_mips64,
+    gdb_f17_mips64,
+    gdb_f18_mips64,
+    gdb_f19_mips64,
+    gdb_f20_mips64,
+    gdb_f21_mips64,
+    gdb_f22_mips64,
+    gdb_f23_mips64,
+    gdb_f24_mips64,
+    gdb_f25_mips64,
+    gdb_f26_mips64,
+    gdb_f27_mips64,
+    gdb_f28_mips64,
+    gdb_f29_mips64,
+    gdb_f30_mips64,
+    gdb_f31_mips64,
+    gdb_fcsr_mips64,
+    gdb_fir_mips64,
+    gdb_ic_mips64,
+    gdb_dummy_mips64,
+    gdb_w0_mips64,
+    gdb_w1_mips64,
+    gdb_w2_mips64,
+    gdb_w3_mips64,
+    gdb_w4_mips64,
+    gdb_w5_mips64,
+    gdb_w6_mips64,
+    gdb_w7_mips64,
+    gdb_w8_mips64,
+    gdb_w9_mips64,
+    gdb_w10_mips64,
+    gdb_w11_mips64,
+    gdb_w12_mips64,
+    gdb_w13_mips64,
+    gdb_w14_mips64,
+    gdb_w15_mips64,
+    gdb_w16_mips64,
+    gdb_w17_mips64,
+    gdb_w18_mips64,
+    gdb_w19_mips64,
+    gdb_w20_mips64,
+    gdb_w21_mips64,
+    gdb_w22_mips64,
+    gdb_w23_mips64,
+    gdb_w24_mips64,
+    gdb_w25_mips64,
+    gdb_w26_mips64,
+    gdb_w27_mips64,
+    gdb_w28_mips64,
+    gdb_w29_mips64,
+    gdb_w30_mips64,
+    gdb_w31_mips64,
+    gdb_mcsr_mips64,
+    gdb_mir_mips64,
+    gdb_config5_mips64,
+};
+
+struct IOVEC_mips
+{
+    void    *iov_base;
+    size_t   iov_len;
+};
+
+// GP registers
+struct GPR_linux_mips
+{
+    uint64_t zero;
+    uint64_t r1;
+    uint64_t r2;
+    uint64_t r3;
+    uint64_t r4;
+    uint64_t r5;
+    uint64_t r6;
+    uint64_t r7;
+    uint64_t r8;
+    uint64_t r9;
+    uint64_t r10;
+    uint64_t r11;
+    uint64_t r12;
+    uint64_t r13;
+    uint64_t r14;
+    uint64_t r15;
+    uint64_t r16;
+    uint64_t r17;
+    uint64_t r18;
+    uint64_t r19;
+    uint64_t r20;
+    uint64_t r21;
+    uint64_t r22;
+    uint64_t r23;
+    uint64_t r24;
+    uint64_t r25;
+    uint64_t r26;
+    uint64_t r27;
+    uint64_t gp;
+    uint64_t sp;
+    uint64_t r30;
+    uint64_t ra;
+    uint64_t mullo;
+    uint64_t mulhi;
+    uint64_t pc;
+    uint64_t badvaddr;
+    uint64_t sr;
+    uint64_t cause;
+    uint64_t config5;
+};
+
+struct FPR_linux_mips
+{
+     uint64_t f0;
+     uint64_t f1;
+     uint64_t f2;
+     uint64_t f3;
+     uint64_t f4;
+     uint64_t f5;
+     uint64_t f6;
+     uint64_t f7;
+     uint64_t f8;
+     uint64_t f9;
+     uint64_t f10;
+     uint64_t f11;
+     uint64_t f12;
+     uint64_t f13;
+     uint64_t f14;
+     uint64_t f15;
+     uint64_t f16;
+     uint64_t f17;
+     uint64_t f18;
+     uint64_t f19;
+     uint64_t f20;
+     uint64_t f21;
+     uint64_t f22;
+     uint64_t f23;
+     uint64_t f24;
+     uint64_t f25;
+     uint64_t f26;
+     uint64_t f27;
+     uint64_t f28;
+     uint64_t f29;
+     uint64_t f30;
+     uint64_t f31;
+     uint32_t fcsr;
+     uint32_t fir;
+     uint32_t config5;
+};
+
+struct MSAReg
+{
+    uint8_t byte[16];
+};
+
+struct MSA_linux_mips
+{
+    MSAReg  w0;
+    MSAReg  w1;
+    MSAReg  w2;
+    MSAReg  w3;
+    MSAReg  w4;
+    MSAReg  w5;
+    MSAReg  w6;
+    MSAReg  w7;
+    MSAReg  w8;
+    MSAReg  w9;
+    MSAReg  w10;
+    MSAReg  w11;
+    MSAReg  w12;
+    MSAReg  w13;
+    MSAReg  w14;
+    MSAReg  w15;
+    MSAReg  w16;
+    MSAReg  w17;
+    MSAReg  w18;
+    MSAReg  w19;
+    MSAReg  w20;
+    MSAReg  w21;
+    MSAReg  w22;
+    MSAReg  w23;
+    MSAReg  w24;
+    MSAReg  w25;
+    MSAReg  w26;
+    MSAReg  w27;
+    MSAReg  w28;
+    MSAReg  w29;
+    MSAReg  w30;
+    MSAReg  w31;
+    uint32_t fcsr;      /* FPU control status register */
+    uint32_t fir;       /* FPU implementaion revision */
+    uint32_t mcsr;      /* MSA control status register */
+    uint32_t mir;       /* MSA implementation revision */
+    uint32_t config5;   /* Config5 register */
+};
+
+struct UserArea
+{
+    GPR_linux_mips gpr; // General purpose registers.
+    FPR_linux_mips fpr; // Floating point registers.
+    MSA_linux_mips msa; // MSA registers.
+};
+
+#endif // liblldb_RegisterContext_mips64_H_

source/Plugins/Process/Utility/RegisterContext_mips64.h

-//===-- RegisterContext_mips64.h --------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_RegisterContext_mips64_H_
-#define liblldb_RegisterContext_mips64_H_
-
-// GCC and DWARF Register numbers (eRegisterKindGCC & eRegisterKindDWARF)
-enum
-{
-    // GP Registers
-    gcc_dwarf_zero_mips = 0,
-    gcc_dwarf_r1_mips,
-    gcc_dwarf_r2_mips,
-    gcc_dwarf_r3_mips,
-    gcc_dwarf_r4_mips,
-    gcc_dwarf_r5_mips,
-    gcc_dwarf_r6_mips,
-    gcc_dwarf_r7_mips,
-    gcc_dwarf_r8_mips,
-    gcc_dwarf_r9_mips,
-    gcc_dwarf_r10_mips,
-    gcc_dwarf_r11_mips,
-    gcc_dwarf_r12_mips,
-    gcc_dwarf_r13_mips,
-    gcc_dwarf_r14_mips,
-    gcc_dwarf_r15_mips,
-    gcc_dwarf_r16_mips,
-    gcc_dwarf_r17_mips,
-    gcc_dwarf_r18_mips,
-    gcc_dwarf_r19_mips,
-    gcc_dwarf_r20_mips,
-    gcc_dwarf_r21_mips,
-    gcc_dwarf_r22_mips,
-    gcc_dwarf_r23_mips,
-    gcc_dwarf_r24_mips,
-    gcc_dwarf_r25_mips,
-    gcc_dwarf_r26_mips,
-    gcc_dwarf_r27_mips,
-    gcc_dwarf_gp_mips,
-    gcc_dwarf_sp_mips,
-    gcc_dwarf_r30_mips,
-    gcc_dwarf_ra_mips,
-    gcc_dwarf_lo_mips,
-    gcc_dwarf_hi_mips,
-    gcc_dwarf_pc_mips,
-    gcc_dwarf_bad_mips,
-    gcc_dwarf_sr_mips,
-    gcc_dwarf_cause_mips,
-    gcc_dwarf_f0_mips,
-    gcc_dwarf_f1_mips,
-    gcc_dwarf_f2_mips,
-    gcc_dwarf_f3_mips,
-    gcc_dwarf_f4_mips,
-    gcc_dwarf_f5_mips,
-    gcc_dwarf_f6_mips,
-    gcc_dwarf_f7_mips,
-    gcc_dwarf_f8_mips,
-    gcc_dwarf_f9_mips,
-    gcc_dwarf_f10_mips,
-    gcc_dwarf_f11_mips,
-    gcc_dwarf_f12_mips,
-    gcc_dwarf_f13_mips,
-    gcc_dwarf_f14_mips,
-    gcc_dwarf_f15_mips,
-    gcc_dwarf_f16_mips,
-    gcc_dwarf_f17_mips,
-    gcc_dwarf_f18_mips,
-    gcc_dwarf_f19_mips,
-    gcc_dwarf_f20_mips,
-    gcc_dwarf_f21_mips,
-    gcc_dwarf_f22_mips,
-    gcc_dwarf_f23_mips,
-    gcc_dwarf_f24_mips,
-    gcc_dwarf_f25_mips,
-    gcc_dwarf_f26_mips,
-    gcc_dwarf_f27_mips,
-    gcc_dwarf_f28_mips,
-    gcc_dwarf_f29_mips,
-    gcc_dwarf_f30_mips,
-    gcc_dwarf_f31_mips,
-    gcc_dwarf_fcsr_mips,
-    gcc_dwarf_fir_mips,
-    gcc_dwarf_ic_mips,
-    gcc_dwarf_dummy_mips
-};
-
-enum
-{
-    gcc_dwarf_zero_mips64 = 0,
-    gcc_dwarf_r1_mips64,
-    gcc_dwarf_r2_mips64,
-    gcc_dwarf_r3_mips64,
-    gcc_dwarf_r4_mips64,
-    gcc_dwarf_r5_mips64,
-    gcc_dwarf_r6_mips64,
-    gcc_dwarf_r7_mips64,
-    gcc_dwarf_r8_mips64,
-    gcc_dwarf_r9_mips64,
-    gcc_dwarf_r10_mips64,
-    gcc_dwarf_r11_mips64,
-    gcc_dwarf_r12_mips64,
-    gcc_dwarf_r13_mips64,
-    gcc_dwarf_r14_mips64,
-    gcc_dwarf_r15_mips64,
-    gcc_dwarf_r16_mips64,
-    gcc_dwarf_r17_mips64,
-    gcc_dwarf_r18_mips64,
-    gcc_dwarf_r19_mips64,
-    gcc_dwarf_r20_mips64,
-    gcc_dwarf_r21_mips64,
-    gcc_dwarf_r22_mips64,
-    gcc_dwarf_r23_mips64,
-    gcc_dwarf_r24_mips64,
-    gcc_dwarf_r25_mips64,
-    gcc_dwarf_r26_mips64,
-    gcc_dwarf_r27_mips64,
-    gcc_dwarf_gp_mips64,
-    gcc_dwarf_sp_mips64,
-    gcc_dwarf_r30_mips64,
-    gcc_dwarf_ra_mips64,
-    gcc_dwarf_sr_mips64,
-    gcc_dwarf_lo_mips64,
-    gcc_dwarf_hi_mips64,
-    gcc_dwarf_bad_mips64,
-    gcc_dwarf_cause_mips64,
-    gcc_dwarf_pc_mips64,
-    gcc_dwarf_f0_mips64,
-    gcc_dwarf_f1_mips64,
-    gcc_dwarf_f2_mips64,
-    gcc_dwarf_f3_mips64,
-    gcc_dwarf_f4_mips64,
-    gcc_dwarf_f5_mips64,
-    gcc_dwarf_f6_mips64,
-    gcc_dwarf_f7_mips64,
-    gcc_dwarf_f8_mips64,
-    gcc_dwarf_f9_mips64,
-    gcc_dwarf_f10_mips64,
-    gcc_dwarf_f11_mips64,
-    gcc_dwarf_f12_mips64,
-    gcc_dwarf_f13_mips64,
-    gcc_dwarf_f14_mips64,
-    gcc_dwarf_f15_mips64,
-    gcc_dwarf_f16_mips64,
-    gcc_dwarf_f17_mips64,
-    gcc_dwarf_f18_mips64,
-    gcc_dwarf_f19_mips64,
-    gcc_dwarf_f20_mips64,
-    gcc_dwarf_f21_mips64,
-    gcc_dwarf_f22_mips64,
-    gcc_dwarf_f23_mips64,
-    gcc_dwarf_f24_mips64,
-    gcc_dwarf_f25_mips64,
-    gcc_dwarf_f26_mips64,
-    gcc_dwarf_f27_mips64,
-    gcc_dwarf_f28_mips64,
-    gcc_dwarf_f29_mips64,
-    gcc_dwarf_f30_mips64,
-    gcc_dwarf_f31_mips64,
-    gcc_dwarf_fcsr_mips64,
-    gcc_dwarf_fir_mips64,
-    gcc_dwarf_ic_mips64,
-    gcc_dwarf_dummy_mips64
-};
-
-// GDB Register numbers (eRegisterKindGDB)
-enum
-{
-    gdb_zero_mips = 0,
-    gdb_r1_mips,
-    gdb_r2_mips,
-    gdb_r3_mips,
-    gdb_r4_mips,
-    gdb_r5_mips,
-    gdb_r6_mips,
-    gdb_r7_mips,
-    gdb_r8_mips,
-    gdb_r9_mips,
-    gdb_r10_mips,
-    gdb_r11_mips,
-    gdb_r12_mips,
-    gdb_r13_mips,
-    gdb_r14_mips,
-    gdb_r15_mips,
-    gdb_r16_mips,
-    gdb_r17_mips,
-    gdb_r18_mips,
-    gdb_r19_mips,
-    gdb_r20_mips,
-    gdb_r21_mips,
-    gdb_r22_mips,
-    gdb_r23_mips,
-    gdb_r24_mips,
-    gdb_r25_mips,
-    gdb_r26_mips,
-    gdb_r27_mips,
-    gdb_gp_mips,
-    gdb_sp_mips,
-    gdb_r30_mips,
-    gdb_ra_mips,
-    gdb_lo_mips,
-    gdb_hi_mips,
-    gdb_pc_mips,
-    gdb_bad_mips,
-    gdb_sr_mips,
-    gdb_cause_mips,
-    gdb_f0_mips,
-    gdb_f1_mips,
-    gdb_f2_mips,
-    gdb_f3_mips,
-    gdb_f4_mips,
-    gdb_f5_mips,
-    gdb_f6_mips,
-    gdb_f7_mips,
-    gdb_f8_mips,
-    gdb_f9_mips,
-    gdb_f10_mips,
-    gdb_f11_mips,
-    gdb_f12_mips,
-    gdb_f13_mips,
-    gdb_f14_mips,
-    gdb_f15_mips,
-    gdb_f16_mips,
-    gdb_f17_mips,
-    gdb_f18_mips,
-    gdb_f19_mips,
-    gdb_f20_mips,
-    gdb_f21_mips,
-    gdb_f22_mips,
-    gdb_f23_mips,
-    gdb_f24_mips,
-    gdb_f25_mips,
-    gdb_f26_mips,
-    gdb_f27_mips,
-    gdb_f28_mips,
-    gdb_f29_mips,
-    gdb_f30_mips,
-    gdb_f31_mips,
-    gdb_fcsr_mips,
-    gdb_fir_mips,
-    gdb_ic_mips,
-    gdb_dummy_mips
-};
-
-enum
-{
-    gdb_zero_mips64 = 0,
-    gdb_r1_mips64,
-    gdb_r2_mips64,
-    gdb_r3_mips64,
-    gdb_r4_mips64,
-    gdb_r5_mips64,
-    gdb_r6_mips64,
-    gdb_r7_mips64,
-    gdb_r8_mips64,
-    gdb_r9_mips64,
-    gdb_r10_mips64,
-    gdb_r11_mips64,
-    gdb_r12_mips64,
-    gdb_r13_mips64,
-    gdb_r14_mips64,
-    gdb_r15_mips64,
-    gdb_r16_mips64,
-    gdb_r17_mips64,
-    gdb_r18_mips64,
-    gdb_r19_mips64,
-    gdb_r20_mips64,
-    gdb_r21_mips64,
-    gdb_r22_mips64,
-    gdb_r23_mips64,
-    gdb_r24_mips64,
-    gdb_r25_mips64,
-    gdb_r26_mips64,
-    gdb_r27_mips64,
-    gdb_gp_mips64,
-    gdb_sp_mips64,
-    gdb_r30_mips64,
-    gdb_ra_mips64,
-    gdb_sr_mips64,
-    gdb_lo_mips64,
-    gdb_hi_mips64,
-    gdb_bad_mips64,
-    gdb_cause_mips64,
-    gdb_pc_mips64,
-    gdb_f0_mips64,
-    gdb_f1_mips64,
-    gdb_f2_mips64,
-    gdb_f3_mips64,
-    gdb_f4_mips64,
-    gdb_f5_mips64,
-    gdb_f6_mips64,
-    gdb_f7_mips64,
-    gdb_f8_mips64,
-    gdb_f9_mips64,
-    gdb_f10_mips64,
-    gdb_f11_mips64,
-    gdb_f12_mips64,
-    gdb_f13_mips64,
-    gdb_f14_mips64,
-    gdb_f15_mips64,
-    gdb_f16_mips64,
-    gdb_f17_mips64,
-    gdb_f18_mips64,
-    gdb_f19_mips64,
-    gdb_f20_mips64,
-    gdb_f21_mips64,
-    gdb_f22_mips64,
-    gdb_f23_mips64,
-    gdb_f24_mips64,
-    gdb_f25_mips64,
-    gdb_f26_mips64,
-    gdb_f27_mips64,
-    gdb_f28_mips64,
-    gdb_f29_mips64,
-    gdb_f30_mips64,
-    gdb_f31_mips64,
-    gdb_fcsr_mips64,
-    gdb_fir_mips64,
-    gdb_ic_mips64,
-    gdb_dummy_mips64
-};
-
-// FP registers
-struct FPR_mips
-{
-    uint64_t    fp_reg[32];
-    uint32_t    fcsr;        /* FPU status register */
-    uint32_t    fir;        /* FPU control register */
-};
-
-#endif // liblldb_RegisterContext_mips64_H_

source/Plugins/Process/Utility/RegisterInfos_mips.h

 //===-- RegisterInfos_mips.h -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 #include "llvm/Support/Compiler.h"
 
 #include <stddef.h>
 
 #ifdef DECLARE_REGISTER_INFOS_MIPS_STRUCT
 
 // Computes the offset of the given GPR in the user data area.
 #define GPR_OFFSET(regname) \
-    (LLVM_EXTENSION offsetof(GPR, regname))
+    (LLVM_EXTENSION offsetof(UserArea, gpr) + \
+     LLVM_EXTENSION offsetof(GPR_linux_mips, regname))
 
 // Computes the offset of the given FPR in the extended data area.
 #define FPR_OFFSET(regname)  \
-     (LLVM_EXTENSION offsetof(FPR_mips, regname))
+     (LLVM_EXTENSION offsetof(UserArea, fpr) + \
+      LLVM_EXTENSION offsetof(FPR_linux_mips, regname))
+
+// Computes the offset of the given MSA in the extended data area.
+#define MSA_OFFSET(regname)  \
+     (LLVM_EXTENSION offsetof(UserArea, msa) + \
+      LLVM_EXTENSION offsetof(MSA_linux_mips, regname))
 
 // Note that the size and offset will be updated by platform-specific classes.
 #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4)            \
-    { #reg, alt, sizeof(((GPR*)NULL)->reg), GPR_OFFSET(reg), eEncodingUint,  \
+    { #reg, alt, sizeof(((GPR_linux_mips*)NULL)->reg) / 2, GPR_OFFSET(reg), eEncodingUint,  \
       eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg##_mips }, NULL, NULL }
 
-#define DEFINE_FPR(member, reg, alt, kind1, kind2, kind3, kind4)           \
-    { #reg, alt, sizeof(((FPR_mips*)NULL)->member) / 2, FPR_OFFSET(member), eEncodingUint,   \
+#define DEFINE_FPR(reg, alt, kind1, kind2, kind3, kind4)           \
+    { #reg, alt, sizeof(((FPR_linux_mips*)NULL)->reg), FPR_OFFSET(reg), eEncodingUint,   \
       eFormatHex, { kind1, kind2, kind3, kind4, fpr_##reg##_mips }, NULL, NULL }
 
-#define DEFINE_FPR_INFO(member, reg, alt, kind1, kind2, kind3, kind4)           \
-    { #reg, alt, sizeof(((FPR_mips*)NULL)->member), FPR_OFFSET(member), eEncodingUint,   \
-      eFormatHex, { kind1, kind2, kind3, kind4, fpr_##reg##_mips }, NULL, NULL }
+#define DEFINE_MSA(reg, alt, kind1, kind2, kind3, kind4)    \
+    { #reg, alt, sizeof(((MSA_linux_mips*)0)->reg), MSA_OFFSET(reg), eEncodingVector,   \
+      eFormatVectorOfUInt8, { kind1, kind2, kind3, kind4, msa_##reg##_mips }, NULL, NULL }
+
+#define DEFINE_MSA_INFO(reg, alt, kind1, kind2, kind3, kind4)    \
+    { #reg, alt, sizeof(((MSA_linux_mips*)0)->reg), MSA_OFFSET(reg), eEncodingUint, \
+      eFormatHex, { kind1, kind2, kind3, kind4, msa_##reg##_mips }, NULL, NULL }
 
 // RegisterKind: GCC, DWARF, Generic, GDB, LLDB
 
 static RegisterInfo
 g_register_infos_mips[] =
 {
     DEFINE_GPR (zero,     "zero", gcc_dwarf_zero_mips,  gcc_dwarf_zero_mips,  LLDB_INVALID_REGNUM,    gdb_zero_mips),
     DEFINE_GPR (r1,       "at",   gcc_dwarf_r1_mips,    gcc_dwarf_r1_mips,    LLDB_INVALID_REGNUM,    gdb_r1_mips),
g_register_infos_mips[] =
     DEFINE_GPR (r24,      NULL,   gcc_dwarf_r24_mips,   gcc_dwarf_r24_mips,   LLDB_INVALID_REGNUM,    gdb_r24_mips),
     DEFINE_GPR (r25,      NULL,   gcc_dwarf_r25_mips,   gcc_dwarf_r25_mips,   LLDB_INVALID_REGNUM,    gdb_r25_mips),
     DEFINE_GPR (r26,      NULL,   gcc_dwarf_r26_mips,   gcc_dwarf_r26_mips,   LLDB_INVALID_REGNUM,    gdb_r26_mips),
     DEFINE_GPR (r27,      NULL,   gcc_dwarf_r27_mips,   gcc_dwarf_r27_mips,   LLDB_INVALID_REGNUM,    gdb_r27_mips),
     DEFINE_GPR (gp,       "gp",   gcc_dwarf_gp_mips,    gcc_dwarf_gp_mips,    LLDB_INVALID_REGNUM,    gdb_gp_mips),
     DEFINE_GPR (sp,       "sp",   gcc_dwarf_sp_mips,    gcc_dwarf_sp_mips,    LLDB_REGNUM_GENERIC_SP, gdb_sp_mips),
     DEFINE_GPR (r30,      "fp",   gcc_dwarf_r30_mips,   gcc_dwarf_r30_mips,   LLDB_REGNUM_GENERIC_FP, gdb_r30_mips),
     DEFINE_GPR (ra,       "ra",   gcc_dwarf_ra_mips,    gcc_dwarf_ra_mips,    LLDB_REGNUM_GENERIC_RA, gdb_ra_mips),
+    DEFINE_GPR (sr,   "status",   gcc_dwarf_sr_mips,    gcc_dwarf_sr_mips,    LLDB_REGNUM_GENERIC_FLAGS,    LLDB_INVALID_REGNUM),
     DEFINE_GPR (mullo,    NULL,   gcc_dwarf_lo_mips,    gcc_dwarf_lo_mips,    LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
     DEFINE_GPR (mulhi,    NULL,   gcc_dwarf_hi_mips,    gcc_dwarf_hi_mips,    LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
-    DEFINE_GPR (pc,       NULL,   gcc_dwarf_pc_mips,    gcc_dwarf_pc_mips,    LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM),
     DEFINE_GPR (badvaddr, NULL,   gcc_dwarf_bad_mips,    gcc_dwarf_bad_mips,    LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
-    DEFINE_GPR (sr,   "status",   gcc_dwarf_sr_mips,    gcc_dwarf_sr_mips,    LLDB_REGNUM_GENERIC_FLAGS,    LLDB_INVALID_REGNUM),
     DEFINE_GPR (cause,    NULL,   gcc_dwarf_cause_mips,    gcc_dwarf_cause_mips,    LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
-    DEFINE_FPR (fp_reg[0],   f0,    NULL,   gcc_dwarf_f0_mips,   gcc_dwarf_f0_mips,   LLDB_INVALID_REGNUM,    gdb_f0_mips),
-    DEFINE_FPR (fp_reg[1],   f1,    NULL,   gcc_dwarf_f1_mips,   gcc_dwarf_f1_mips,   LLDB_INVALID_REGNUM,    gdb_f1_mips),
-    DEFINE_FPR (fp_reg[2],   f2,    NULL,   gcc_dwarf_f2_mips,   gcc_dwarf_f2_mips,   LLDB_INVALID_REGNUM,    gdb_f2_mips),
-    DEFINE_FPR (fp_reg[3],   f3,    NULL,   gcc_dwarf_f3_mips,   gcc_dwarf_f3_mips,   LLDB_INVALID_REGNUM,    gdb_f3_mips),
-    DEFINE_FPR (fp_reg[4],   f4,    NULL,   gcc_dwarf_f4_mips,   gcc_dwarf_f4_mips,   LLDB_INVALID_REGNUM,    gdb_f4_mips),
-    DEFINE_FPR (fp_reg[5],   f5,    NULL,   gcc_dwarf_f5_mips,   gcc_dwarf_f5_mips,   LLDB_INVALID_REGNUM,    gdb_f5_mips),
-    DEFINE_FPR (fp_reg[6],   f6,    NULL,   gcc_dwarf_f6_mips,   gcc_dwarf_f6_mips,   LLDB_INVALID_REGNUM,    gdb_f6_mips),
-    DEFINE_FPR (fp_reg[7],   f7,    NULL,   gcc_dwarf_f7_mips,   gcc_dwarf_f7_mips,   LLDB_INVALID_REGNUM,    gdb_f7_mips),
-    DEFINE_FPR (fp_reg[8],   f8,    NULL,   gcc_dwarf_f8_mips,   gcc_dwarf_f8_mips,   LLDB_INVALID_REGNUM,    gdb_f8_mips),
-    DEFINE_FPR (fp_reg[9],   f9,    NULL,   gcc_dwarf_f9_mips,   gcc_dwarf_f9_mips,   LLDB_INVALID_REGNUM,    gdb_f9_mips),
-    DEFINE_FPR (fp_reg[10],  f10,   NULL,   gcc_dwarf_f10_mips,  gcc_dwarf_f10_mips,  LLDB_INVALID_REGNUM,    gdb_f10_mips),
-    DEFINE_FPR (fp_reg[11],  f11,   NULL,   gcc_dwarf_f11_mips,  gcc_dwarf_f11_mips,  LLDB_INVALID_REGNUM,    gdb_f11_mips),
-    DEFINE_FPR (fp_reg[12],  f12,   NULL,   gcc_dwarf_f12_mips,  gcc_dwarf_f12_mips,  LLDB_INVALID_REGNUM,    gdb_f12_mips),
-    DEFINE_FPR (fp_reg[13],  f13,   NULL,   gcc_dwarf_f13_mips,  gcc_dwarf_f13_mips,  LLDB_INVALID_REGNUM,    gdb_f13_mips),
-    DEFINE_FPR (fp_reg[14],  f14,   NULL,   gcc_dwarf_f14_mips,  gcc_dwarf_f14_mips,  LLDB_INVALID_REGNUM,    gdb_f14_mips),
-    DEFINE_FPR (fp_reg[15],  f15,   NULL,   gcc_dwarf_f15_mips,  gcc_dwarf_f15_mips,  LLDB_INVALID_REGNUM,    gdb_f15_mips),
-    DEFINE_FPR (fp_reg[16],  f16,   NULL,   gcc_dwarf_f16_mips,  gcc_dwarf_f16_mips,  LLDB_INVALID_REGNUM,    gdb_f16_mips),
-    DEFINE_FPR (fp_reg[17],  f17,   NULL,   gcc_dwarf_f17_mips,  gcc_dwarf_f17_mips,  LLDB_INVALID_REGNUM,    gdb_f17_mips),
-    DEFINE_FPR (fp_reg[18],  f18,   NULL,   gcc_dwarf_f18_mips,  gcc_dwarf_f18_mips,  LLDB_INVALID_REGNUM,    gdb_f18_mips),
-    DEFINE_FPR (fp_reg[19],  f19,   NULL,   gcc_dwarf_f19_mips,  gcc_dwarf_f19_mips,  LLDB_INVALID_REGNUM,    gdb_f19_mips),
-    DEFINE_FPR (fp_reg[20],  f20,   NULL,   gcc_dwarf_f20_mips,  gcc_dwarf_f20_mips,  LLDB_INVALID_REGNUM,    gdb_f20_mips),
-    DEFINE_FPR (fp_reg[21],  f21,   NULL,   gcc_dwarf_f21_mips,  gcc_dwarf_f21_mips,  LLDB_INVALID_REGNUM,    gdb_f21_mips),
-    DEFINE_FPR (fp_reg[22],  f22,   NULL,   gcc_dwarf_f22_mips,  gcc_dwarf_f22_mips,  LLDB_INVALID_REGNUM,    gdb_f22_mips),
-    DEFINE_FPR (fp_reg[23],  f23,   NULL,   gcc_dwarf_f23_mips,  gcc_dwarf_f23_mips,  LLDB_INVALID_REGNUM,    gdb_f23_mips),
-    DEFINE_FPR (fp_reg[24],  f24,   NULL,   gcc_dwarf_f24_mips,  gcc_dwarf_f24_mips,  LLDB_INVALID_REGNUM,    gdb_f24_mips),
-    DEFINE_FPR (fp_reg[25],  f25,   NULL,   gcc_dwarf_f25_mips,  gcc_dwarf_f25_mips,  LLDB_INVALID_REGNUM,    gdb_f25_mips),
-    DEFINE_FPR (fp_reg[26],  f26,   NULL,   gcc_dwarf_f26_mips,  gcc_dwarf_f26_mips,  LLDB_INVALID_REGNUM,    gdb_f26_mips),
-    DEFINE_FPR (fp_reg[27],  f27,   NULL,   gcc_dwarf_f27_mips,  gcc_dwarf_f27_mips,  LLDB_INVALID_REGNUM,    gdb_f27_mips),
-    DEFINE_FPR (fp_reg[28],  f28,   NULL,   gcc_dwarf_f28_mips,  gcc_dwarf_f28_mips,  LLDB_INVALID_REGNUM,    gdb_f28_mips),
-    DEFINE_FPR (fp_reg[29],  f29,   NULL,   gcc_dwarf_f29_mips,  gcc_dwarf_f29_mips,  LLDB_INVALID_REGNUM,    gdb_f29_mips),
-    DEFINE_FPR (fp_reg[30],  f30,   NULL,   gcc_dwarf_f30_mips,  gcc_dwarf_f30_mips,  LLDB_INVALID_REGNUM,    gdb_f30_mips),
-    DEFINE_FPR (fp_reg[31],  f31,   NULL,   gcc_dwarf_f31_mips,  gcc_dwarf_f31_mips,  LLDB_INVALID_REGNUM,    gdb_f31_mips),
-    DEFINE_FPR_INFO (fcsr,        fcsr,  NULL,   gcc_dwarf_fcsr_mips, gcc_dwarf_fcsr_mips, LLDB_INVALID_REGNUM,    gdb_fcsr_mips),
-    DEFINE_FPR_INFO (fir,         fir,   NULL,   gcc_dwarf_fir_mips,  gcc_dwarf_fir_mips,  LLDB_INVALID_REGNUM,    gdb_fir_mips)
+    DEFINE_GPR (pc,       NULL,   gcc_dwarf_pc_mips,    gcc_dwarf_pc_mips,    LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM),
+    DEFINE_GPR (config5,    NULL,   gcc_dwarf_config5_mips,    gcc_dwarf_config5_mips,    LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
+    DEFINE_FPR (f0,    NULL,   gcc_dwarf_f0_mips,   gcc_dwarf_f0_mips,   LLDB_INVALID_REGNUM,    gdb_f0_mips),
+    DEFINE_FPR (f1,    NULL,   gcc_dwarf_f1_mips,   gcc_dwarf_f1_mips,   LLDB_INVALID_REGNUM,    gdb_f1_mips),
+    DEFINE_FPR (f2,    NULL,   gcc_dwarf_f2_mips,   gcc_dwarf_f2_mips,   LLDB_INVALID_REGNUM,    gdb_f2_mips),
+    DEFINE_FPR (f3,    NULL,   gcc_dwarf_f3_mips,   gcc_dwarf_f3_mips,   LLDB_INVALID_REGNUM,    gdb_f3_mips),
+    DEFINE_FPR (f4,    NULL,   gcc_dwarf_f4_mips,   gcc_dwarf_f4_mips,   LLDB_INVALID_REGNUM,    gdb_f4_mips),
+    DEFINE_FPR (f5,    NULL,   gcc_dwarf_f5_mips,   gcc_dwarf_f5_mips,   LLDB_INVALID_REGNUM,    gdb_f5_mips),
+    DEFINE_FPR (f6,    NULL,   gcc_dwarf_f6_mips,   gcc_dwarf_f6_mips,   LLDB_INVALID_REGNUM,    gdb_f6_mips),
+    DEFINE_FPR (f7,    NULL,   gcc_dwarf_f7_mips,   gcc_dwarf_f7_mips,   LLDB_INVALID_REGNUM,    gdb_f7_mips),
+    DEFINE_FPR (f8,    NULL,   gcc_dwarf_f8_mips,   gcc_dwarf_f8_mips,   LLDB_INVALID_REGNUM,    gdb_f8_mips),
+    DEFINE_FPR (f9,    NULL,   gcc_dwarf_f9_mips,   gcc_dwarf_f9_mips,   LLDB_INVALID_REGNUM,    gdb_f9_mips),
+    DEFINE_FPR (f10,   NULL,   gcc_dwarf_f10_mips,  gcc_dwarf_f10_mips,  LLDB_INVALID_REGNUM,    gdb_f10_mips),
+    DEFINE_FPR (f11,   NULL,   gcc_dwarf_f11_mips,  gcc_dwarf_f11_mips,  LLDB_INVALID_REGNUM,    gdb_f11_mips),
+    DEFINE_FPR (f12,   NULL,   gcc_dwarf_f12_mips,  gcc_dwarf_f12_mips,  LLDB_INVALID_REGNUM,    gdb_f12_mips),
+    DEFINE_FPR (f13,   NULL,   gcc_dwarf_f13_mips,  gcc_dwarf_f13_mips,  LLDB_INVALID_REGNUM,    gdb_f13_mips),
+    DEFINE_FPR (f14,   NULL,   gcc_dwarf_f14_mips,  gcc_dwarf_f14_mips,  LLDB_INVALID_REGNUM,    gdb_f14_mips),
+    DEFINE_FPR (f15,   NULL,   gcc_dwarf_f15_mips,  gcc_dwarf_f15_mips,  LLDB_INVALID_REGNUM,    gdb_f15_mips),
+    DEFINE_FPR (f16,   NULL,   gcc_dwarf_f16_mips,  gcc_dwarf_f16_mips,  LLDB_INVALID_REGNUM,    gdb_f16_mips),
+    DEFINE_FPR (f17,   NULL,   gcc_dwarf_f17_mips,  gcc_dwarf_f17_mips,  LLDB_INVALID_REGNUM,    gdb_f17_mips),
+    DEFINE_FPR (f18,   NULL,   gcc_dwarf_f18_mips,  gcc_dwarf_f18_mips,  LLDB_INVALID_REGNUM,    gdb_f18_mips),
+    DEFINE_FPR (f19,   NULL,   gcc_dwarf_f19_mips,  gcc_dwarf_f19_mips,  LLDB_INVALID_REGNUM,    gdb_f19_mips),
+    DEFINE_FPR (f20,   NULL,   gcc_dwarf_f20_mips,  gcc_dwarf_f20_mips,  LLDB_INVALID_REGNUM,    gdb_f20_mips),
+    DEFINE_FPR (f21,   NULL,   gcc_dwarf_f21_mips,  gcc_dwarf_f21_mips,  LLDB_INVALID_REGNUM,    gdb_f21_mips),
+    DEFINE_FPR (f22,   NULL,   gcc_dwarf_f22_mips,  gcc_dwarf_f22_mips,  LLDB_INVALID_REGNUM,    gdb_f22_mips),
+    DEFINE_FPR (f23,   NULL,   gcc_dwarf_f23_mips,  gcc_dwarf_f23_mips,  LLDB_INVALID_REGNUM,    gdb_f23_mips),
+    DEFINE_FPR (f24,   NULL,   gcc_dwarf_f24_mips,  gcc_dwarf_f24_mips,  LLDB_INVALID_REGNUM,    gdb_f24_mips),
+    DEFINE_FPR (f25,   NULL,   gcc_dwarf_f25_mips,  gcc_dwarf_f25_mips,  LLDB_INVALID_REGNUM,    gdb_f25_mips),
+    DEFINE_FPR (f26,   NULL,   gcc_dwarf_f26_mips,  gcc_dwarf_f26_mips,  LLDB_INVALID_REGNUM,    gdb_f26_mips),
+    DEFINE_FPR (f27,   NULL,   gcc_dwarf_f27_mips,  gcc_dwarf_f27_mips,  LLDB_INVALID_REGNUM,    gdb_f27_mips),
+    DEFINE_FPR (f28,   NULL,   gcc_dwarf_f28_mips,  gcc_dwarf_f28_mips,  LLDB_INVALID_REGNUM,    gdb_f28_mips),
+    DEFINE_FPR (f29,   NULL,   gcc_dwarf_f29_mips,  gcc_dwarf_f29_mips,  LLDB_INVALID_REGNUM,    gdb_f29_mips),
+    DEFINE_FPR (f30,   NULL,   gcc_dwarf_f30_mips,  gcc_dwarf_f30_mips,  LLDB_INVALID_REGNUM,    gdb_f30_mips),
+    DEFINE_FPR (f31,   NULL,   gcc_dwarf_f31_mips,  gcc_dwarf_f31_mips,  LLDB_INVALID_REGNUM,    gdb_f31_mips),
+    DEFINE_FPR (fcsr,  NULL,   gcc_dwarf_fcsr_mips, gcc_dwarf_fcsr_mips, LLDB_INVALID_REGNUM,    gdb_fcsr_mips),
+    DEFINE_FPR (fir,   NULL,   gcc_dwarf_fir_mips,  gcc_dwarf_fir_mips,  LLDB_INVALID_REGNUM,    gdb_fir_mips),
+    DEFINE_FPR (config5,   NULL,   gcc_dwarf_config5_mips,  gcc_dwarf_config5_mips,  LLDB_INVALID_REGNUM,    gdb_config5_mips),
+    DEFINE_MSA (w0,    NULL,   gcc_dwarf_w0_mips,   gcc_dwarf_w0_mips,   LLDB_INVALID_REGNUM,    gdb_w0_mips),
+    DEFINE_MSA (w1,    NULL,   gcc_dwarf_w1_mips,   gcc_dwarf_w1_mips,   LLDB_INVALID_REGNUM,    gdb_w1_mips),
+    DEFINE_MSA (w2,    NULL,   gcc_dwarf_w2_mips,   gcc_dwarf_w2_mips,   LLDB_INVALID_REGNUM,    gdb_w2_mips),
+    DEFINE_MSA (w3,    NULL,   gcc_dwarf_w3_mips,   gcc_dwarf_w3_mips,   LLDB_INVALID_REGNUM,    gdb_w3_mips),
+    DEFINE_MSA (w4,    NULL,   gcc_dwarf_w4_mips,   gcc_dwarf_w4_mips,   LLDB_INVALID_REGNUM,    gdb_w4_mips),
+    DEFINE_MSA (w5,    NULL,   gcc_dwarf_w5_mips,   gcc_dwarf_w5_mips,   LLDB_INVALID_REGNUM,    gdb_w5_mips),
+    DEFINE_MSA (w6,    NULL,   gcc_dwarf_w6_mips,   gcc_dwarf_w6_mips,   LLDB_INVALID_REGNUM,    gdb_w6_mips),
+    DEFINE_MSA (w7,    NULL,   gcc_dwarf_w7_mips,   gcc_dwarf_w7_mips,   LLDB_INVALID_REGNUM,    gdb_w7_mips),
+    DEFINE_MSA (w8,    NULL,   gcc_dwarf_w8_mips,   gcc_dwarf_w8_mips,   LLDB_INVALID_REGNUM,    gdb_w8_mips),
+    DEFINE_MSA (w9,    NULL,   gcc_dwarf_w9_mips,   gcc_dwarf_w9_mips,   LLDB_INVALID_REGNUM,    gdb_w9_mips),
+    DEFINE_MSA (w10,   NULL,   gcc_dwarf_w10_mips,  gcc_dwarf_w10_mips,  LLDB_INVALID_REGNUM,    gdb_w10_mips),
+    DEFINE_MSA (w11,   NULL,   gcc_dwarf_w11_mips,  gcc_dwarf_w11_mips,  LLDB_INVALID_REGNUM,    gdb_w11_mips),
+    DEFINE_MSA (w12,   NULL,   gcc_dwarf_w12_mips,  gcc_dwarf_w12_mips,  LLDB_INVALID_REGNUM,    gdb_w12_mips),
+    DEFINE_MSA (w13,   NULL,   gcc_dwarf_w13_mips,  gcc_dwarf_w13_mips,  LLDB_INVALID_REGNUM,    gdb_w13_mips),
+    DEFINE_MSA (w14,   NULL,   gcc_dwarf_w14_mips,  gcc_dwarf_w14_mips,  LLDB_INVALID_REGNUM,    gdb_w14_mips),
+    DEFINE_MSA (w15,   NULL,   gcc_dwarf_w15_mips,  gcc_dwarf_w15_mips,  LLDB_INVALID_REGNUM,    gdb_w15_mips),
+    DEFINE_MSA (w16,   NULL,   gcc_dwarf_w16_mips,  gcc_dwarf_w16_mips,  LLDB_INVALID_REGNUM,    gdb_w16_mips),
+    DEFINE_MSA (w17,   NULL,   gcc_dwarf_w17_mips,  gcc_dwarf_w17_mips,  LLDB_INVALID_REGNUM,    gdb_w17_mips),
+    DEFINE_MSA (w18,   NULL,   gcc_dwarf_w18_mips,  gcc_dwarf_w18_mips,  LLDB_INVALID_REGNUM,    gdb_w18_mips),
+    DEFINE_MSA (w19,   NULL,   gcc_dwarf_w19_mips,  gcc_dwarf_w19_mips,  LLDB_INVALID_REGNUM,    gdb_w19_mips),
+    DEFINE_MSA (w20,   NULL,   gcc_dwarf_w10_mips,  gcc_dwarf_w20_mips,  LLDB_INVALID_REGNUM,    gdb_w20_mips),
+    DEFINE_MSA (w21,   NULL,   gcc_dwarf_w21_mips,  gcc_dwarf_w21_mips,  LLDB_INVALID_REGNUM,    gdb_w21_mips),
+    DEFINE_MSA (w22,   NULL,   gcc_dwarf_w22_mips,  gcc_dwarf_w22_mips,  LLDB_INVALID_REGNUM,    gdb_w22_mips),
+    DEFINE_MSA (w23,   NULL,   gcc_dwarf_w23_mips,  gcc_dwarf_w23_mips,  LLDB_INVALID_REGNUM,    gdb_w23_mips),
+    DEFINE_MSA (w24,   NULL,   gcc_dwarf_w24_mips,  gcc_dwarf_w24_mips,  LLDB_INVALID_REGNUM,    gdb_w24_mips),
+    DEFINE_MSA (w25,   NULL,   gcc_dwarf_w25_mips,  gcc_dwarf_w25_mips,  LLDB_INVALID_REGNUM,    gdb_w25_mips),
+    DEFINE_MSA (w26,   NULL,   gcc_dwarf_w26_mips,  gcc_dwarf_w26_mips,  LLDB_INVALID_REGNUM,    gdb_w26_mips),
+    DEFINE_MSA (w27,   NULL,   gcc_dwarf_w27_mips,  gcc_dwarf_w27_mips,  LLDB_INVALID_REGNUM,    gdb_w27_mips),
+    DEFINE_MSA (w28,   NULL,   gcc_dwarf_w28_mips,  gcc_dwarf_w28_mips,  LLDB_INVALID_REGNUM,    gdb_w28_mips),
+    DEFINE_MSA (w29,   NULL,   gcc_dwarf_w29_mips,  gcc_dwarf_w29_mips,  LLDB_INVALID_REGNUM,    gdb_w29_mips),
+    DEFINE_MSA (w30,   NULL,   gcc_dwarf_w30_mips,  gcc_dwarf_w30_mips,  LLDB_INVALID_REGNUM,    gdb_w30_mips),
+    DEFINE_MSA (w31,   NULL,   gcc_dwarf_w31_mips,  gcc_dwarf_w31_mips,  LLDB_INVALID_REGNUM,    gdb_w31_mips),
+    DEFINE_MSA_INFO (mcsr,  NULL,   gcc_dwarf_mcsr_mips, gcc_dwarf_mcsr_mips, LLDB_INVALID_REGNUM,    gdb_mcsr_mips),
+    DEFINE_MSA_INFO (mir,   NULL,   gcc_dwarf_mir_mips,  gcc_dwarf_mir_mips,  LLDB_INVALID_REGNUM,    gdb_mir_mips),
+    DEFINE_MSA_INFO (fcsr,  NULL,   gcc_dwarf_fcsr_mips, gcc_dwarf_fcsr_mips, LLDB_INVALID_REGNUM,    gdb_fcsr_mips),
+    DEFINE_MSA_INFO (fir,   NULL,   gcc_dwarf_fir_mips,  gcc_dwarf_fir_mips,  LLDB_INVALID_REGNUM,    gdb_fir_mips),
+    DEFINE_MSA_INFO (config5, NULL,   gcc_dwarf_config5_mips,  gcc_dwarf_config5_mips,  LLDB_INVALID_REGNUM,    gdb_config5_mips)
 };
 static_assert((sizeof(g_register_infos_mips) / sizeof(g_register_infos_mips[0])) == k_num_registers_mips,
     "g_register_infos_mips has wrong number of register infos");
 
 #undef GPR_OFFSET
 #undef FPR_OFFSET
+#undef MSA_OFFSET
 #undef DEFINE_GPR
 #undef DEFINE_FPR
+#undef DEFINE_MSA
+#undef DEFINE_MSA_INFO
 
 #endif // DECLARE_REGISTER_INFOS_MIPS_STRUCT

source/Plugins/Process/Utility/RegisterInfos_mips64.h

 //===-- RegisterInfos_mips64.h ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 #include "llvm/Support/Compiler.h"
 
 #include <stddef.h>
 
 #ifdef DECLARE_REGISTER_INFOS_MIPS64_STRUCT
 
 // Computes the offset of the given GPR in the user data area.
+#ifdef LINUX_MIPS64
     #define GPR_OFFSET(regname) \
-    (LLVM_EXTENSION offsetof(GPR, regname))
+        (LLVM_EXTENSION offsetof(UserArea, gpr) + \
+         LLVM_EXTENSION offsetof(GPR_linux_mips, regname))
+#else
+    #define GPR_OFFSET(regname) \
+        (LLVM_EXTENSION offsetof(GPR_freebsd_mips, regname))
+#endif
 
 // Computes the offset of the given FPR in the extended data area.
 #define FPR_OFFSET(regname) \
-     LLVM_EXTENSION offsetof(FPR_mips, regname) \
+     (LLVM_EXTENSION offsetof(UserArea, fpr) + \
+      LLVM_EXTENSION offsetof(FPR_linux_mips, regname))
+
+// Computes the offset of the given MSA in the extended data area.
+#define MSA_OFFSET(regname) \
+     (LLVM_EXTENSION offsetof(UserArea, msa) + \
+      LLVM_EXTENSION offsetof(MSA_linux_mips, regname))
 
 // RegisterKind: GCC, DWARF, Generic, GDB, LLDB
 
 // Note that the size and offset will be updated by platform-specific classes.
+#ifdef LINUX_MIPS64
+    #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4) \
+         { #reg, alt, sizeof(((GPR_linux_mips*)0)->reg), GPR_OFFSET(reg), eEncodingUint, \
+          eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg##_mips64 }, NULL, NULL }
+#else
     #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4)    \
-    { #reg, alt, sizeof(((GPR*)0)->reg), GPR_OFFSET(reg), eEncodingUint, \
+         { #reg, alt, sizeof(((GPR_freebsd_mips*)0)->reg), GPR_OFFSET(reg), eEncodingUint, \
+          eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg##_mips64 }, NULL, NULL }
+#endif
+
+#define DEFINE_GPR_INFO(reg, alt, kind1, kind2, kind3, kind4)    \
+    { #reg, alt, sizeof(((GPR_linux_mips*)0)->reg) / 2, GPR_OFFSET(reg), eEncodingUint, \
       eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg##_mips64 }, NULL, NULL }
 
-#define DEFINE_FPR(member, reg, alt, kind1, kind2, kind3, kind4)    \
-    { #reg, alt, sizeof(((FPR_mips*)0)->member), FPR_OFFSET(member), eEncodingUint,   \
+#define DEFINE_FPR(reg, alt, kind1, kind2, kind3, kind4)    \
+    { #reg, alt, sizeof(((FPR_linux_mips*)0)->reg), FPR_OFFSET(reg), eEncodingUint,   \
       eFormatHex, { kind1, kind2, kind3, kind4, fpr_##reg##_mips64 }, NULL, NULL }
 
+#define DEFINE_MSA(reg, alt, kind1, kind2, kind3, kind4)    \
+    { #reg, alt, sizeof(((MSA_linux_mips*)0)->reg), MSA_OFFSET(reg), eEncodingVector,   \
+      eFormatVectorOfUInt8, { kind1, kind2, kind3, kind4, msa_##reg##_mips64 }, NULL, NULL }
+
+#define DEFINE_MSA_INFO(reg, alt, kind1, kind2, kind3, kind4)    \
+    { #reg, alt, sizeof(((MSA_linux_mips*)0)->reg), MSA_OFFSET(reg), eEncodingUint,   \
+      eFormatHex, { kind1, kind2, kind3, kind4, msa_##reg##_mips64 }, NULL, NULL }
+
 static RegisterInfo
 g_register_infos_mips64[] =
 {
     // General purpose registers.                 GCC,                  DWARF,              Generic,                GDB
+#ifndef LINUX_MIPS64
     DEFINE_GPR(zero,     "r0",  gcc_dwarf_zero_mips64,  gcc_dwarf_zero_mips64,  LLDB_INVALID_REGNUM,    gdb_zero_mips64),
     DEFINE_GPR(r1,       NULL,  gcc_dwarf_r1_mips64,    gcc_dwarf_r1_mips64,    LLDB_INVALID_REGNUM,    gdb_r1_mips64),
     DEFINE_GPR(r2,       NULL,  gcc_dwarf_r2_mips64,    gcc_dwarf_r2_mips64,    LLDB_INVALID_REGNUM,    gdb_r2_mips64),
     DEFINE_GPR(r3,       NULL,  gcc_dwarf_r3_mips64,    gcc_dwarf_r3_mips64,    LLDB_INVALID_REGNUM,    gdb_r3_mips64),
     DEFINE_GPR(r4,       NULL,  gcc_dwarf_r4_mips64,    gcc_dwarf_r4_mips64,    LLDB_REGNUM_GENERIC_ARG1,    gdb_r4_mips64),
     DEFINE_GPR(r5,       NULL,  gcc_dwarf_r5_mips64,    gcc_dwarf_r5_mips64,    LLDB_REGNUM_GENERIC_ARG2,    gdb_r5_mips64),
     DEFINE_GPR(r6,       NULL,  gcc_dwarf_r6_mips64,    gcc_dwarf_r6_mips64,    LLDB_REGNUM_GENERIC_ARG3,    gdb_r6_mips64),
     DEFINE_GPR(r7,       NULL,  gcc_dwarf_r7_mips64,    gcc_dwarf_r7_mips64,    LLDB_REGNUM_GENERIC_ARG4,    gdb_r7_mips64),
#ifndef LINUX_MIPS64
     DEFINE_GPR(r24,      NULL,  gcc_dwarf_r24_mips64,   gcc_dwarf_r24_mips64,   LLDB_INVALID_REGNUM,    gdb_r24_mips64),
     DEFINE_GPR(r25,      NULL,  gcc_dwarf_r25_mips64,   gcc_dwarf_r25_mips64,   LLDB_INVALID_REGNUM,    gdb_r25_mips64),
     DEFINE_GPR(r26,      NULL,  gcc_dwarf_r26_mips64,   gcc_dwarf_r26_mips64,   LLDB_INVALID_REGNUM,    gdb_r26_mips64),
     DEFINE_GPR(r27,      NULL,  gcc_dwarf_r27_mips64,   gcc_dwarf_r27_mips64,   LLDB_INVALID_REGNUM,    gdb_r27_mips64),
     DEFINE_GPR(gp,       "r28", gcc_dwarf_gp_mips64,    gcc_dwarf_gp_mips64,    LLDB_INVALID_REGNUM,    gdb_gp_mips64),
     DEFINE_GPR(sp,       "r29", gcc_dwarf_sp_mips64,    gcc_dwarf_sp_mips64,    LLDB_REGNUM_GENERIC_SP, gdb_sp_mips64),
     DEFINE_GPR(r30,      NULL,  gcc_dwarf_r30_mips64,   gcc_dwarf_r30_mips64,   LLDB_REGNUM_GENERIC_FP,    gdb_r30_mips64),
     DEFINE_GPR(ra,       "r31", gcc_dwarf_ra_mips64,    gcc_dwarf_ra_mips64,    LLDB_REGNUM_GENERIC_RA,    gdb_ra_mips64),
+    DEFINE_GPR(sr,       NULL,  gcc_dwarf_sr_mips64,    gcc_dwarf_sr_mips64,    LLDB_REGNUM_GENERIC_FLAGS,    LLDB_INVALID_REGNUM),
     DEFINE_GPR(mullo,    NULL,  gcc_dwarf_lo_mips64,    gcc_dwarf_lo_mips64,    LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
     DEFINE_GPR(mulhi,    NULL,  gcc_dwarf_hi_mips64,    gcc_dwarf_hi_mips64,    LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
-    DEFINE_GPR(pc,       "pc",  gcc_dwarf_pc_mips64,    gcc_dwarf_pc_mips64,    LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM),
     DEFINE_GPR(badvaddr, NULL,  gcc_dwarf_bad_mips64,   gcc_dwarf_bad_mips64,   LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
-    DEFINE_GPR(sr,       NULL,  gcc_dwarf_sr_mips64,    gcc_dwarf_sr_mips64,    LLDB_REGNUM_GENERIC_FLAGS,    LLDB_INVALID_REGNUM),
     DEFINE_GPR(cause,    NULL,  gcc_dwarf_cause_mips64, gcc_dwarf_cause_mips64, LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
+    DEFINE_GPR(pc,       "pc",  gcc_dwarf_pc_mips64,    gcc_dwarf_pc_mips64,    LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM),
     DEFINE_GPR(ic,       NULL,  gcc_dwarf_ic_mips64,    gcc_dwarf_ic_mips64,    LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
     DEFINE_GPR(dummy,    NULL,  gcc_dwarf_dummy_mips64, gcc_dwarf_dummy_mips64, LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
+#else
 
-    DEFINE_FPR (fp_reg[0],   f0,    NULL,   gcc_dwarf_f0_mips64,   gcc_dwarf_f0_mips64,   LLDB_INVALID_REGNUM,    gdb_f0_mips64),
-    DEFINE_FPR (fp_reg[1],   f1,    NULL,   gcc_dwarf_f1_mips64,   gcc_dwarf_f1_mips64,   LLDB_INVALID_REGNUM,    gdb_f1_mips64),
-    DEFINE_FPR (fp_reg[2],   f2,    NULL,   gcc_dwarf_f2_mips64,   gcc_dwarf_f2_mips64,   LLDB_INVALID_REGNUM,    gdb_f2_mips64),
-    DEFINE_FPR (fp_reg[3],   f3,    NULL,   gcc_dwarf_f3_mips64,   gcc_dwarf_f3_mips64,   LLDB_INVALID_REGNUM,    gdb_f3_mips64),
-    DEFINE_FPR (fp_reg[4],   f4,    NULL,   gcc_dwarf_f4_mips64,   gcc_dwarf_f4_mips64,   LLDB_INVALID_REGNUM,    gdb_f4_mips64),
-    DEFINE_FPR (fp_reg[5],   f5,    NULL,   gcc_dwarf_f5_mips64,   gcc_dwarf_f5_mips64,   LLDB_INVALID_REGNUM,    gdb_f5_mips64),
-    DEFINE_FPR (fp_reg[6],   f6,    NULL,   gcc_dwarf_f6_mips64,   gcc_dwarf_f6_mips64,   LLDB_INVALID_REGNUM,    gdb_f6_mips64),
-    DEFINE_FPR (fp_reg[7],   f7,    NULL,   gcc_dwarf_f7_mips64,   gcc_dwarf_f7_mips64,   LLDB_INVALID_REGNUM,    gdb_f7_mips64),
-    DEFINE_FPR (fp_reg[8],   f8,    NULL,   gcc_dwarf_f8_mips64,   gcc_dwarf_f8_mips64,   LLDB_INVALID_REGNUM,    gdb_f8_mips64),
-    DEFINE_FPR (fp_reg[9],   f9,    NULL,   gcc_dwarf_f9_mips64,   gcc_dwarf_f9_mips64,   LLDB_INVALID_REGNUM,    gdb_f9_mips64),
-    DEFINE_FPR (fp_reg[10],  f10,   NULL,   gcc_dwarf_f10_mips64,  gcc_dwarf_f10_mips64,  LLDB_INVALID_REGNUM,    gdb_f10_mips64),
-    DEFINE_FPR (fp_reg[11],  f11,   NULL,   gcc_dwarf_f11_mips64,  gcc_dwarf_f11_mips64,  LLDB_INVALID_REGNUM,    gdb_f11_mips64),
-    DEFINE_FPR (fp_reg[12],  f12,   NULL,   gcc_dwarf_f12_mips64,  gcc_dwarf_f12_mips64,  LLDB_INVALID_REGNUM,    gdb_f12_mips64),
-    DEFINE_FPR (fp_reg[13],  f13,   NULL,   gcc_dwarf_f13_mips64,  gcc_dwarf_f13_mips64,  LLDB_INVALID_REGNUM,    gdb_f13_mips64),
-    DEFINE_FPR (fp_reg[14],  f14,   NULL,   gcc_dwarf_f14_mips64,  gcc_dwarf_f14_mips64,  LLDB_INVALID_REGNUM,    gdb_f14_mips64),
-    DEFINE_FPR (fp_reg[15],  f15,   NULL,   gcc_dwarf_f15_mips64,  gcc_dwarf_f15_mips64,  LLDB_INVALID_REGNUM,    gdb_f15_mips64),
-    DEFINE_FPR (fp_reg[16],  f16,   NULL,   gcc_dwarf_f16_mips64,  gcc_dwarf_f16_mips64,  LLDB_INVALID_REGNUM,    gdb_f16_mips64),
-    DEFINE_FPR (fp_reg[17],  f17,   NULL,   gcc_dwarf_f17_mips64,  gcc_dwarf_f17_mips64,  LLDB_INVALID_REGNUM,    gdb_f17_mips64),
-    DEFINE_FPR (fp_reg[18],  f18,   NULL,   gcc_dwarf_f18_mips64,  gcc_dwarf_f18_mips64,  LLDB_INVALID_REGNUM,    gdb_f18_mips64),
-    DEFINE_FPR (fp_reg[19],  f19,   NULL,   gcc_dwarf_f19_mips64,  gcc_dwarf_f19_mips64,  LLDB_INVALID_REGNUM,    gdb_f19_mips64),
-    DEFINE_FPR (fp_reg[20],  f20,   NULL,   gcc_dwarf_f20_mips64,  gcc_dwarf_f20_mips64,  LLDB_INVALID_REGNUM,    gdb_f20_mips64),
-    DEFINE_FPR (fp_reg[21],  f21,   NULL,   gcc_dwarf_f21_mips64,  gcc_dwarf_f21_mips64,  LLDB_INVALID_REGNUM,    gdb_f21_mips64),
-    DEFINE_FPR (fp_reg[22],  f22,   NULL,   gcc_dwarf_f22_mips64,  gcc_dwarf_f22_mips64,  LLDB_INVALID_REGNUM,    gdb_f22_mips64),
-    DEFINE_FPR (fp_reg[23],  f23,   NULL,   gcc_dwarf_f23_mips64,  gcc_dwarf_f23_mips64,  LLDB_INVALID_REGNUM,    gdb_f23_mips64),
-    DEFINE_FPR (fp_reg[24],  f24,   NULL,   gcc_dwarf_f24_mips64,  gcc_dwarf_f24_mips64,  LLDB_INVALID_REGNUM,    gdb_f24_mips64),
-    DEFINE_FPR (fp_reg[25],  f25,   NULL,   gcc_dwarf_f25_mips64,  gcc_dwarf_f25_mips64,  LLDB_INVALID_REGNUM,    gdb_f25_mips64),
-    DEFINE_FPR (fp_reg[26],  f26,   NULL,   gcc_dwarf_f26_mips64,  gcc_dwarf_f26_mips64,  LLDB_INVALID_REGNUM,    gdb_f26_mips64),
-    DEFINE_FPR (fp_reg[27],  f27,   NULL,   gcc_dwarf_f27_mips64,  gcc_dwarf_f27_mips64,  LLDB_INVALID_REGNUM,    gdb_f27_mips64),
-    DEFINE_FPR (fp_reg[28],  f28,   NULL,   gcc_dwarf_f28_mips64,  gcc_dwarf_f28_mips64,  LLDB_INVALID_REGNUM,    gdb_f28_mips64),
-    DEFINE_FPR (fp_reg[29],  f29,   NULL,   gcc_dwarf_f29_mips64,  gcc_dwarf_f29_mips64,  LLDB_INVALID_REGNUM,    gdb_f29_mips64),
-    DEFINE_FPR (fp_reg[30],  f30,   NULL,   gcc_dwarf_f30_mips64,  gcc_dwarf_f30_mips64,  LLDB_INVALID_REGNUM,    gdb_f30_mips64),
-    DEFINE_FPR (fp_reg[31],  f31,   NULL,   gcc_dwarf_f31_mips64,  gcc_dwarf_f31_mips64,  LLDB_INVALID_REGNUM,    gdb_f31_mips64),
-    DEFINE_FPR (fcsr,        fcsr,  NULL,   gcc_dwarf_fcsr_mips64, gcc_dwarf_fcsr_mips64, LLDB_INVALID_REGNUM,    gdb_fcsr_mips64),
-    DEFINE_FPR (fir,         fir,   NULL,   gcc_dwarf_fir_mips64,  gcc_dwarf_fir_mips64,  LLDB_INVALID_REGNUM,    gdb_fir_mips64)
+    DEFINE_GPR(zero,     "r0",  gcc_dwarf_zero_mips64,  gcc_dwarf_zero_mips64,  LLDB_INVALID_REGNUM,    gdb_zero_mips64),
+    DEFINE_GPR(r1,       NULL,  gcc_dwarf_r1_mips64,    gcc_dwarf_r1_mips64,    LLDB_INVALID_REGNUM,    gdb_r1_mips64),
+    DEFINE_GPR(r2,       NULL,  gcc_dwarf_r2_mips64,    gcc_dwarf_r2_mips64,    LLDB_INVALID_REGNUM,    gdb_r2_mips64),
+    DEFINE_GPR(r3,       NULL,  gcc_dwarf_r3_mips64,    gcc_dwarf_r3_mips64,    LLDB_INVALID_REGNUM,    gdb_r3_mips64),
+    DEFINE_GPR(r4,       NULL,  gcc_dwarf_r4_mips64,    gcc_dwarf_r4_mips64,    LLDB_REGNUM_GENERIC_ARG1,    gdb_r4_mips64),
+    DEFINE_GPR(r5,       NULL,  gcc_dwarf_r5_mips64,    gcc_dwarf_r5_mips64,    LLDB_REGNUM_GENERIC_ARG2,    gdb_r5_mips64),
+    DEFINE_GPR(r6,       NULL,  gcc_dwarf_r6_mips64,    gcc_dwarf_r6_mips64,    LLDB_REGNUM_GENERIC_ARG3,    gdb_r6_mips64),
+    DEFINE_GPR(r7,       NULL,  gcc_dwarf_r7_mips64,    gcc_dwarf_r7_mips64,    LLDB_REGNUM_GENERIC_ARG4,    gdb_r7_mips64),
+    DEFINE_GPR(r8,       NULL,  gcc_dwarf_r8_mips64,    gcc_dwarf_r8_mips64,    LLDB_REGNUM_GENERIC_ARG5,    gdb_r8_mips64),
+    DEFINE_GPR(r9,       NULL,  gcc_dwarf_r9_mips64,    gcc_dwarf_r9_mips64,    LLDB_REGNUM_GENERIC_ARG6,    gdb_r9_mips64),
+    DEFINE_GPR(r10,      NULL,  gcc_dwarf_r10_mips64,   gcc_dwarf_r10_mips64,   LLDB_REGNUM_GENERIC_ARG7,    gdb_r10_mips64),
+    DEFINE_GPR(r11,      NULL,  gcc_dwarf_r11_mips64,   gcc_dwarf_r11_mips64,   LLDB_REGNUM_GENERIC_ARG8,    gdb_r11_mips64),
+    DEFINE_GPR(r12,      NULL,  gcc_dwarf_r12_mips64,   gcc_dwarf_r12_mips64,   LLDB_INVALID_REGNUM,    gdb_r12_mips64),
+    DEFINE_GPR(r13,      NULL,  gcc_dwarf_r13_mips64,   gcc_dwarf_r13_mips64,   LLDB_INVALID_REGNUM,    gdb_r13_mips64),
+    DEFINE_GPR(r14,      NULL,  gcc_dwarf_r14_mips64,   gcc_dwarf_r14_mips64,   LLDB_INVALID_REGNUM,    gdb_r14_mips64),
+    DEFINE_GPR(r15,      NULL,  gcc_dwarf_r15_mips64,   gcc_dwarf_r15_mips64,   LLDB_INVALID_REGNUM,    gdb_r15_mips64),
+    DEFINE_GPR(r16,      NULL,  gcc_dwarf_r16_mips64,   gcc_dwarf_r16_mips64,   LLDB_INVALID_REGNUM,    gdb_r16_mips64),
+    DEFINE_GPR(r17,      NULL,  gcc_dwarf_r17_mips64,   gcc_dwarf_r17_mips64,   LLDB_INVALID_REGNUM,    gdb_r17_mips64),
+    DEFINE_GPR(r18,      NULL,  gcc_dwarf_r18_mips64,   gcc_dwarf_r18_mips64,   LLDB_INVALID_REGNUM,    gdb_r18_mips64),
+    DEFINE_GPR(r19,      NULL,  gcc_dwarf_r19_mips64,   gcc_dwarf_r19_mips64,   LLDB_INVALID_REGNUM,    gdb_r19_mips64),
+    DEFINE_GPR(r20,      NULL,  gcc_dwarf_r20_mips64,   gcc_dwarf_r20_mips64,   LLDB_INVALID_REGNUM,    gdb_r20_mips64),
+    DEFINE_GPR(r21,      NULL,  gcc_dwarf_r21_mips64,   gcc_dwarf_r21_mips64,   LLDB_INVALID_REGNUM,    gdb_r21_mips64),
+    DEFINE_GPR(r22,      NULL,  gcc_dwarf_r22_mips64,   gcc_dwarf_r22_mips64,   LLDB_INVALID_REGNUM,    gdb_r22_mips64),
+    DEFINE_GPR(r23,      NULL,  gcc_dwarf_r23_mips64,   gcc_dwarf_r23_mips64,   LLDB_INVALID_REGNUM,    gdb_r23_mips64),
+    DEFINE_GPR(r24,      NULL,  gcc_dwarf_r24_mips64,   gcc_dwarf_r24_mips64,   LLDB_INVALID_REGNUM,    gdb_r24_mips64),
+    DEFINE_GPR(r25,      NULL,  gcc_dwarf_r25_mips64,   gcc_dwarf_r25_mips64,   LLDB_INVALID_REGNUM,    gdb_r25_mips64),
+    DEFINE_GPR(r26,      NULL,  gcc_dwarf_r26_mips64,   gcc_dwarf_r26_mips64,   LLDB_INVALID_REGNUM,    gdb_r26_mips64),
+    DEFINE_GPR(r27,      NULL,  gcc_dwarf_r27_mips64,   gcc_dwarf_r27_mips64,   LLDB_INVALID_REGNUM,    gdb_r27_mips64),
+    DEFINE_GPR(gp,       "r28", gcc_dwarf_gp_mips64,    gcc_dwarf_gp_mips64,    LLDB_INVALID_REGNUM,    gdb_gp_mips64),
+    DEFINE_GPR(sp,       "r29", gcc_dwarf_sp_mips64,    gcc_dwarf_sp_mips64,    LLDB_REGNUM_GENERIC_SP, gdb_sp_mips64),
+    DEFINE_GPR(r30,      NULL,  gcc_dwarf_r30_mips64,   gcc_dwarf_r30_mips64,   LLDB_REGNUM_GENERIC_FP,    gdb_r30_mips64),
+    DEFINE_GPR(ra,       "r31", gcc_dwarf_ra_mips64,    gcc_dwarf_ra_mips64,    LLDB_REGNUM_GENERIC_RA,    gdb_ra_mips64),
+    DEFINE_GPR_INFO(sr,       NULL,  gcc_dwarf_sr_mips64,    gcc_dwarf_sr_mips64,    LLDB_REGNUM_GENERIC_FLAGS,    LLDB_INVALID_REGNUM),
+    DEFINE_GPR(mullo,    NULL,  gcc_dwarf_lo_mips64,    gcc_dwarf_lo_mips64,    LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
+    DEFINE_GPR(mulhi,    NULL,  gcc_dwarf_hi_mips64,    gcc_dwarf_hi_mips64,    LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
+    DEFINE_GPR(badvaddr, NULL,  gcc_dwarf_bad_mips64,   gcc_dwarf_bad_mips64,   LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
+    DEFINE_GPR_INFO(cause,    NULL,  gcc_dwarf_cause_mips64, gcc_dwarf_cause_mips64, LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
+    DEFINE_GPR(pc,       "pc",  gcc_dwarf_pc_mips64,    gcc_dwarf_pc_mips64,    LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM),
+    DEFINE_GPR_INFO(config5,    NULL,  gcc_dwarf_config5_mips64, gcc_dwarf_config5_mips64, LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
+    DEFINE_FPR (f0,    NULL,   gcc_dwarf_f0_mips64,   gcc_dwarf_f0_mips64,   LLDB_INVALID_REGNUM,    gdb_f0_mips64),
+    DEFINE_FPR (f1,    NULL,   gcc_dwarf_f1_mips64,   gcc_dwarf_f1_mips64,   LLDB_INVALID_REGNUM,    gdb_f1_mips64),
+    DEFINE_FPR (f2,    NULL,   gcc_dwarf_f2_mips64,   gcc_dwarf_f2_mips64,   LLDB_INVALID_REGNUM,    gdb_f2_mips64),
+    DEFINE_FPR (f3,    NULL,   gcc_dwarf_f3_mips64,   gcc_dwarf_f3_mips64,   LLDB_INVALID_REGNUM,    gdb_f3_mips64),
+    DEFINE_FPR (f4,    NULL,   gcc_dwarf_f4_mips64,   gcc_dwarf_f4_mips64,   LLDB_INVALID_REGNUM,    gdb_f4_mips64),
+    DEFINE_FPR (f5,    NULL,   gcc_dwarf_f5_mips64,   gcc_dwarf_f5_mips64,   LLDB_INVALID_REGNUM,    gdb_f5_mips64),
+    DEFINE_FPR (f6,    NULL,   gcc_dwarf_f6_mips64,   gcc_dwarf_f6_mips64,   LLDB_INVALID_REGNUM,    gdb_f6_mips64),
+    DEFINE_FPR (f7,    NULL,   gcc_dwarf_f7_mips64,   gcc_dwarf_f7_mips64,   LLDB_INVALID_REGNUM,    gdb_f7_mips64),
+    DEFINE_FPR (f8,    NULL,   gcc_dwarf_f8_mips64,   gcc_dwarf_f8_mips64,   LLDB_INVALID_REGNUM,    gdb_f8_mips64),
+    DEFINE_FPR (f9,    NULL,   gcc_dwarf_f9_mips64,   gcc_dwarf_f9_mips64,   LLDB_INVALID_REGNUM,    gdb_f9_mips64),
+    DEFINE_FPR (f10,   NULL,   gcc_dwarf_f10_mips64,  gcc_dwarf_f10_mips64,  LLDB_INVALID_REGNUM,    gdb_f10_mips64),
+    DEFINE_FPR (f11,   NULL,   gcc_dwarf_f11_mips64,  gcc_dwarf_f11_mips64,  LLDB_INVALID_REGNUM,    gdb_f11_mips64),
+    DEFINE_FPR (f12,   NULL,   gcc_dwarf_f12_mips64,  gcc_dwarf_f12_mips64,  LLDB_INVALID_REGNUM,    gdb_f12_mips64),
+    DEFINE_FPR (f13,   NULL,   gcc_dwarf_f13_mips64,  gcc_dwarf_f13_mips64,  LLDB_INVALID_REGNUM,    gdb_f13_mips64),
+    DEFINE_FPR (f14,   NULL,   gcc_dwarf_f14_mips64,  gcc_dwarf_f14_mips64,  LLDB_INVALID_REGNUM,    gdb_f14_mips64),
+    DEFINE_FPR (f15,   NULL,   gcc_dwarf_f15_mips64,  gcc_dwarf_f15_mips64,  LLDB_INVALID_REGNUM,    gdb_f15_mips64),
+    DEFINE_FPR (f16,   NULL,   gcc_dwarf_f16_mips64,  gcc_dwarf_f16_mips64,  LLDB_INVALID_REGNUM,    gdb_f16_mips64),
+    DEFINE_FPR (f17,   NULL,   gcc_dwarf_f17_mips64,  gcc_dwarf_f17_mips64,  LLDB_INVALID_REGNUM,    gdb_f17_mips64),
+    DEFINE_FPR (f18,   NULL,   gcc_dwarf_f18_mips64,  gcc_dwarf_f18_mips64,  LLDB_INVALID_REGNUM,    gdb_f18_mips64),
+    DEFINE_FPR (f19,   NULL,   gcc_dwarf_f19_mips64,  gcc_dwarf_f19_mips64,  LLDB_INVALID_REGNUM,    gdb_f19_mips64),
+    DEFINE_FPR (f20,   NULL,   gcc_dwarf_f20_mips64,  gcc_dwarf_f20_mips64,  LLDB_INVALID_REGNUM,    gdb_f20_mips64),
+    DEFINE_FPR (f21,   NULL,   gcc_dwarf_f21_mips64,  gcc_dwarf_f21_mips64,  LLDB_INVALID_REGNUM,    gdb_f21_mips64),
+    DEFINE_FPR (f22,   NULL,   gcc_dwarf_f22_mips64,  gcc_dwarf_f22_mips64,  LLDB_INVALID_REGNUM,    gdb_f22_mips64),
+    DEFINE_FPR (f23,   NULL,   gcc_dwarf_f23_mips64,  gcc_dwarf_f23_mips64,  LLDB_INVALID_REGNUM,    gdb_f23_mips64),
+    DEFINE_FPR (f24,   NULL,   gcc_dwarf_f24_mips64,  gcc_dwarf_f24_mips64,  LLDB_INVALID_REGNUM,    gdb_f24_mips64),
+    DEFINE_FPR (f25,   NULL,   gcc_dwarf_f25_mips64,  gcc_dwarf_f25_mips64,  LLDB_INVALID_REGNUM,    gdb_f25_mips64),
+    DEFINE_FPR (f26,   NULL,   gcc_dwarf_f26_mips64,  gcc_dwarf_f26_mips64,  LLDB_INVALID_REGNUM,    gdb_f26_mips64),
+    DEFINE_FPR (f27,   NULL,   gcc_dwarf_f27_mips64,  gcc_dwarf_f27_mips64,  LLDB_INVALID_REGNUM,    gdb_f27_mips64),
+    DEFINE_FPR (f28,   NULL,   gcc_dwarf_f28_mips64,  gcc_dwarf_f28_mips64,  LLDB_INVALID_REGNUM,    gdb_f28_mips64),
+    DEFINE_FPR (f29,   NULL,   gcc_dwarf_f29_mips64,  gcc_dwarf_f29_mips64,  LLDB_INVALID_REGNUM,    gdb_f29_mips64),
+    DEFINE_FPR (f30,   NULL,   gcc_dwarf_f30_mips64,  gcc_dwarf_f30_mips64,  LLDB_INVALID_REGNUM,    gdb_f30_mips64),
+    DEFINE_FPR (f31,   NULL,   gcc_dwarf_f31_mips64,  gcc_dwarf_f31_mips64,  LLDB_INVALID_REGNUM,    gdb_f31_mips64),
+    DEFINE_FPR (fcsr,  NULL,   gcc_dwarf_fcsr_mips64, gcc_dwarf_fcsr_mips64, LLDB_INVALID_REGNUM,    gdb_fcsr_mips64),
+    DEFINE_FPR (fir,   NULL,   gcc_dwarf_fir_mips64,  gcc_dwarf_fir_mips64,  LLDB_INVALID_REGNUM,    gdb_fir_mips64),
+    DEFINE_FPR (config5,   NULL,   gcc_dwarf_config5_mips64,  gcc_dwarf_config5_mips64,  LLDB_INVALID_REGNUM,    gdb_config5_mips64),
+    DEFINE_MSA (w0,    NULL,   gcc_dwarf_w0_mips64,   gcc_dwarf_w0_mips64,   LLDB_INVALID_REGNUM,    gdb_w0_mips64),
+    DEFINE_MSA (w1,    NULL,   gcc_dwarf_w1_mips64,   gcc_dwarf_w1_mips64,   LLDB_INVALID_REGNUM,    gdb_w1_mips64),
+    DEFINE_MSA (w2,    NULL,   gcc_dwarf_w2_mips64,   gcc_dwarf_w2_mips64,   LLDB_INVALID_REGNUM,    gdb_w2_mips64),
+    DEFINE_MSA (w3,    NULL,   gcc_dwarf_w3_mips64,   gcc_dwarf_w3_mips64,   LLDB_INVALID_REGNUM,    gdb_w3_mips64),
+    DEFINE_MSA (w4,    NULL,   gcc_dwarf_w4_mips64,   gcc_dwarf_w4_mips64,   LLDB_INVALID_REGNUM,    gdb_w4_mips64),
+    DEFINE_MSA (w5,    NULL,   gcc_dwarf_w5_mips64,   gcc_dwarf_w5_mips64,   LLDB_INVALID_REGNUM,    gdb_w5_mips64),
+    DEFINE_MSA (w6,    NULL,   gcc_dwarf_w6_mips64,   gcc_dwarf_w6_mips64,   LLDB_INVALID_REGNUM,    gdb_w6_mips64),
+    DEFINE_MSA (w7,    NULL,   gcc_dwarf_w7_mips64,   gcc_dwarf_w7_mips64,   LLDB_INVALID_REGNUM,    gdb_w7_mips64),
+    DEFINE_MSA (w8,    NULL,   gcc_dwarf_w8_mips64,   gcc_dwarf_w8_mips64,   LLDB_INVALID_REGNUM,    gdb_w8_mips64),
+    DEFINE_MSA (w9,    NULL,   gcc_dwarf_w9_mips64,   gcc_dwarf_w9_mips64,   LLDB_INVALID_REGNUM,    gdb_w9_mips64),
+    DEFINE_MSA (w10,   NULL,   gcc_dwarf_w10_mips64,  gcc_dwarf_w10_mips64,  LLDB_INVALID_REGNUM,    gdb_w10_mips64),
+    DEFINE_MSA (w11,   NULL,   gcc_dwarf_w11_mips64,  gcc_dwarf_w11_mips64,  LLDB_INVALID_REGNUM,    gdb_w11_mips64),
+    DEFINE_MSA (w12,   NULL,   gcc_dwarf_w12_mips64,  gcc_dwarf_w12_mips64,  LLDB_INVALID_REGNUM,    gdb_w12_mips64),
+    DEFINE_MSA (w13,   NULL,   gcc_dwarf_w13_mips64,  gcc_dwarf_w13_mips64,  LLDB_INVALID_REGNUM,    gdb_w13_mips64),
+    DEFINE_MSA (w14,   NULL,   gcc_dwarf_w14_mips64,  gcc_dwarf_w14_mips64,  LLDB_INVALID_REGNUM,    gdb_w14_mips64),
+    DEFINE_MSA (w15,   NULL,   gcc_dwarf_w15_mips64,  gcc_dwarf_w15_mips64,  LLDB_INVALID_REGNUM,    gdb_w15_mips64),
+    DEFINE_MSA (w16,   NULL,   gcc_dwarf_w16_mips64,  gcc_dwarf_w16_mips64,  LLDB_INVALID_REGNUM,    gdb_w16_mips64),
+    DEFINE_MSA (w17,   NULL,   gcc_dwarf_w17_mips64,  gcc_dwarf_w17_mips64,  LLDB_INVALID_REGNUM,    gdb_w17_mips64),
+    DEFINE_MSA (w18,   NULL,   gcc_dwarf_w18_mips64,  gcc_dwarf_w18_mips64,  LLDB_INVALID_REGNUM,    gdb_w18_mips64),
+    DEFINE_MSA (w19,   NULL,   gcc_dwarf_w19_mips64,  gcc_dwarf_w19_mips64,  LLDB_INVALID_REGNUM,    gdb_w19_mips64),
+    DEFINE_MSA (w20,   NULL,   gcc_dwarf_w10_mips64,  gcc_dwarf_w20_mips64,  LLDB_INVALID_REGNUM,    gdb_w20_mips64),
+    DEFINE_MSA (w21,   NULL,   gcc_dwarf_w21_mips64,  gcc_dwarf_w21_mips64,  LLDB_INVALID_REGNUM,    gdb_w21_mips64),
+    DEFINE_MSA (w22,   NULL,   gcc_dwarf_w22_mips64,  gcc_dwarf_w22_mips64,  LLDB_INVALID_REGNUM,    gdb_w22_mips64),
+    DEFINE_MSA (w23,   NULL,   gcc_dwarf_w23_mips64,  gcc_dwarf_w23_mips64,  LLDB_INVALID_REGNUM,    gdb_w23_mips64),
+    DEFINE_MSA (w24,   NULL,   gcc_dwarf_w24_mips64,  gcc_dwarf_w24_mips64,  LLDB_INVALID_REGNUM,    gdb_w24_mips64),
+    DEFINE_MSA (w25,   NULL,   gcc_dwarf_w25_mips64,  gcc_dwarf_w25_mips64,  LLDB_INVALID_REGNUM,    gdb_w25_mips64),
+    DEFINE_MSA (w26,   NULL,   gcc_dwarf_w26_mips64,  gcc_dwarf_w26_mips64,  LLDB_INVALID_REGNUM,    gdb_w26_mips64),
+    DEFINE_MSA (w27,   NULL,   gcc_dwarf_w27_mips64,  gcc_dwarf_w27_mips64,  LLDB_INVALID_REGNUM,    gdb_w27_mips64),
+    DEFINE_MSA (w28,   NULL,   gcc_dwarf_w28_mips64,  gcc_dwarf_w28_mips64,  LLDB_INVALID_REGNUM,    gdb_w28_mips64),
+    DEFINE_MSA (w29,   NULL,   gcc_dwarf_w29_mips64,  gcc_dwarf_w29_mips64,  LLDB_INVALID_REGNUM,    gdb_w29_mips64),
+    DEFINE_MSA (w30,   NULL,   gcc_dwarf_w30_mips64,  gcc_dwarf_w30_mips64,  LLDB_INVALID_REGNUM,    gdb_w30_mips64),
+    DEFINE_MSA (w31,   NULL,   gcc_dwarf_w31_mips64,  gcc_dwarf_w31_mips64,  LLDB_INVALID_REGNUM,    gdb_w31_mips64),
+    DEFINE_MSA_INFO (mcsr,  NULL,   gcc_dwarf_mcsr_mips64, gcc_dwarf_mcsr_mips64, LLDB_INVALID_REGNUM,    gdb_mcsr_mips64),
+    DEFINE_MSA_INFO (mir,   NULL,   gcc_dwarf_mir_mips64,  gcc_dwarf_mir_mips64,  LLDB_INVALID_REGNUM,    gdb_mir_mips64),
+    DEFINE_MSA_INFO (fcsr,  NULL,   gcc_dwarf_fcsr_mips64, gcc_dwarf_fcsr_mips64, LLDB_INVALID_REGNUM,    gdb_fcsr_mips64),
+    DEFINE_MSA_INFO (fir,   NULL,   gcc_dwarf_fir_mips64,  gcc_dwarf_fir_mips64,  LLDB_INVALID_REGNUM,    gdb_fir_mips64),
+    DEFINE_MSA_INFO (config5, NULL,   gcc_dwarf_config5_mips64,  gcc_dwarf_config5_mips64,  LLDB_INVALID_REGNUM,    gdb_config5_mips64)
+#endif
 };
+
 static_assert((sizeof(g_register_infos_mips64) / sizeof(g_register_infos_mips64[0])) == k_num_registers_mips64,
     "g_register_infos_mips64 has wrong number of register infos");
 
 #undef DEFINE_GPR
+#undef DEFINE_GPR_INFO
 #undef DEFINE_FPR
+#undef DEFINE_MSA
+#undef DEFINE_MSA_INFO
 #undef GPR_OFFSET
 #undef FPR_OFFSET
+#undef MSA_OFFSET
 
 #endif // DECLARE_REGISTER_INFOS_MIPS64_STRUCT

source/Plugins/Process/Utility/lldb-mips-freebsd-register-enums.h

+//===-- lldb-mips-frebsd-register-enums.h -------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef lldb_mips_freebsd_register_enums_h
+#define lldb_mips_freebsd_register_enums_h
+
+namespace lldb_private
+{
+    // LLDB register codes (e.g. RegisterKind == eRegisterKindLLDB)
+
+    //---------------------------------------------------------------------------
+    // Internal codes for all mips registers.
+    //---------------------------------------------------------------------------
+    enum
+    {
+        k_first_gpr_mips64,
+        gpr_zero_mips64 = k_first_gpr_mips64,
+        gpr_r1_mips64,
+        gpr_r2_mips64,
+        gpr_r3_mips64,
+        gpr_r4_mips64,
+        gpr_r5_mips64,
+        gpr_r6_mips64,
+        gpr_r7_mips64,
+        gpr_r8_mips64,
+        gpr_r9_mips64,
+        gpr_r10_mips64,
+        gpr_r11_mips64,
+        gpr_r12_mips64,
+        gpr_r13_mips64,
+        gpr_r14_mips64,
+        gpr_r15_mips64,
+        gpr_r16_mips64,
+        gpr_r17_mips64,
+        gpr_r18_mips64,
+        gpr_r19_mips64,
+        gpr_r20_mips64,
+        gpr_r21_mips64,
+        gpr_r22_mips64,
+        gpr_r23_mips64,
+        gpr_r24_mips64,
+        gpr_r25_mips64,
+        gpr_r26_mips64,
+        gpr_r27_mips64,
+        gpr_gp_mips64,
+        gpr_sp_mips64,
+        gpr_r30_mips64,
+        gpr_ra_mips64,
+        gpr_sr_mips64,
+        gpr_mullo_mips64,
+        gpr_mulhi_mips64,
+        gpr_badvaddr_mips64,
+        gpr_cause_mips64,
+        gpr_pc_mips64,
+        gpr_ic_mips64,
+        gpr_dummy_mips64,
+        k_last_gpr_mips64 = gpr_dummy_mips64,
+
+        k_num_registers_mips64,
+
+        k_num_gpr_registers_mips64 = k_last_gpr_mips64 - k_first_gpr_mips64 + 1
+    };
+}
+#endif // #ifndef lldb_mips_freebsd_register_enums_h

source/Plugins/Process/Utility/lldb-mips-linux-register-enums.h

+//===-- lldb-mips-linux-register-enums.h -------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef lldb_mips_linux_register_enums_h
+#define lldb_mips_linux_register_enums_h
+
+namespace lldb_private
+{
+    // LLDB register codes (e.g. RegisterKind == eRegisterKindLLDB)
+
+    //---------------------------------------------------------------------------
+    // Internal codes for all mips registers.
+    //---------------------------------------------------------------------------
+    enum
+    {
+        k_first_gpr_mips,
+        gpr_zero_mips = k_first_gpr_mips,
+        gpr_r1_mips,
+        gpr_r2_mips,
+        gpr_r3_mips,
+        gpr_r4_mips,
+        gpr_r5_mips,
+        gpr_r6_mips,
+        gpr_r7_mips,
+        gpr_r8_mips,
+        gpr_r9_mips,
+        gpr_r10_mips,
+        gpr_r11_mips,
+        gpr_r12_mips,
+        gpr_r13_mips,
+        gpr_r14_mips,
+        gpr_r15_mips,
+        gpr_r16_mips,
+        gpr_r17_mips,
+        gpr_r18_mips,
+        gpr_r19_mips,
+        gpr_r20_mips,
+        gpr_r21_mips,
+        gpr_r22_mips,
+        gpr_r23_mips,
+        gpr_r24_mips,
+        gpr_r25_mips,
+        gpr_r26_mips,
+        gpr_r27_mips,
+        gpr_gp_mips,
+        gpr_sp_mips,
+        gpr_r30_mips,
+        gpr_ra_mips,
+        gpr_sr_mips,
+        gpr_mullo_mips,
+        gpr_mulhi_mips,
+        gpr_badvaddr_mips,
+        gpr_cause_mips,
+        gpr_pc_mips,
+        gpr_config5_mips,
+
+        k_last_gpr_mips = gpr_config5_mips,
+
+        k_first_fpr_mips,
+        fpr_f0_mips = k_first_fpr_mips,
+        fpr_f1_mips,
+        fpr_f2_mips,
+        fpr_f3_mips,
+        fpr_f4_mips,
+        fpr_f5_mips,
+        fpr_f6_mips,
+        fpr_f7_mips,
+        fpr_f8_mips,
+        fpr_f9_mips,
+        fpr_f10_mips,
+        fpr_f11_mips,
+        fpr_f12_mips,
+        fpr_f13_mips,
+        fpr_f14_mips,
+        fpr_f15_mips,
+        fpr_f16_mips,
+        fpr_f17_mips,
+        fpr_f18_mips,
+        fpr_f19_mips,
+        fpr_f20_mips,
+        fpr_f21_mips,
+        fpr_f22_mips,
+        fpr_f23_mips,
+        fpr_f24_mips,
+        fpr_f25_mips,
+        fpr_f26_mips,
+        fpr_f27_mips,
+        fpr_f28_mips,
+        fpr_f29_mips,
+        fpr_f30_mips,
+        fpr_f31_mips,
+        fpr_fcsr_mips,
+        fpr_fir_mips,
+        fpr_config5_mips,
+        k_last_fpr_mips = fpr_config5_mips,
+
+        k_first_msa_mips,
+        msa_w0_mips = k_first_msa_mips,
+        msa_w1_mips,
+        msa_w2_mips,
+        msa_w3_mips,
+        msa_w4_mips,
+        msa_w5_mips,
+        msa_w6_mips,
+        msa_w7_mips,
+        msa_w8_mips,
+        msa_w9_mips,
+        msa_w10_mips,
+        msa_w11_mips,
+        msa_w12_mips,
+        msa_w13_mips,
+        msa_w14_mips,
+        msa_w15_mips,
+        msa_w16_mips,
+        msa_w17_mips,
+        msa_w18_mips,
+        msa_w19_mips,
+        msa_w20_mips,
+        msa_w21_mips,
+        msa_w22_mips,
+        msa_w23_mips,
+        msa_w24_mips,
+        msa_w25_mips,
+        msa_w26_mips,
+        msa_w27_mips,
+        msa_w28_mips,
+        msa_w29_mips,
+        msa_w30_mips,
+        msa_w31_mips,
+        msa_fcsr_mips,
+        msa_fir_mips,
+        msa_mcsr_mips,
+        msa_mir_mips,
+        msa_config5_mips,
+        k_last_msa_mips = msa_config5_mips,
+
+        k_num_registers_mips,
+
+        k_num_gpr_registers_mips = k_last_gpr_mips - k_first_gpr_mips + 1,
+        k_num_fpr_registers_mips = k_last_fpr_mips - k_first_fpr_mips + 1,
+        k_num_msa_registers_mips = k_last_msa_mips - k_first_msa_mips + 1,
+        k_num_user_registers_mips = k_num_gpr_registers_mips + k_num_fpr_registers_mips + k_num_msa_registers_mips
+    };
+
+    //---------------------------------------------------------------------------
+    // Internal codes for all mips64 registers.
+    //---------------------------------------------------------------------------
+    enum
+    {
+        k_first_gpr_mips64,
+        gpr_zero_mips64 = k_first_gpr_mips64,
+        gpr_r1_mips64,
+        gpr_r2_mips64,
+        gpr_r3_mips64,
+        gpr_r4_mips64,
+        gpr_r5_mips64,
+        gpr_r6_mips64,
+        gpr_r7_mips64,
+        gpr_r8_mips64,
+        gpr_r9_mips64,
+        gpr_r10_mips64,
+        gpr_r11_mips64,
+        gpr_r12_mips64,
+        gpr_r13_mips64,
+        gpr_r14_mips64,
+        gpr_r15_mips64,
+        gpr_r16_mips64,
+        gpr_r17_mips64,
+        gpr_r18_mips64,
+        gpr_r19_mips64,
+        gpr_r20_mips64,
+        gpr_r21_mips64,
+        gpr_r22_mips64,
+        gpr_r23_mips64,
+        gpr_r24_mips64,
+        gpr_r25_mips64,
+        gpr_r26_mips64,
+        gpr_r27_mips64,
+        gpr_gp_mips64,
+        gpr_sp_mips64,
+        gpr_r30_mips64,
+        gpr_ra_mips64,
+        gpr_sr_mips64,
+        gpr_mullo_mips64,
+        gpr_mulhi_mips64,
+        gpr_badvaddr_mips64,
+        gpr_cause_mips64,
+        gpr_pc_mips64,
+        gpr_config5_mips64,
+        k_last_gpr_mips64 = gpr_config5_mips64,
+
+        k_first_fpr_mips64,
+        fpr_f0_mips64 = k_first_fpr_mips64,
+        fpr_f1_mips64,
+        fpr_f2_mips64,
+        fpr_f3_mips64,
+        fpr_f4_mips64,
+        fpr_f5_mips64,
+        fpr_f6_mips64,
+        fpr_f7_mips64,
+        fpr_f8_mips64,
+        fpr_f9_mips64,
+        fpr_f10_mips64,
+        fpr_f11_mips64,
+        fpr_f12_mips64,
+        fpr_f13_mips64,
+        fpr_f14_mips64,
+        fpr_f15_mips64,
+        fpr_f16_mips64,
+        fpr_f17_mips64,
+        fpr_f18_mips64,
+        fpr_f19_mips64,
+        fpr_f20_mips64,
+        fpr_f21_mips64,
+        fpr_f22_mips64,
+        fpr_f23_mips64,
+        fpr_f24_mips64,
+        fpr_f25_mips64,
+        fpr_f26_mips64,
+        fpr_f27_mips64,
+        fpr_f28_mips64,
+        fpr_f29_mips64,
+        fpr_f30_mips64,
+        fpr_f31_mips64,
+        fpr_fcsr_mips64,
+        fpr_fir_mips64,
+        fpr_config5_mips64,
+        k_last_fpr_mips64 = fpr_config5_mips64,
+
+        k_first_msa_mips64,
+        msa_w0_mips64 = k_first_msa_mips64,
+        msa_w1_mips64,
+        msa_w2_mips64,
+        msa_w3_mips64,
+        msa_w4_mips64,
+        msa_w5_mips64,
+        msa_w6_mips64,
+        msa_w7_mips64,
+        msa_w8_mips64,
+        msa_w9_mips64,
+        msa_w10_mips64,
+        msa_w11_mips64,
+        msa_w12_mips64,
+        msa_w13_mips64,
+        msa_w14_mips64,
+        msa_w15_mips64,
+        msa_w16_mips64,
+        msa_w17_mips64,
+        msa_w18_mips64,
+        msa_w19_mips64,
+        msa_w20_mips64,
+        msa_w21_mips64,
+        msa_w22_mips64,
+        msa_w23_mips64,
+        msa_w24_mips64,
+        msa_w25_mips64,
+        msa_w26_mips64,
+        msa_w27_mips64,
+        msa_w28_mips64,
+        msa_w29_mips64,
+        msa_w30_mips64,
+        msa_w31_mips64,
+        msa_fcsr_mips64,
+        msa_fir_mips64,
+        msa_mcsr_mips64,
+        msa_mir_mips64,
+        msa_config5_mips64,
+        k_last_msa_mips64 = msa_config5_mips64,
+
+        k_num_registers_mips64,
+
+        k_num_gpr_registers_mips64 = k_last_gpr_mips64 - k_first_gpr_mips64 + 1,
+        k_num_fpr_registers_mips64 = k_last_fpr_mips64 - k_first_fpr_mips64 + 1,
+        k_num_msa_registers_mips64 = k_last_msa_mips64 - k_first_msa_mips64 + 1,
+        k_num_user_registers_mips64 = k_num_gpr_registers_mips64 + k_num_fpr_registers_mips64 + k_num_msa_registers_mips64
+    };
+}
+
+#endif // #ifndef lldb_mips_linux_register_enums_h

source/Plugins/Process/Utility/lldb-mips64-register-enums.h

-//===-- lldb-mips64-register-enums.h -------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef lldb_mips64_register_enums_h
-#define lldb_mips64_register_enums_h
-
-namespace lldb_private
-{
-    // LLDB register codes (e.g. RegisterKind == eRegisterKindLLDB)
-
-    //---------------------------------------------------------------------------
-    // Internal codes for all mips registers.
-    //---------------------------------------------------------------------------
-    enum
-    {
-        k_first_gpr_mips,
-        gpr_zero_mips = k_first_gpr_mips,
-        gpr_r1_mips,
-        gpr_r2_mips,
-        gpr_r3_mips,
-        gpr_r4_mips,
-        gpr_r5_mips,
-        gpr_r6_mips,
-        gpr_r7_mips,
-        gpr_r8_mips,
-        gpr_r9_mips,
-        gpr_r10_mips,
-        gpr_r11_mips,
-        gpr_r12_mips,
-        gpr_r13_mips,
-        gpr_r14_mips,
-        gpr_r15_mips,
-        gpr_r16_mips,
-        gpr_r17_mips,
-        gpr_r18_mips,
-        gpr_r19_mips,
-        gpr_r20_mips,
-        gpr_r21_mips,
-        gpr_r22_mips,
-        gpr_r23_mips,
-        gpr_r24_mips,
-        gpr_r25_mips,
-        gpr_r26_mips,
-        gpr_r27_mips,
-        gpr_gp_mips,
-        gpr_sp_mips,
-        gpr_r30_mips,
-        gpr_ra_mips,
-        gpr_mullo_mips,
-        gpr_mulhi_mips,
-        gpr_pc_mips,
-        gpr_badvaddr_mips,
-        gpr_sr_mips,
-        gpr_cause_mips,
-
-        k_last_gpr_mips = gpr_cause_mips,
-
-        k_first_fpr_mips,
-        fpr_f0_mips = k_first_fpr_mips,
-        fpr_f1_mips,
-        fpr_f2_mips,
-        fpr_f3_mips,
-        fpr_f4_mips,
-        fpr_f5_mips,
-        fpr_f6_mips,
-        fpr_f7_mips,
-        fpr_f8_mips,
-        fpr_f9_mips,
-        fpr_f10_mips,
-        fpr_f11_mips,
-        fpr_f12_mips,
-        fpr_f13_mips,
-        fpr_f14_mips,
-        fpr_f15_mips,
-        fpr_f16_mips,
-        fpr_f17_mips,
-        fpr_f18_mips,
-        fpr_f19_mips,
-        fpr_f20_mips,
-        fpr_f21_mips,
-        fpr_f22_mips,
-        fpr_f23_mips,
-        fpr_f24_mips,
-        fpr_f25_mips,
-        fpr_f26_mips,
-        fpr_f27_mips,
-        fpr_f28_mips,
-        fpr_f29_mips,
-        fpr_f30_mips,
-        fpr_f31_mips,
-        fpr_fcsr_mips,
-        fpr_fir_mips,
-        k_last_fpr_mips = fpr_fir_mips,
-
-        k_num_registers_mips,
-        k_num_gpr_registers_mips = k_last_gpr_mips - k_first_gpr_mips + 1,
-        k_num_fpr_registers_mips = k_last_fpr_mips - k_first_fpr_mips + 1,
-        k_num_user_registers_mips = k_num_gpr_registers_mips + k_num_fpr_registers_mips,
-    };
-
-    //---------------------------------------------------------------------------
-    // Internal codes for all mips64 registers.
-    //---------------------------------------------------------------------------
-    enum
-    {
-        k_first_gpr_mips64,
-        gpr_zero_mips64 = k_first_gpr_mips64,
-        gpr_r1_mips64,
-        gpr_r2_mips64,
-        gpr_r3_mips64,
-        gpr_r4_mips64,
-        gpr_r5_mips64,
-        gpr_r6_mips64,
-        gpr_r7_mips64,
-        gpr_r8_mips64,
-        gpr_r9_mips64,
-        gpr_r10_mips64,
-        gpr_r11_mips64,
-        gpr_r12_mips64,
-        gpr_r13_mips64,
-        gpr_r14_mips64,
-        gpr_r15_mips64,
-        gpr_r16_mips64,
-        gpr_r17_mips64,
-        gpr_r18_mips64,
-        gpr_r19_mips64,
-        gpr_r20_mips64,
-        gpr_r21_mips64,
-        gpr_r22_mips64,
-        gpr_r23_mips64,
-        gpr_r24_mips64,
-        gpr_r25_mips64,
-        gpr_r26_mips64,
-        gpr_r27_mips64,
-        gpr_gp_mips64,
-        gpr_sp_mips64,
-        gpr_r30_mips64,
-        gpr_ra_mips64,
-        gpr_mullo_mips64,
-        gpr_mulhi_mips64,
-        gpr_pc_mips64,
-        gpr_badvaddr_mips64,
-        gpr_sr_mips64,
-        gpr_cause_mips64,
-        gpr_ic_mips64,
-        gpr_dummy_mips64,
-
-        k_last_gpr_mips64 = gpr_dummy_mips64,
-
-        k_first_fpr_mips64,
-        fpr_f0_mips64 = k_first_fpr_mips64,
-        fpr_f1_mips64,
-        fpr_f2_mips64,
-        fpr_f3_mips64,
-        fpr_f4_mips64,
-        fpr_f5_mips64,
-        fpr_f6_mips64,
-        fpr_f7_mips64,
-        fpr_f8_mips64,
-        fpr_f9_mips64,
-        fpr_f10_mips64,
-        fpr_f11_mips64,
-        fpr_f12_mips64,
-        fpr_f13_mips64,
-        fpr_f14_mips64,
-        fpr_f15_mips64,
-        fpr_f16_mips64,
-        fpr_f17_mips64,
-        fpr_f18_mips64,
-        fpr_f19_mips64,
-        fpr_f20_mips64,
-        fpr_f21_mips64,
-        fpr_f22_mips64,
-        fpr_f23_mips64,
-        fpr_f24_mips64,
-        fpr_f25_mips64,
-        fpr_f26_mips64,
-        fpr_f27_mips64,
-        fpr_f28_mips64,
-        fpr_f29_mips64,
-        fpr_f30_mips64,
-        fpr_f31_mips64,
-        fpr_fcsr_mips64,
-        fpr_fir_mips64,
-        k_last_fpr_mips64 = fpr_fir_mips64,
-
-        k_num_registers_mips64,
-        k_num_gpr_registers_mips64 = k_last_gpr_mips64 - k_first_gpr_mips64 + 1,
-        k_num_fpr_registers_mips64 = k_last_fpr_mips64 - k_first_fpr_mips64 + 1,
-    };
-}
-
-#endif // #ifndef fpr_mips64_register_enums_h