This patch separates the generic portion of ClangExpressionVariable, which

stores information about a variable that different parts of LLDB use, from the
compiler-specific portion that only the expression parser cares about.

http://reviews.llvm.org/D12602

llvm-svn: 246871

2 files changed, 86 insertions, 338 deletions

diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.cpp
index 9d88f9009a9..735a843bc81 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.cpp
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.cpp
@@ -24,122 +24,38 @@ using namespace clang;
 const char *g_clang_expression_variable_kind_name = "ClangExpressionVariable";
 
 ClangExpressionVariable::ClangExpressionVariable(ExecutionContextScope *exe_scope, lldb::ByteOrder byte_order, uint32_t addr_byte_size) :
+    ExpressionVariable(),
     m_parser_vars(),
-    m_jit_vars (),
-    m_flags (EVNone),
-    m_frozen_sp (ValueObjectConstResult::Create (exe_scope, byte_order, addr_byte_size))
+    m_jit_vars ()
 {
+    m_flags = EVNone;
+    m_frozen_sp = ValueObjectConstResult::Create (exe_scope, byte_order, addr_byte_size);
 }
 
 ClangExpressionVariable::ClangExpressionVariable (ExecutionContextScope *exe_scope,
                                                   Value &value,
                                                   const ConstString &name,
                                                   uint16_t flags) :
+    ExpressionVariable(),
     m_parser_vars(),
-    m_jit_vars (),
-    m_flags (flags),
-    m_frozen_sp (ValueObjectConstResult::Create (exe_scope, value, name))
+    m_jit_vars ()
 {
+    m_flags = flags;
+    m_frozen_sp = ValueObjectConstResult::Create (exe_scope, value, name);
 }
 
 ClangExpressionVariable::ClangExpressionVariable (const lldb::ValueObjectSP &valobj_sp) :
+    ExpressionVariable(),
     m_parser_vars(),
-    m_jit_vars (),
-    m_flags (EVNone),
-    m_frozen_sp (valobj_sp)
+    m_jit_vars ()
 {
+    m_flags = EVNone;
+    m_frozen_sp = valobj_sp;
 }
 
-//----------------------------------------------------------------------
-/// Return the variable's size in bytes
-//----------------------------------------------------------------------
-size_t
-ClangExpressionVariable::GetByteSize ()
-{
-    return m_frozen_sp->GetByteSize();
-}
-
-const ConstString &
-ClangExpressionVariable::GetName ()
-{
-    return m_frozen_sp->GetName();
-}
-
-lldb::ValueObjectSP
-ClangExpressionVariable::GetValueObject()
-{
-    return m_frozen_sp;
-}
-
-RegisterInfo *
-ClangExpressionVariable::GetRegisterInfo()
-{
-    return m_frozen_sp->GetValue().GetRegisterInfo();
-}
-
-void
-ClangExpressionVariable::SetRegisterInfo (const RegisterInfo *reg_info)
-{
-    return m_frozen_sp->GetValue().SetContext (Value::eContextTypeRegisterInfo, const_cast<RegisterInfo *>(reg_info));
-}
-
-CompilerType
-ClangExpressionVariable::GetCompilerType()
-{
-    return m_frozen_sp->GetCompilerType();
-}
-
-void
-ClangExpressionVariable::SetCompilerType(const CompilerType &clang_type)
-{
-    m_frozen_sp->GetValue().SetCompilerType(clang_type);
-}
-
-
 TypeFromUser
 ClangExpressionVariable::GetTypeFromUser()
 {
     TypeFromUser tfu (m_frozen_sp->GetCompilerType());
     return tfu;
 }
-
-uint8_t *
-ClangExpressionVariable::GetValueBytes()
-{
-    const size_t byte_size = m_frozen_sp->GetByteSize();
-    if (byte_size > 0)
-    {
-        if (m_frozen_sp->GetDataExtractor().GetByteSize() < byte_size)
-        {
-            m_frozen_sp->GetValue().ResizeData(byte_size);
-            m_frozen_sp->GetValue().GetData (m_frozen_sp->GetDataExtractor());
-        }
-        return const_cast<uint8_t *>(m_frozen_sp->GetDataExtractor().GetDataStart());
-    }
-    return NULL;
-}
-
-void
-ClangExpressionVariable::SetName (const ConstString &name)
-{
-    m_frozen_sp->SetName (name);
-}
-
-void
-ClangExpressionVariable::ValueUpdated ()
-{
-    m_frozen_sp->ValueUpdated ();
-}
-
-void
-ClangExpressionVariable::TransferAddress (bool force)
-{
-    if (m_live_sp.get() == NULL)
-        return;
-
-    if (m_frozen_sp.get() == NULL)
-        return;
-
-    if (force || (m_frozen_sp->GetLiveAddress() == LLDB_INVALID_ADDRESS))
-        m_frozen_sp->SetLiveAddress(m_live_sp->GetLiveAddress());
-}
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h
index 580ab2a342a..ed3e908aa98 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h
@@ -26,6 +26,7 @@
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/Value.h"
+#include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Symbol/TaggedASTType.h"
 
 namespace llvm {
@@ -34,7 +35,6 @@ namespace llvm {
 
 namespace lldb_private {
 
-class ClangExpressionVariableList;
 class ValueObjectConstResult;
 
 //----------------------------------------------------------------------
@@ -60,7 +60,7 @@ class ValueObjectConstResult;
 /// polymorphism, and provides necessary support methods.  Its interface
 /// is RTTI-neutral.
 //----------------------------------------------------------------------
-class ClangExpressionVariable
+class ClangExpressionVariable : public ExpressionVariable
 {
 public:
     ClangExpressionVariable(ExecutionContextScope *exe_scope, lldb::ByteOrder byte_order, uint32_t addr_byte_size);
@@ -71,6 +71,77 @@ public:
                              uint16_t flags = EVNone);
     
     ClangExpressionVariable(const lldb::ValueObjectSP &valobj_sp);
+    
+    ClangExpressionVariable *AsClangExpressionVariable() override
+    {
+        return this;
+    }
+    
+    //----------------------------------------------------------------------
+    /// Utility functions for dealing with ExpressionVariableLists in Clang-specific ways
+    //----------------------------------------------------------------------
+    
+    //----------------------------------------------------------------------
+    /// Finds a variable by NamedDecl in the list.
+    ///
+    /// @param[in] name
+    ///     The name of the requested variable.
+    ///
+    /// @return
+    ///     The variable requested, or NULL if that variable is not in the list.
+    //----------------------------------------------------------------------
+    static ClangExpressionVariable *
+    FindVariableInList (ExpressionVariableList &list, const clang::NamedDecl *decl, uint64_t parser_id)
+    {
+        lldb::ExpressionVariableSP var_sp;
+        for (size_t index = 0, size = list.GetSize(); index < size; ++index)
+        {
+            var_sp = list.GetVariableAtIndex(index);
+            
+            if (ClangExpressionVariable *clang_var = var_sp->AsClangExpressionVariable())
+            {
+                ClangExpressionVariable::ParserVars *parser_vars = clang_var->GetParserVars(parser_id);
+                
+                if (parser_vars && parser_vars->m_named_decl == decl)
+                    return clang_var;
+            }
+        }
+        return nullptr;
+    }
+    
+    static ClangExpressionVariable *
+    CreateVariableInList (ExpressionVariableList &list, ExecutionContextScope *exe_scope, lldb::ByteOrder byte_order, uint32_t addr_byte_size)
+    {
+        ClangExpressionVariable *clang_var = new ClangExpressionVariable(exe_scope, byte_order, addr_byte_size);
+        lldb::ExpressionVariableSP var_sp(clang_var);
+        list.AddVariable(var_sp);
+        return clang_var;
+    }
+    
+    static ClangExpressionVariable *
+    CreateVariableInList (ExpressionVariableList &list, const lldb::ValueObjectSP &valobj_sp)
+    {
+        ClangExpressionVariable *clang_var = new ClangExpressionVariable(valobj_sp);
+        lldb::ExpressionVariableSP var_sp(clang_var);
+        list.AddVariable(var_sp);
+        return clang_var;
+    }
+    
+    static ClangExpressionVariable *
+    CreateVariableInList (ExpressionVariableList &list,
+                          ExecutionContextScope *exe_scope,
+                          const ConstString &name,
+                          const TypeFromUser& user_type,
+                          lldb::ByteOrder byte_order,
+                          uint32_t addr_byte_size)
+    {
+        ClangExpressionVariable *clang_var = new ClangExpressionVariable(exe_scope, byte_order, addr_byte_size);
+        lldb::ExpressionVariableSP var_sp(clang_var);
+        clang_var->SetName (name);
+        clang_var->SetCompilerType (user_type);
+        list.AddVariable(var_sp);
+        return clang_var;
+    }
 
     //----------------------------------------------------------------------
     /// If the variable contains its own data, make a Value point at it.
@@ -90,9 +161,6 @@ public:
     bool
     PointValueAtData(Value &value, ExecutionContext *exe_ctx);
     
-    lldb::ValueObjectSP
-    GetValueObject();
-
     //----------------------------------------------------------------------
     /// The following values should not live beyond parsing
     //----------------------------------------------------------------------
@@ -205,252 +273,16 @@ public:
         else
             return &i->second;
     }
-        
-    //----------------------------------------------------------------------
-    /// Return the variable's size in bytes
-    //----------------------------------------------------------------------
-    size_t 
-    GetByteSize ();
-
-    const ConstString &
-    GetName();
-
-    RegisterInfo *
-    GetRegisterInfo();
-    
-    void
-    SetRegisterInfo (const RegisterInfo *reg_info);
-
-    CompilerType
-    GetCompilerType ();
     
-    void
-    SetCompilerType (const CompilerType &clang_type);
-
     TypeFromUser
     GetTypeFromUser ();
-
-    uint8_t *
-    GetValueBytes ();
-    
-    void
-    SetName (const ConstString &name);
-
-    void
-    ValueUpdated ();
     
-    // this function is used to copy the address-of m_live_sp into m_frozen_sp
-    // this is necessary because the results of certain cast and pointer-arithmetic
-    // operations (such as those described in bugzilla issues 11588 and 11618) generate
-    // frozen objects that do not have a valid address-of, which can be troublesome when
-    // using synthetic children providers. Transferring the address-of the live object
-    // solves these issues and provides the expected user-level behavior
-    void
-    TransferAddress (bool force = false);
-
-    typedef std::shared_ptr<ValueObjectConstResult> ValueObjectConstResultSP;
-
     //----------------------------------------------------------------------
     /// Members
-    //----------------------------------------------------------------------
-    enum Flags 
-    {
-        EVNone                  = 0,
-        EVIsLLDBAllocated       = 1 << 0,   ///< This variable is resident in a location specifically allocated for it by LLDB in the target process
-        EVIsProgramReference    = 1 << 1,   ///< This variable is a reference to a (possibly invalid) area managed by the target program
-        EVNeedsAllocation       = 1 << 2,   ///< Space for this variable has yet to be allocated in the target process
-        EVIsFreezeDried         = 1 << 3,   ///< This variable's authoritative version is in m_frozen_sp (for example, for statically-computed results)
-        EVNeedsFreezeDry        = 1 << 4,   ///< Copy from m_live_sp to m_frozen_sp during dematerialization
-        EVKeepInTarget          = 1 << 5,   ///< Keep the allocation after the expression is complete rather than freeze drying its contents and freeing it
-        EVTypeIsReference       = 1 << 6,   ///< The original type of this variable is a reference, so materialize the value rather than the location
-        EVUnknownType           = 1 << 7,   ///< This is a symbol of unknown type, and the type must be resolved after parsing is complete
-        EVBareRegister          = 1 << 8    ///< This variable is a direct reference to $pc or some other entity.
-    };
-    
-    typedef uint16_t FlagType;
-    
-    FlagType m_flags; // takes elements of Flags
-    
-    lldb::ValueObjectSP m_frozen_sp;
-    lldb::ValueObjectSP m_live_sp;
-    
+    //----------------------------------------------------------------------        
     DISALLOW_COPY_AND_ASSIGN (ClangExpressionVariable);
 };
 
-//----------------------------------------------------------------------
-/// @class ClangExpressionVariableListBase ClangExpressionVariable.h "lldb/Expression/ClangExpressionVariable.h"
-/// @brief A list of variable references.
-///
-/// This class stores variables internally, acting as the permanent store.
-//----------------------------------------------------------------------
-class ClangExpressionVariableList
-{
-public:
-    //----------------------------------------------------------------------
-    /// Implementation of methods in ClangExpressionVariableListBase
-    //----------------------------------------------------------------------
-    size_t 
-    GetSize()
-    {
-        return m_variables.size();
-    }
-    
-    lldb::ClangExpressionVariableSP
-    GetVariableAtIndex(size_t index)
-    {
-        lldb::ClangExpressionVariableSP var_sp;
-        if (index < m_variables.size())
-            var_sp = m_variables[index];
-        return var_sp;
-    }
-    
-    size_t
-    AddVariable (const lldb::ClangExpressionVariableSP &var_sp)
-    {
-        m_variables.push_back(var_sp);
-        return m_variables.size() - 1;
-    }
-
-    bool
-    ContainsVariable (const lldb::ClangExpressionVariableSP &var_sp)
-    {
-        const size_t size = m_variables.size();
-        for (size_t index = 0; index < size; ++index)
-        {
-            if (m_variables[index].get() == var_sp.get())
-                return true;
-        }
-        return false;
-    }
-
-    //----------------------------------------------------------------------
-    /// Finds a variable by name in the list.
-    ///
-    /// @param[in] name
-    ///     The name of the requested variable.
-    ///
-    /// @return
-    ///     The variable requested, or NULL if that variable is not in the list.
-    //----------------------------------------------------------------------
-    lldb::ClangExpressionVariableSP
-    GetVariable (const ConstString &name)
-    {
-        lldb::ClangExpressionVariableSP var_sp;
-        for (size_t index = 0, size = GetSize(); index < size; ++index)
-        {
-            var_sp = GetVariableAtIndex(index);
-            if (var_sp->GetName() == name)
-                return var_sp;
-        }
-        var_sp.reset();
-        return var_sp;
-    }
-
-    lldb::ClangExpressionVariableSP
-    GetVariable (const char *name)
-    {
-        lldb::ClangExpressionVariableSP var_sp;
-        if (name && name[0])
-        {
-            for (size_t index = 0, size = GetSize(); index < size; ++index)
-            {
-                var_sp = GetVariableAtIndex(index);
-                const char *var_name_cstr = var_sp->GetName().GetCString();
-                if (!var_name_cstr || !name)
-                    continue;
-                if (::strcmp (var_name_cstr, name) == 0)
-                    return var_sp;
-            }
-            var_sp.reset();
-        }
-        return var_sp;
-    }
-    
-    //----------------------------------------------------------------------
-    /// Finds a variable by NamedDecl in the list.
-    ///
-    /// @param[in] name
-    ///     The name of the requested variable.
-    ///
-    /// @return
-    ///     The variable requested, or NULL if that variable is not in the list.
-    //----------------------------------------------------------------------
-    lldb::ClangExpressionVariableSP
-    GetVariable (const clang::NamedDecl *decl, uint64_t parser_id)
-    {
-        lldb::ClangExpressionVariableSP var_sp;
-        for (size_t index = 0, size = GetSize(); index < size; ++index)
-        {
-            var_sp = GetVariableAtIndex(index);
-            
-            ClangExpressionVariable::ParserVars *parser_vars = var_sp->GetParserVars(parser_id);
-            
-            if (parser_vars && parser_vars->m_named_decl == decl)
-                return var_sp;
-        }
-        var_sp.reset();
-        return var_sp;
-    }
-
-    //----------------------------------------------------------------------
-    /// Create a new variable in the list and return its index
-    //----------------------------------------------------------------------
-    lldb::ClangExpressionVariableSP
-    CreateVariable (ExecutionContextScope *exe_scope, lldb::ByteOrder byte_order, uint32_t addr_byte_size)
-    {
-        lldb::ClangExpressionVariableSP var_sp(new ClangExpressionVariable(exe_scope, byte_order, addr_byte_size));
-        m_variables.push_back(var_sp);
-        return var_sp;
-    }
-
-    lldb::ClangExpressionVariableSP
-    CreateVariable(const lldb::ValueObjectSP &valobj_sp)
-    {
-        lldb::ClangExpressionVariableSP var_sp(new ClangExpressionVariable(valobj_sp));
-        m_variables.push_back(var_sp);
-        return var_sp;
-    }
-
-    lldb::ClangExpressionVariableSP
-    CreateVariable (ExecutionContextScope *exe_scope,
-                    const ConstString &name, 
-                    const TypeFromUser& user_type,
-                    lldb::ByteOrder byte_order, 
-                    uint32_t addr_byte_size)
-    {
-        lldb::ClangExpressionVariableSP var_sp(new ClangExpressionVariable(exe_scope, byte_order, addr_byte_size));
-        var_sp->SetName (name);
-        var_sp->SetCompilerType (user_type);
-        m_variables.push_back(var_sp);
-        return var_sp;
-    }
-    
-    void
-    RemoveVariable (lldb::ClangExpressionVariableSP var_sp)
-    {
-        for (std::vector<lldb::ClangExpressionVariableSP>::iterator vi = m_variables.begin(), ve = m_variables.end();
-             vi != ve;
-             ++vi)
-        {
-            if (vi->get() == var_sp.get())
-            {
-                m_variables.erase(vi);
-                return;
-            }
-        }
-    }
-    
-    void
-    Clear()
-    {
-        m_variables.clear();
-    }
-
-private:
-    std::vector <lldb::ClangExpressionVariableSP> m_variables;
-};
-
-
 } // namespace lldb_private
 
 #endif  // liblldb_ClangExpressionVariable_h_