Vendor import of lldb release_39 branch r276489:vendor/lldb/lldb-release_39-r276489

https://llvm.org/svn/llvm-project/lldb/branches/release_39@276489

1 files changed, 73 insertions, 119 deletions

diff --git a/source/Core/RegisterValue.cpp b/source/Core/RegisterValue.cpp
index d4ba9989c6a9..d9085d7f0bae 100644
--- a/source/Core/RegisterValue.cpp
+++ b/source/Core/RegisterValue.cpp
@@ -1,4 +1,4 @@
-//===-- RegisterValue.cpp ----------------------------------------*- C++ -*-===//
+//===-- RegisterValue.cpp ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -11,7 +11,12 @@
 
 // C Includes
 // C++ Includes
+#include <vector>
+
 // Other libraries and framework includes
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+
 // Project includes
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Error.h"
@@ -24,7 +29,6 @@
 using namespace lldb;
 using namespace lldb_private;
 
-
 bool
 RegisterValue::Dump (Stream *s, 
                      const RegisterInfo *reg_info, 
@@ -98,14 +102,12 @@ RegisterValue::Dump (Stream *s,
     return false;
 }
 
-
 bool
 RegisterValue::GetData (DataExtractor &data) const
 {
     return data.SetData(GetBytes(), GetByteSize(), GetByteOrder()) > 0;
 }
 
-
 uint32_t
 RegisterValue::GetAsMemoryData (const RegisterInfo *reg_info,
                                 void *dst,
@@ -113,7 +115,7 @@ RegisterValue::GetAsMemoryData (const RegisterInfo *reg_info,
                                 lldb::ByteOrder dst_byte_order,
                                 Error &error) const
 {    
-    if (reg_info == NULL)
+    if (reg_info == nullptr)
     {
         error.SetErrorString ("invalid register info argument.");
         return 0;
@@ -163,7 +165,7 @@ RegisterValue::SetFromMemoryData (const RegisterInfo *reg_info,
                                   lldb::ByteOrder src_byte_order,
                                   Error &error)
 {
-    if (reg_info == NULL)
+    if (reg_info == nullptr)
     {
         error.SetErrorString ("invalid register info argument.");
         return 0;
@@ -202,34 +204,13 @@ RegisterValue::SetFromMemoryData (const RegisterInfo *reg_info,
     // Use a data extractor to correctly copy and pad the bytes read into the
     // register value
     DataExtractor src_data (src, src_len, src_byte_order, 4);
-    
-    // Given the register info, set the value type of this RegisterValue object
-    SetType (reg_info);
-    // And make sure we were able to figure out what that register value was
-    RegisterValue::Type value_type = GetType();
-    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)
-    {
-        buffer.byte_order = src_byte_order;
-        // Make sure to set the buffer length of the destination buffer to avoid
-        // problems due to uninitialized 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);
+    error = SetValueFromData(reg_info, src_data, 0, true);
+    if (error.Fail())
+        return 0;
 
-    return bytes_copied;
+    // If SetValueFromData succeeded, we must have copied all of src_len
+    return src_len;
 }
 
 bool
@@ -239,16 +220,27 @@ RegisterValue::GetScalarValue (Scalar &scalar) const
     {
         case eTypeInvalid:      break;
         case eTypeBytes:
-        {
-            switch (buffer.length)
             {
-            default:    break;
-            case 1:     scalar = *(const uint8_t *)buffer.bytes; return true;
-            case 2:     scalar = *(const uint16_t *)buffer.bytes; return true;
-            case 4:     scalar = *(const uint32_t *)buffer.bytes; return true;
-            case 8:     scalar = *(const uint64_t *)buffer.bytes; return true;
+                switch (buffer.length)
+                {
+                default:    break;
+                case 1:     scalar = *(const uint8_t *)buffer.bytes; return true;
+                case 2:     scalar = *(const uint16_t *)buffer.bytes; return true;
+                case 4:     scalar = *(const uint32_t *)buffer.bytes; return true;
+                case 8:     scalar = *(const uint64_t *)buffer.bytes; return true;
+                case 16:
+                case 32:
+                            if (buffer.length % sizeof(uint64_t) == 0)
+                            {
+                                const auto length_in_bits = buffer.length * 8;
+                                const auto length_in_uint64 = buffer.length / sizeof(uint64_t);
+                                scalar = llvm::APInt(length_in_bits, llvm::ArrayRef<uint64_t>((const uint64_t *)buffer.bytes, length_in_uint64));
+                                return true;
+                            }
+                            break;
+                }
             }
-        }
+            break;
         case eTypeUInt8:
         case eTypeUInt16:
         case eTypeUInt32:
@@ -270,41 +262,12 @@ RegisterValue::Clear()
 RegisterValue::Type
 RegisterValue::SetType (const RegisterInfo *reg_info)
 {
-    m_type = eTypeInvalid;
-    const uint32_t byte_size = reg_info->byte_size;
-    switch (reg_info->encoding)
-    {
-        case eEncodingInvalid:
-            break;
-            
-        case eEncodingUint:
-        case eEncodingSint:
-            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;
-            else if (byte_size <= 16)
-                m_type = eTypeUInt128;
-            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;
+    // To change the type, we simply copy the data in again, using the new format
+    RegisterValue copy;
+    DataExtractor copy_data;
+    if (copy.CopyValue(*this) && copy.GetData(copy_data))
+        SetValueFromData(reg_info, copy_data, 0, true);
 
-        case eEncodingVector:
-            m_type = eTypeBytes;
-            break;
-    }
-    m_scalar.SetType(reg_info);
     return m_type;
 }
 
@@ -342,16 +305,23 @@ RegisterValue::SetValueFromData (const RegisterInfo *reg_info, DataExtractor &sr
     memset (buffer.bytes, 0, sizeof (buffer.bytes));
 
     type128 int128;
-    switch (SetType (reg_info))
+
+    m_type = eTypeInvalid;
+    switch (reg_info->encoding)
     {
-        case eTypeInvalid:
-            error.SetErrorString("");
+        case eEncodingInvalid:
             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;
-        case eTypeUInt128:
+        case eEncodingUint:
+        case eEncodingSint:
+            if (reg_info->byte_size == 1)
+                SetUInt8(src.GetMaxU32(&src_offset, src_len));
+            else if (reg_info->byte_size <= 2)
+                SetUInt16(src.GetMaxU32(&src_offset, src_len));
+            else if (reg_info->byte_size <= 4)
+                SetUInt32(src.GetMaxU32(&src_offset, src_len));
+            else if (reg_info->byte_size <= 8)
+                SetUInt64(src.GetMaxU64(&src_offset, src_len));
+            else if (reg_info->byte_size <= 16)
             {
                 uint64_t data1 = src.GetU64 (&src_offset);
                 uint64_t data2 = src.GetU64 (&src_offset);
@@ -368,11 +338,17 @@ RegisterValue::SetValueFromData (const RegisterInfo *reg_info, DataExtractor &sr
                 SetUInt128 (llvm::APInt(128, 2, int128.x));
             }
             break;
-        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:
+        case eEncodingIEEE754:
+            if (reg_info->byte_size == sizeof(float))
+                SetFloat(src.GetFloat(&src_offset));
+            else if (reg_info->byte_size == sizeof(double))
+                SetDouble(src.GetDouble(&src_offset));
+            else if (reg_info->byte_size == sizeof(long double))
+                SetLongDouble(src.GetLongDouble(&src_offset));
+            break;
+        case eEncodingVector:
         {
+            m_type = eTypeBytes;
             buffer.length = reg_info->byte_size;
             buffer.byte_order = src.GetByteOrder();
             assert (buffer.length <= kMaxRegisterByteSize);
@@ -384,17 +360,17 @@ RegisterValue::SetValueFromData (const RegisterInfo *reg_info, DataExtractor &sr
                                          buffer.length,          // dst length
                                          buffer.byte_order) == 0)// dst byte order
             {
-                error.SetErrorString ("data copy failed data.");
+                error.SetErrorStringWithFormat("failed to copy data for register write of %s", reg_info->name);
                 return error;
             }
         }
     }
-    
+
+    if (m_type == eTypeInvalid)
+        error.SetErrorStringWithFormat("invalid register value type for register %s", reg_info->name);
     return error;
 }
 
-#include "llvm/ADT/StringRef.h"
-#include <vector>
 static inline void StripSpaces(llvm::StringRef &Str)
 {
     while (!Str.empty() && isspace(Str[0]))
@@ -402,16 +378,19 @@ static inline void StripSpaces(llvm::StringRef &Str)
     while (!Str.empty() && isspace(Str.back()))
         Str = Str.substr(0, Str.size()-1);
 }
+
 static inline void LStrip(llvm::StringRef &Str, char c)
 {
     if (!Str.empty() && Str.front() == c)
         Str = Str.substr(1);
 }
+
 static inline void RStrip(llvm::StringRef &Str, char c)
 {
     if (!Str.empty() && Str.back() == c)
         Str = Str.substr(0, Str.size()-1);
 }
+
 // Helper function for RegisterValue::SetValueFromCString()
 static bool
 ParseVectorEncoding(const RegisterInfo *reg_info, const char *vector_str, const uint32_t byte_size, RegisterValue *reg_value)
@@ -445,17 +424,18 @@ ParseVectorEncoding(const RegisterInfo *reg_info, const char *vector_str, const
     reg_value->SetBytes(&(bytes.front()), byte_size, eByteOrderLittle);
     return true;
 }
+
 Error
 RegisterValue::SetValueFromCString (const RegisterInfo *reg_info, const char *value_str)
 {
     Error error;
-    if (reg_info == NULL)
+    if (reg_info == nullptr)
     {
         error.SetErrorString ("Invalid register info argument.");
         return error;
     }
 
-    if (value_str == NULL || value_str[0] == '\0')
+    if (value_str == nullptr || value_str[0] == '\0')
     {
         error.SetErrorString ("Invalid c-string value string.");
         return error;
@@ -562,7 +542,6 @@ RegisterValue::SetValueFromCString (const RegisterInfo *reg_info, const char *va
     return error;
 }
 
-
 bool
 RegisterValue::SignExtend (uint32_t sign_bitpos)
 {
@@ -730,9 +709,7 @@ RegisterValue::GetAsUInt128 (const llvm::APInt& fail_value, bool *success_ptr) c
                 case 4:
                 case 8:
                 case 16:
-                {
                     return llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)buffer.bytes)->x);
-                }
             }
         }
         break;
@@ -825,26 +802,7 @@ RegisterValue::GetBytes () const
         case eTypeLongDouble:   return m_scalar.GetBytes();
         case eTypeBytes:        return buffer.bytes;
     }
-    return NULL;
-}
-
-void *
-RegisterValue::GetBytes ()
-{
-    switch (m_type)
-    {
-        case eTypeInvalid:      break;
-        case eTypeUInt8:
-        case eTypeUInt16:
-        case eTypeUInt32:
-        case eTypeUInt64:
-        case eTypeUInt128:
-        case eTypeFloat:
-        case eTypeDouble:
-        case eTypeLongDouble:   return m_scalar.GetBytes();
-        case eTypeBytes:        return buffer.bytes;
-    }
-    return NULL;
+    return nullptr;
 }
 
 uint32_t
@@ -866,7 +824,6 @@ RegisterValue::GetByteSize () const
     return 0;
 }
 
-
 bool
 RegisterValue::SetUInt (uint64_t uint, uint32_t byte_size)
 {
@@ -921,7 +878,6 @@ RegisterValue::SetBytes (const void *bytes, size_t length, lldb::ByteOrder byte_
     }
 }
 
-
 bool
 RegisterValue::operator == (const RegisterValue &rhs) const
 {
@@ -1032,7 +988,6 @@ RegisterValue::ClearBit (uint32_t bit)
     return false;
 }
 
-
 bool
 RegisterValue::SetBit (uint32_t bit)
 {
@@ -1077,4 +1032,3 @@ RegisterValue::SetBit (uint32_t bit)
     }
     return false;
 }
-