Add a class ValueObjectConstResultCast.

[sivachandra]

Summary

Other changes around the main change include:

1. Add a method Cast to ValueObjectConstResult, ValueObjectConstResultImpl

and ValueObjectConstResultChild.

2. Add an argument |live_address| of type lldb::addr_t to the constructor

of ValueObjectConstResultChild. This is passed on to the backing
ValueObjectConstResultImpl object constructor so that the address of the
child value can be calculated properly.

[sivachandra]

I will add tests in case the general direction of this change is OK.

[clayborg]

I would almost rather see us create a ValueObjectCast class that just takes another ValueObjectSP and a new type to cast it to. We might want there to be different cast types like static, reinterpret, or dynamic. Is there a reason this is ValueObjectConstResultCast? I think it would be great to be able to cast any ValueObjectSP if possible. I will talk more with Jim Ingham on this and get back to you.

[clayborg]

Actually after speaking with Jim Ingham and Enrico Granata, this is the way it should be for now.

[granata.enrico]

This patch is fine for now if that is what is required in the current model

In general, a redesign of how Cast works (and even - on a broader level - what operations might fall under the "casting" label in a debugger) would be great, but that is definitely beyond the scope of your change

[sivachandra]

Added tests.

[sivachandra]

Thanks for the review, I will commit this shortly.

include/lldb/Core/ValueObjectCast.h

protected:
     virtual bool
     UpdateValue ();
     
     virtual ClangASTType
     GetClangTypeImpl ();
     
     ClangASTType m_cast_type;
     
-private:
     ValueObjectCast (ValueObject &parent, 
                      const ConstString &name, 
                      const ClangASTType &cast_type);
     
+private:
     //------------------------------------------------------------------
     // For ValueObject only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (ValueObjectCast);
 };
 
 } // namespace lldb_private
 
 #endif  // liblldb_ValueObjectCast_h_

include/lldb/Core/ValueObjectConstResult.h

public:
     }
     
     virtual lldb::ValueObjectSP
     GetDynamicValue (lldb::DynamicValueType valueType);
     
     virtual lldb::LanguageType
     GetPreferredDisplayLanguage ();
 
+    virtual lldb::ValueObjectSP
+    Cast (const ClangASTType &clang_ast_type);
+
 protected:
     virtual bool
     UpdateValue ();
     
     virtual ClangASTType
     GetClangTypeImpl ();
 
     ConstString m_type_name;

include/lldb/Core/ValueObjectConstResultCast.h

+//===-- ValueObjectConstResultCast.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_ValueObjectConstResultCast_h_
+#define liblldb_ValueObjectConstResultCast_h_
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/Core/ValueObjectCast.h"
+#include "lldb/Core/ValueObjectConstResultImpl.h"
+
+namespace lldb_private {
+
+class ValueObjectConstResultCast : public ValueObjectCast
+{
+public:
+    ValueObjectConstResultCast (
+        ValueObject &parent,
+        const ConstString &name,
+        const ClangASTType &cast_type,
+        lldb::addr_t live_address = LLDB_INVALID_ADDRESS);
+
+    virtual
+    ~ValueObjectConstResultCast ();
+
+    virtual lldb::ValueObjectSP
+    Dereference (Error &error);
+
+    virtual ValueObject *
+    CreateChildAtIndex (size_t idx,
+                        bool synthetic_array_member,
+                        int32_t synthetic_index);
+
+    virtual ClangASTType
+    GetClangType ()
+    {
+        return ValueObjectCast::GetClangType();
+    }
+
+    virtual lldb::ValueObjectSP
+    GetSyntheticChildAtOffset(uint32_t offset,
+                              const ClangASTType& type,
+                              bool can_create);
+
+    virtual lldb::ValueObjectSP
+    AddressOf (Error &error);
+
+    virtual size_t
+    GetPointeeData (DataExtractor& data,
+                    uint32_t item_idx = 0,
+                    uint32_t item_count = 1);
+
+    virtual lldb::ValueObjectSP
+    Cast (const ClangASTType &clang_ast_type);
+
+protected:
+    ValueObjectConstResultImpl m_impl;
+
+private:
+    friend class ValueObject;
+    friend class ValueObjectConstResult;
+    friend class ValueObjectConstResultImpl;
+
+    DISALLOW_COPY_AND_ASSIGN (ValueObjectConstResultCast);
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_ValueObjectConstResultCast_h_

include/lldb/Core/ValueObjectConstResultChild.h

public:
     ValueObjectConstResultChild (ValueObject &parent,
                                  const ClangASTType &clang_type,
                                  const ConstString &name,
                                  uint32_t byte_size,
                                  int32_t byte_offset,
                                  uint32_t bitfield_bit_size,
                                  uint32_t bitfield_bit_offset,
                                  bool is_base_class,
-                                 bool is_deref_of_parent);
+                                 bool is_deref_of_parent,
+                                 lldb::addr_t live_address = LLDB_INVALID_ADDRESS);
     
     virtual ~ValueObjectConstResultChild();
     
     virtual lldb::ValueObjectSP
     Dereference (Error &error);
     
     virtual ValueObject *
     CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index);
public:
     
     virtual lldb::ValueObjectSP
     AddressOf (Error &error);
     
     virtual size_t
     GetPointeeData (DataExtractor& data,
                     uint32_t item_idx = 0,
           uint32_t item_count = 1);
-    
+    virtual lldb::ValueObjectSP
+    Cast (const ClangASTType &clang_ast_type);
+    
 protected:
     ValueObjectConstResultImpl m_impl;
     
 private:
     friend class ValueObject;
     friend class ValueObjectConstResult;
     friend class ValueObjectConstResultImpl;
 
     DISALLOW_COPY_AND_ASSIGN (ValueObjectConstResultChild);
 };
 
 } // namespace lldb_private
 
 #endif  // liblldb_ValueObjectConstResultChild_h_

include/lldb/Core/ValueObjectConstResultImpl.h

public:
     lldb::ValueObjectSP
     AddressOf (Error &error);
     
     lldb::addr_t
     GetLiveAddress()
     {
         return m_live_address;
     }
-    
+    lldb::ValueObjectSP
+    Cast (const ClangASTType &clang_ast_type);
+    
     void
     SetLiveAddress(lldb::addr_t addr = LLDB_INVALID_ADDRESS,
                    AddressType address_type = eAddressTypeLoad)
     {
         m_live_address = addr;
         m_live_address_type = address_type;
     }
     

source/Core/CMakeLists.txt

add_lldb_library(lldbCore
   UserID.cpp
   UserSettingsController.cpp
   UUID.cpp
   Value.cpp
   ValueObject.cpp
   ValueObjectCast.cpp
   ValueObjectChild.cpp
   ValueObjectConstResult.cpp
+  ValueObjectConstResultCast.cpp
   ValueObjectConstResultChild.cpp
   ValueObjectConstResultImpl.cpp
   ValueObjectDynamicValue.cpp
   ValueObjectList.cpp
   ValueObjectMemory.cpp
   ValueObjectRegister.cpp
   ValueObjectSyntheticFilter.cpp
   ValueObjectVariable.cpp
   VMRange.cpp
   )
 

source/Core/ValueObjectConstResult.cpp

if (use_dynamic != eNoDynamicValues)
                 m_dynamic_value = new ValueObjectDynamicValue (*this, use_dynamic);
         }
         if (m_dynamic_value)
             return m_dynamic_value->GetSP();
     }
     return ValueObjectSP();
 }
 
+lldb::ValueObjectSP
+ValueObjectConstResult::Cast (const ClangASTType &clang_ast_type)
+{
+    return m_impl.Cast(clang_ast_type);
+}
+
 lldb::LanguageType
 ValueObjectConstResult::GetPreferredDisplayLanguage ()
 {
     return lldb::eLanguageTypeUnknown;
 }

source/Core/ValueObjectConstResultCast.cpp

+//===-- ValueObjectConstResultCast.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/ValueObjectConstResultCast.h"
+
+#include "lldb/Core/ValueObjectConstResult.h"
+#include "lldb/Core/ValueObjectList.h"
+
+#include "lldb/Symbol/ClangASTContext.h"
+
+using namespace lldb_private;
+
+ValueObjectConstResultCast::ValueObjectConstResultCast(
+    ValueObject &parent,
+    const ConstString &name,
+    const ClangASTType &cast_type,
+    lldb::addr_t live_address) :
+    ValueObjectCast (parent, name, cast_type),
+    m_impl(this, live_address)
+{
+    m_name = name;
+}
+
+ValueObjectConstResultCast::~ValueObjectConstResultCast()
+{
+}
+
+lldb::ValueObjectSP
+ValueObjectConstResultCast::Dereference (Error &error)
+{
+    return m_impl.Dereference(error);
+}
+
+lldb::ValueObjectSP
+ValueObjectConstResultCast::GetSyntheticChildAtOffset(uint32_t offset,
+                                                      const ClangASTType& type,
+                                                      bool can_create)
+{
+    return m_impl.GetSyntheticChildAtOffset(offset, type, can_create);
+}
+
+lldb::ValueObjectSP
+ValueObjectConstResultCast::AddressOf (Error &error)
+{
+    return m_impl.AddressOf(error);
+}
+
+ValueObject *
+ValueObjectConstResultCast::CreateChildAtIndex (size_t idx,
+                                                bool synthetic_array_member,
+                                                int32_t synthetic_index)
+{
+    return m_impl.CreateChildAtIndex(
+        idx, synthetic_array_member, synthetic_index);
+}
+
+size_t
+ValueObjectConstResultCast::GetPointeeData (DataExtractor& data,
+                                             uint32_t item_idx,
+                                             uint32_t item_count)
+{
+    return m_impl.GetPointeeData(data, item_idx, item_count);
+}
+
+lldb::ValueObjectSP
+ValueObjectConstResultCast::Cast (const ClangASTType &clang_ast_type)
+{
+    return m_impl.Cast(clang_ast_type);
+}

source/Core/ValueObjectConstResultChild.cpp

(
     ValueObject &parent,
     const ClangASTType &clang_type,
     const ConstString &name,
     uint32_t byte_size,
     int32_t byte_offset,
     uint32_t bitfield_bit_size,
     uint32_t bitfield_bit_offset,
     bool is_base_class,
-    bool is_deref_of_parent
+    bool is_deref_of_parent,
+    lldb::addr_t live_address
 ) :
     ValueObjectChild (parent,
                       clang_type,
                       name,
                       byte_size,
                       byte_offset,
                       bitfield_bit_size,
                       bitfield_bit_offset,
                       is_base_class,
                       is_deref_of_parent,
                       eAddressTypeLoad),
-    m_impl(this)
+    m_impl(this, live_address)
 {
     m_name = name;
 }
 
 ValueObjectConstResultChild::~ValueObjectConstResultChild()
 {
 }
 

 
 size_t
 ValueObjectConstResultChild::GetPointeeData (DataExtractor& data,
                                              uint32_t item_idx,
                                              uint32_t item_count)
 {
     return m_impl.GetPointeeData(data, item_idx, item_count);
 }
+
+lldb::ValueObjectSP
+ValueObjectConstResultChild::Cast (const ClangASTType &clang_ast_type)
+{
+    return m_impl.Cast(clang_ast_type);
+}

source/Core/ValueObjectConstResultImpl.cpp

 //===-- ValueObjectConstResultImpl.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/ValueObjectConstResultImpl.h"
 
 #include "lldb/Core/ValueObjectChild.h"
 #include "lldb/Core/ValueObjectConstResult.h"
+#include "lldb/Core/ValueObjectConstResultCast.h"
 #include "lldb/Core/ValueObjectConstResultChild.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ValueObjectList.h"
 
 #include "lldb/Symbol/ClangASTType.h"
 #include "lldb/Symbol/ObjectFile.h"
ValueObjectConstResultImpl::CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index)
     if (child_clang_type && child_byte_size)
     {
         if (synthetic_index)
             child_byte_offset += child_byte_size * synthetic_index;
         
         ConstString child_name;
         if (!child_name_str.empty())
             child_name.SetCString (child_name_str.c_str());
-        
         valobj = new ValueObjectConstResultChild (*m_impl_backend,
                                                   child_clang_type,
                                                   child_name,
                                                   child_byte_size,
                                                   child_byte_offset,
                                                   child_bitfield_bit_size,
                                                   child_bitfield_bit_offset,
                                                   child_is_base_class,
if (m_live_address != LLDB_INVALID_ADDRESS)
         m_address_of_backend->GetValue().GetScalar() = m_live_address;
         
         return m_address_of_backend;
     }
     else
         return m_impl_backend->ValueObject::AddressOf(error);
 }
 
+lldb::ValueObjectSP
+ValueObjectConstResultImpl::Cast (const ClangASTType &clang_ast_type)
+{
+    if (m_impl_backend == NULL)
+        return lldb::ValueObjectSP();
+
+    ValueObjectConstResultCast *result_cast = new ValueObjectConstResultCast(
+        *m_impl_backend, m_impl_backend->GetName(), clang_ast_type, m_live_address);
+    return result_cast->GetSP();
+}
+
 lldb::addr_t
 ValueObjectConstResultImpl::GetAddressOf (bool scalar_is_load_address,
                                           AddressType *address_type)
 {
     
     if (m_impl_backend == NULL)
         return 0;
     

test/python_api/value/TestValueAPI.py

def value_api(self, exe_name):
 
         # Now try to get at the same variable using GetValueForExpressionPath().
         # These two SBValue objects should have the same value.
         val2 = value.GetValueForExpressionPath('[5]')
         self.assertTrue(val2, VALID_VARIABLE)
         self.DebugSBValue(val2)
         self.assertTrue(child.GetValue() == val2.GetValue() and
                         child.GetSummary() == val2.GetSummary())
-        
+        val_i = target.EvaluateExpression('i')
+        val_s = target.EvaluateExpression('s')
+        val_a = target.EvaluateExpression('a')
+        self.assertTrue(val_s.GetChildMemberWithName('a').AddressOf(), VALID_VARIABLE)
+        self.assertTrue(val_a.Cast(val_i.GetType()).AddressOf(), VALID_VARIABLE)
+        
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()

test/python_api/value/main.c

 const char *weekdays[5] = { "Monday",
                             "Tuesday",
                             "Wednesday",
                             "Thursday",
                             "Friday" };
 
 const char **g_table[2] = { days_of_week, weekdays };
 
+typedef int MyInt;
+
+struct MyStruct
+{
+  int a;
+  int b;
+};
+
 int main (int argc, char const *argv[])
 {
     int i;
+    MyInt a = 12345;
+    struct MyStruct s = { 11, 22 };
     int *my_int_ptr = &g_my_int;
     printf("my_int_ptr points to location %p\n", my_int_ptr);
     const char **str_ptr = days_of_week;
     for (i = 0; i < 7; ++i)
         printf("%s\n", str_ptr[i]); // Break at this line
                                     // and do str_ptr_val.GetChildAtIndex(5, lldb.eNoDynamicValues, True).
     
     return 0;
 }