First step of refactoring variable handling in the

expression parser.  There shouldn't be four separate
classes encapsulating a variable.

ClangExpressionVariable is now meant to be the
container for all variable information.  It has
several optional components that hold data for
different subsystems.

ClangPersistentVariable has been removed; we now
use ClangExpressionVariable instead.

llvm-svn: 111600

7 files changed, 164 insertions, 174 deletions

diff --git a/lldb/source/Commands/CommandObjectExpression.cpp b/lldb/source/Commands/CommandObjectExpression.cpp
index 12e99e26f56..af1041002b6 100644
--- a/lldb/source/Commands/CommandObjectExpression.cpp
+++ b/lldb/source/Commands/CommandObjectExpression.cpp
@@ -252,7 +252,7 @@ CommandObjectExpression::EvaluateExpression (const char *expr, bool bare, Stream
     bool success;
     bool canInterpret = false;
     
-    ClangPersistentVariable *expr_result = 0;
+    ClangExpressionVariable *expr_result = 0;
     Error expr_error;
     
     canInterpret = clang_expr.ConvertIRToDWARF (expr_local_vars, dwarf_opcodes);
diff --git a/lldb/source/Expression/ClangExpressionDeclMap.cpp b/lldb/source/Expression/ClangExpressionDeclMap.cpp
index 845d1c0d881..8cacc1fae90 100644
--- a/lldb/source/Expression/ClangExpressionDeclMap.cpp
+++ b/lldb/source/Expression/ClangExpressionDeclMap.cpp
@@ -101,14 +101,7 @@ ClangExpressionDeclMap::AddPersistentVariable (const char *name, TypeFromParser
                                                      parser_type.GetOpaqueQualType()),
                             context);
     
-    ConstString const_name(name);
-    
-    ClangPersistentVariable *pvar = m_persistent_vars->CreateVariable(const_name, user_type);
-    
-    if (!pvar)
-        return false;
-    
-    return true;
+    return m_persistent_vars->CreatePersistentVariable (name, user_type);
 }
 
 bool 
@@ -294,7 +287,7 @@ ClangExpressionDeclMap::Materialize (ExecutionContext *exe_ctx,
 
 bool 
 ClangExpressionDeclMap::Dematerialize (ExecutionContext *exe_ctx,
-                                       ClangPersistentVariable *&result,
+                                       ClangExpressionVariable *&result,
                                        Error &err)
 {
     return DoMaterialize(true, exe_ctx, &result, err);
@@ -368,7 +361,7 @@ ClangExpressionDeclMap::DumpMaterializedStruct(ExecutionContext *exe_ctx,
 bool 
 ClangExpressionDeclMap::DoMaterialize (bool dematerialize,
                                        ExecutionContext *exe_ctx,
-                                       ClangPersistentVariable **result,
+                                       ClangExpressionVariable **result,
                                        Error &err)
 {
     Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS);
@@ -451,7 +444,7 @@ ClangExpressionDeclMap::DoMaterialize (bool dematerialize,
                         if (log)
                             log->PutCString("Returning result PVar");
                         
-                        *result = m_persistent_vars->GetVariable(ConstString(m_result_name.c_str()));
+                        *result = m_persistent_vars->GetVariable(m_result_name.c_str());
                         
                         if (!*result)
                         {
@@ -506,7 +499,7 @@ ClangExpressionDeclMap::DoMaterializeOnePersistentVariable(bool dematerialize,
     if (log)
         log->Printf("Found persistent variable %s", name);
     
-    ClangPersistentVariable *pvar(m_persistent_vars->GetVariable(ConstString(name)));
+    ClangExpressionVariable *pvar(m_persistent_vars->GetVariable(name));
     
     if (!pvar)
     {
@@ -515,7 +508,11 @@ ClangExpressionDeclMap::DoMaterializeOnePersistentVariable(bool dematerialize,
     }
     
     size_t pvar_size = pvar->Size();
-    uint8_t *pvar_data = pvar->Data();                
+    
+    if (!pvar->m_data_vars.get())
+        return false;
+    
+    uint8_t *pvar_data = pvar->m_data_vars->m_data->GetBytes();               
     Error error;
     
     if (dematerialize)
@@ -779,7 +776,7 @@ ClangExpressionDeclMap::GetDecls(NameSearchContext &context,
     if (var)
         AddOneVariable(context, var);
     
-    ClangPersistentVariable *pvar(m_persistent_vars->GetVariable(ConstString(name)));
+    ClangExpressionVariable *pvar(m_persistent_vars->GetVariable(name));
     
     if (pvar)
         AddOneVariable(context, pvar);
@@ -927,9 +924,9 @@ ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
 
 void
 ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
-                                       ClangPersistentVariable *pvar)
+                                       ClangExpressionVariable *pvar)
 {
-    TypeFromUser user_type = pvar->Type();
+    TypeFromUser user_type = pvar->m_user_type;
     
     TypeFromParser parser_type(ClangASTContext::CopyType(context.GetASTContext(), 
                                                          user_type.GetASTContext(), 
diff --git a/lldb/source/Expression/ClangExpressionVariable.cpp b/lldb/source/Expression/ClangExpressionVariable.cpp
index dce0316983c..d41e6203d3b 100644
--- a/lldb/source/Expression/ClangExpressionVariable.cpp
+++ b/lldb/source/Expression/ClangExpressionVariable.cpp
@@ -14,74 +14,155 @@
 // Other libraries and framework includes
 // Project includes
 #include "clang/AST/ASTContext.h"
+#include "lldb/Core/ConstString.h"
+#include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Core/Value.h"
 
 using namespace lldb_private;
 using namespace clang;
 
-ClangExpressionVariableList::ClangExpressionVariableList() :
-    m_variables()
+ClangExpressionVariable::ClangExpressionVariable()
 {
+    m_name = "";
+    m_user_type = TypeFromUser(NULL, NULL);
+    m_parser_vars.reset(NULL);
+    m_jit_vars.reset(NULL);
+    m_data_vars.reset(NULL);
 }
 
-ClangExpressionVariableList::~ClangExpressionVariableList()
+void ClangExpressionVariable::DisableDataVars()
 {
-    uint32_t num_variables = m_variables.size();
-    uint32_t var_index;
-        
-    for (var_index = 0; var_index < num_variables; ++var_index)
-        delete m_variables[var_index].m_value;
+    if (m_data_vars.get() && m_data_vars->m_data)
+        delete m_data_vars->m_data;
+    m_data_vars.reset();
 }
 
-Value *
-ValueForDecl(const VarDecl *var_decl)
+Error
+ClangExpressionVariable::Print (Stream &output_stream,
+                                ExecutionContext &exe_ctx,
+                                lldb::Format format,
+                                bool show_types,
+                                bool show_summary,
+                                bool verbose)
 {
-    Value *ret = new Value;
-        
-    ret->SetContext(Value::eContextTypeOpaqueClangQualType, 
-                    var_decl->getType().getAsOpaquePtr());
+    Error err;
+    
+    if (!m_data_vars.get() || !m_data_vars->m_data)
+    {
+        err.SetErrorToGenericError();
+        err.SetErrorStringWithFormat("Variable doesn't contain a value");
+        return err;
+    }
+    
+    Value val;
+    
+    clang::ASTContext *ast_context = m_user_type.GetASTContext();
+    
+    val.SetContext (Value::eContextTypeOpaqueClangQualType, m_user_type.GetOpaqueQualType ());
+    val.SetValueType (Value::eValueTypeHostAddress);
+    val.GetScalar() = (uint64_t)m_data_vars->m_data->GetBytes ();
+    
+    val.ResolveValue (&exe_ctx, ast_context);
+    
+    if (val.GetContextType () == Value::eContextTypeInvalid &&
+        val.GetValueType () == Value::eValueTypeScalar &&
+        format == lldb::eFormatDefault)
+    {
+        // The expression result is just a scalar with no special formatting
+        val.GetScalar ().GetValue (&output_stream, show_types);
+        output_stream.EOL ();
+        return err;
+    }
+    
+    // The expression result is more complex and requires special handling
+    DataExtractor data;
+    Error expr_error = val.GetValueAsData (&exe_ctx, ast_context, data, 0);
+    
+    if (!expr_error.Success ())
+    {
+        err.SetErrorToGenericError ();
+        err.SetErrorStringWithFormat ("Couldn't resolve variable value: %s", expr_error.AsCString ());
+        return err;
+    }
     
-    uint64_t bit_width = var_decl->getASTContext().getTypeSize(var_decl->getType());
+    if (format == lldb::eFormatDefault)
+        format = val.GetValueDefaultFormat ();
     
-    uint32_t byte_size = (bit_width + 7 ) / 8;
+    void *clang_type = val.GetValueOpaqueClangQualType ();
     
-    ret->ResizeData(byte_size);
+    output_stream.Printf("%s = ", m_name.c_str());
     
-    return ret;
+    if (clang_type)
+    {
+        if (show_types)
+            output_stream.Printf("(%s) ", ClangASTType::GetClangTypeName (clang_type).GetCString());
+        
+        ClangASTType::DumpValue (ast_context,               // The ASTContext that the clang type belongs to
+                                 clang_type,                // The opaque clang type we want to dump that value of
+                                 &exe_ctx,                  // The execution context for memory and variable access
+                                 &output_stream,            // Stream to dump to
+                                 format,                    // Format to use when dumping
+                                 data,                      // A buffer containing the bytes for the clang type
+                                 0,                         // Byte offset within "data" where value is
+                                 data.GetByteSize (),       // Size in bytes of the value we are dumping
+                                 0,                         // Bitfield bit size
+                                 0,                         // Bitfield bit offset
+                                 show_types,                // Show types?
+                                 show_summary,              // Show summary?
+                                 verbose,                   // Debug logging output?
+                                 UINT32_MAX);               // Depth to dump in case this is an aggregate type
+    }
+    else
+    {
+        data.Dump (&output_stream,          // Stream to dump to
+                   0,                       // Byte offset within "data"
+                   format,                  // Format to use when dumping
+                   data.GetByteSize (),     // Size in bytes of each item we are dumping
+                   1,                       // Number of items to dump
+                   UINT32_MAX,              // Number of items per line
+                   LLDB_INVALID_ADDRESS,    // Invalid address, don't show any offset/address context
+                   0,                       // Bitfield bit size
+                   0);                      // Bitfield bit offset
+    }
+    
+    output_stream.EOL();
+    
+    return err;
 }
 
-Value *
-ClangExpressionVariableList::GetVariableForVarDecl (const VarDecl *var_decl, uint32_t& idx, bool can_create)
+ClangExpressionVariable::ClangExpressionVariable(const ClangExpressionVariable &cev) :
+    m_name(cev.m_name),
+    m_user_type(cev.m_user_type)
 {
-    uint32_t num_variables = m_variables.size();
-    uint32_t var_index;
-    
-    for (var_index = 0; var_index < num_variables; ++var_index)
+    if (cev.m_parser_vars.get())
     {
-        if (m_variables[var_index].m_var_decl == var_decl)
-        {
-            idx = var_index;
-            return m_variables[var_index].m_value;
-        }
+        m_parser_vars.reset(new struct ParserVars);
+        *m_parser_vars.get() = *cev.m_parser_vars.get();
     }
-
-    if (!can_create)
-        return NULL;
-    
-    idx = m_variables.size();
     
-    ClangExpressionVariable val;
-    val.m_var_decl = var_decl;
-    val.m_value = ValueForDecl(var_decl);
-    m_variables.push_back(val);
+    if (cev.m_jit_vars.get())
+    {
+        m_jit_vars.reset(new struct JITVars);
+        *m_jit_vars.get() = *cev.m_jit_vars.get();
+    }
     
-    return m_variables.back().m_value;
+    if (cev.m_data_vars.get())
+    {
+        m_data_vars.reset(new struct DataVars);
+        *m_data_vars.get() = *cev.m_data_vars.get();
+    }
 }
 
-Value *
-ClangExpressionVariableList::GetVariableAtIndex (uint32_t idx)
+bool
+ClangExpressionVariable::PointValueAtData(Value &value)
 {
-    if (idx < m_variables.size())
-        return m_variables[idx].m_value;
+    if (!m_data_vars.get())
+        return false;
+    
+    value.SetContext(Value::eContextTypeOpaqueClangQualType, m_user_type.GetOpaqueQualType());
+    value.SetValueType(Value::eValueTypeHostAddress);
+    value.GetScalar() = (uint64_t)m_data_vars->m_data->GetBytes();
     
-    return NULL;
+    return true;
 }
diff --git a/lldb/source/Expression/ClangPersistentVariables.cpp b/lldb/source/Expression/ClangPersistentVariables.cpp
index 7e1664889cc..f014811fb17 100644
--- a/lldb/source/Expression/ClangPersistentVariables.cpp
+++ b/lldb/source/Expression/ClangPersistentVariables.cpp
@@ -15,119 +15,10 @@
 
 using namespace lldb_private;
 
-Error
-ClangPersistentVariable::Print (Stream &output_stream,
-                                ExecutionContext &exe_ctx,
-                                lldb::Format format,
-                                bool show_types,
-                                bool show_summary,
-                                bool verbose)
-{
-    Error err;
-    
-    Value val;
-    
-    clang::ASTContext *ast_context = m_user_type.GetASTContext();
-    
-    val.SetContext (Value::eContextTypeOpaqueClangQualType, m_user_type.GetOpaqueQualType ());
-    val.SetValueType (Value::eValueTypeHostAddress);
-    val.GetScalar() = (uint64_t)Data ();
-    
-    val.ResolveValue (&exe_ctx, ast_context);
-    
-    if (val.GetContextType () == Value::eContextTypeInvalid &&
-        val.GetValueType () == Value::eValueTypeScalar &&
-        format == lldb::eFormatDefault)
-    {
-        // The expression result is just a scalar with no special formatting
-        val.GetScalar ().GetValue (&output_stream, show_types);
-        output_stream.EOL ();
-        return err;
-    }
-    
-    // The expression result is more complext and requires special handling
-    DataExtractor data;
-    Error expr_error = val.GetValueAsData (&exe_ctx, ast_context, data, 0);
-    
-    if (!expr_error.Success ())
-    {
-        err.SetErrorToGenericError ();
-        err.SetErrorStringWithFormat ("Couldn't resolve result value: %s", expr_error.AsCString ());
-        return err;
-    }
-    
-    if (format == lldb::eFormatDefault)
-        format = val.GetValueDefaultFormat ();
-    
-    void *clang_type = val.GetValueOpaqueClangQualType ();
-    
-    output_stream.Printf("%s = ", m_name.AsCString("<anonymous>"));
-    
-    if (clang_type)
-    {
-        if (show_types)
-            output_stream.Printf("(%s) ", ClangASTType::GetClangTypeName (clang_type).GetCString());
-        
-        ClangASTType::DumpValue (ast_context,               // The ASTContext that the clang type belongs to
-                                 clang_type,                // The opaque clang type we want to dump that value of
-                                 &exe_ctx,                  // The execution context for memory and variable access
-                                 &output_stream,            // Stream to dump to
-                                 format,                    // Format to use when dumping
-                                 data,                      // A buffer containing the bytes for the clang type
-                                 0,                         // Byte offset within "data" where value is
-                                 data.GetByteSize (),       // Size in bytes of the value we are dumping
-                                 0,                         // Bitfield bit size
-                                 0,                         // Bitfield bit offset
-                                 show_types,                // Show types?
-                                 show_summary,              // Show summary?
-                                 verbose,                   // Debug logging output?
-                                 UINT32_MAX);               // Depth to dump in case this is an aggregate type
-    }
-    else
-    {
-        data.Dump (&output_stream,          // Stream to dump to
-                   0,                       // Byte offset within "data"
-                   format,                  // Format to use when dumping
-                   data.GetByteSize (),     // Size in bytes of each item we are dumping
-                   1,                       // Number of items to dump
-                   UINT32_MAX,              // Number of items per line
-                   LLDB_INVALID_ADDRESS,    // Invalid address, don't show any offset/address context
-                   0,                       // Bitfield bit size
-                   0);                      // Bitfield bit offset
-    }
-    
-    output_stream.EOL();
-    
-    return err;
-}
-
 ClangPersistentVariables::ClangPersistentVariables () :
-    m_variables(),
-    m_result_counter(0)
+    ClangExpressionVariableStore()
 {
-}
-
-ClangPersistentVariable *
-ClangPersistentVariables::CreateVariable (ConstString name, 
-                                          TypeFromUser user_type)
-{    
-    ClangPersistentVariable new_var(name, user_type);
-    
-    if (m_variables.find(name) != m_variables.end())
-        return NULL;
-    
-    m_variables[name] = new_var;
-    
-    return &m_variables[name];
-}
-
-ClangPersistentVariable *
-ClangPersistentVariables::GetVariable (ConstString name)
-{    
-    if (m_variables.find(name) == m_variables.end())
-        return NULL;
-    
-    return &m_variables[name];
+    m_result_counter = 0;
 }
 
 void
@@ -140,3 +31,22 @@ ClangPersistentVariables::GetNextResultName (std::string &name)
     
     name = s.GetString();
 }
+
+bool
+ClangPersistentVariables::CreatePersistentVariable(const char   *name,
+                                                   TypeFromUser  user_type)
+{
+    if (GetVariable(name))
+            return false;
+
+    ClangExpressionVariable &pvar (VariableAtIndex(CreateVariable()));
+
+    pvar.m_name = name;
+    pvar.m_user_type = user_type;
+
+    pvar.EnableDataVars();
+    
+    pvar.m_data_vars->m_data = new DataBufferHeap(pvar.Size(), 0);
+    
+    return true;
+}
\ No newline at end of file
diff --git a/lldb/source/Expression/DWARFExpression.cpp b/lldb/source/Expression/DWARFExpression.cpp
index 9609cad3731..ae6a903c968 100644
--- a/lldb/source/Expression/DWARFExpression.cpp
+++ b/lldb/source/Expression/DWARFExpression.cpp
@@ -2435,6 +2435,7 @@ DWARFExpression::Evaluate
         //----------------------------------------------------------------------
         case DW_OP_APPLE_expr_local:
             {
+                /*
                 uint32_t idx = opcodes.GetULEB128(&offset);
                 if (expr_locals == NULL)
                 {
@@ -2453,6 +2454,7 @@ DWARFExpression::Evaluate
                 stack.push_back(*proxy);
                 delete proxy;
                 //stack.back().SetContext (Value::eContextTypeOpaqueClangQualType, expr_local_variable->GetOpaqueClangQualType());
+                */
             }
             break;
 
diff --git a/lldb/source/Expression/IRForTarget.cpp b/lldb/source/Expression/IRForTarget.cpp
index c3fce6fbbb0..2c0f86c4120 100644
--- a/lldb/source/Expression/IRForTarget.cpp
+++ b/lldb/source/Expression/IRForTarget.cpp
@@ -32,7 +32,7 @@ static char ID;
 
 IRForTarget::IRForTarget(lldb_private::ClangExpressionDeclMap *decl_map,
                          const TargetData *target_data) :
-    ModulePass(ID),
+    ModulePass(&ID),
     m_decl_map(decl_map),
     m_target_data(target_data),
     m_sel_registerName(NULL)
diff --git a/lldb/source/Expression/IRToDWARF.cpp b/lldb/source/Expression/IRToDWARF.cpp
index db38e8e53d2..121a47c171e 100644
--- a/lldb/source/Expression/IRToDWARF.cpp
+++ b/lldb/source/Expression/IRToDWARF.cpp
@@ -29,7 +29,7 @@ static char ID;
 IRToDWARF::IRToDWARF(lldb_private::ClangExpressionVariableList &variable_list, 
                      lldb_private::ClangExpressionDeclMap *decl_map,
                      lldb_private::StreamString &strm) :
-    ModulePass(ID),
+    ModulePass(&ID),
     m_variable_list(variable_list),
     m_decl_map(decl_map),
     m_strm(strm)