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

15 files changed, 223 insertions, 456 deletions

diff --git a/lldb/source/API/SBFrame.cpp b/lldb/source/API/SBFrame.cpp
index 08a5822cb78..c1aecf8e1cc 100644
--- a/lldb/source/API/SBFrame.cpp
+++ b/lldb/source/API/SBFrame.cpp
@@ -956,7 +956,7 @@ SBFrame::FindValue (const char *name, ValueType value_type, lldb::DynamicValueTy
                 case eValueTypeConstResult:         // constant result variables
                     {
                         ConstString const_name(name);
-                        ClangExpressionVariableSP expr_var_sp (target->GetPersistentVariables().GetVariable (const_name));
+                        ExpressionVariableSP expr_var_sp (target->GetPersistentVariables().GetVariable (const_name));
                         if (expr_var_sp)
                         {
                             value_sp = expr_var_sp->GetValueObject();
diff --git a/lldb/source/Breakpoint/BreakpointLocation.cpp b/lldb/source/Breakpoint/BreakpointLocation.cpp
index a199d390803..1d082f69416 100644
--- a/lldb/source/Breakpoint/BreakpointLocation.cpp
+++ b/lldb/source/Breakpoint/BreakpointLocation.cpp
@@ -314,7 +314,7 @@ BreakpointLocation::ConditionSaysStop (ExecutionContext &exe_ctx, Error &error)
     
     StreamString execution_errors;
     
-    ClangExpressionVariableSP result_variable_sp;
+    ExpressionVariableSP result_variable_sp;
     
     ExpressionResults result_code =
     m_user_expression_sp->Execute(execution_errors,
diff --git a/lldb/source/Core/FormatEntity.cpp b/lldb/source/Core/FormatEntity.cpp
index ee9ccf4549b..73d799fcd2d 100644
--- a/lldb/source/Core/FormatEntity.cpp
+++ b/lldb/source/Core/FormatEntity.cpp
@@ -1437,7 +1437,7 @@ FormatEntity::Format (const Entry &entry,
                     StopInfoSP stop_info_sp = thread->GetStopInfo ();
                     if (stop_info_sp && stop_info_sp->IsValid())
                     {
-                        ClangExpressionVariableSP expression_var_sp = StopInfo::GetExpressionVariable (stop_info_sp);
+                        ExpressionVariableSP expression_var_sp = StopInfo::GetExpressionVariable (stop_info_sp);
                         if (expression_var_sp && expression_var_sp->GetValueObject())
                         {
                             expression_var_sp->GetValueObject()->Dump(s);
diff --git a/lldb/source/Core/ValueObject.cpp b/lldb/source/Core/ValueObject.cpp
index e66d6d0d086..85305a00ae7 100644
--- a/lldb/source/Core/ValueObject.cpp
+++ b/lldb/source/Core/ValueObject.cpp
@@ -4280,7 +4280,7 @@ ValueObject::Persist ()
     
     ConstString name(target_sp->GetPersistentVariables().GetNextPersistentVariableName());
     
-    ClangExpressionVariableSP clang_var_sp(new ClangExpressionVariable(target_sp.get(), GetValue(), name));
+    ExpressionVariableSP clang_var_sp(new ClangExpressionVariable(target_sp.get(), GetValue(), name));
     if (clang_var_sp)
     {
         clang_var_sp->m_live_sp = clang_var_sp->m_frozen_sp;
diff --git a/lldb/source/Expression/ClangExpressionDeclMap.cpp b/lldb/source/Expression/ClangExpressionDeclMap.cpp
index 4e12c6642c8..cba1122038a 100644
--- a/lldb/source/Expression/ClangExpressionDeclMap.cpp
+++ b/lldb/source/Expression/ClangExpressionDeclMap.cpp
@@ -134,18 +134,18 @@ ClangExpressionDeclMap::DidParse()
              entity_index < num_entities;
              ++entity_index)
         {
-            ClangExpressionVariableSP var_sp(m_found_entities.GetVariableAtIndex(entity_index));
+            ExpressionVariableSP var_sp(m_found_entities.GetVariableAtIndex(entity_index));
             if (var_sp)
-                var_sp->DisableParserVars(GetParserID());
+                var_sp->AsClangExpressionVariable()->DisableParserVars(GetParserID());
         }
 
         for (size_t pvar_index = 0, num_pvars = m_parser_vars->m_persistent_vars->GetSize();
              pvar_index < num_pvars;
              ++pvar_index)
         {
-            ClangExpressionVariableSP pvar_sp(m_parser_vars->m_persistent_vars->GetVariableAtIndex(pvar_index));
+            ExpressionVariableSP pvar_sp(m_parser_vars->m_persistent_vars->GetVariableAtIndex(pvar_index));
             if (pvar_sp)
-                pvar_sp->DisableParserVars(GetParserID());
+                pvar_sp->AsClangExpressionVariable()->DisableParserVars(GetParserID());
         }
 
         DisableParserVars();
@@ -212,25 +212,26 @@ ClangExpressionDeclMap::AddPersistentVariable
 
         uint32_t offset = m_parser_vars->m_materializer->AddResultVariable(user_type, is_lvalue, m_keep_result_in_memory, err);
 
-        ClangExpressionVariableSP var_sp = m_found_entities.CreateVariable(exe_ctx.GetBestExecutionContextScope(),
-                                                                           name,
-                                                                           user_type,
-                                                                           m_parser_vars->m_target_info.byte_order,
-                                                                           m_parser_vars->m_target_info.address_byte_size);
+        ClangExpressionVariable *var = ClangExpressionVariable::CreateVariableInList(m_found_entities,
+                                                                                     exe_ctx.GetBestExecutionContextScope(),
+                                                                                     name,
+                                                                                     user_type,
+                                                                                     m_parser_vars->m_target_info.byte_order,
+                                                                                     m_parser_vars->m_target_info.address_byte_size);
 
-        if (!var_sp)
+        if (!var)
             return false;
 
-        var_sp->EnableParserVars(GetParserID());
+        var->EnableParserVars(GetParserID());
 
-        ClangExpressionVariable::ParserVars *parser_vars = var_sp->GetParserVars(GetParserID());
+        ClangExpressionVariable::ParserVars *parser_vars = var->GetParserVars(GetParserID());
 
         parser_vars->m_named_decl = decl;
         parser_vars->m_parser_type = parser_type;
 
-        var_sp->EnableJITVars(GetParserID());
+        var->EnableJITVars(GetParserID());
 
-        ClangExpressionVariable::JITVars *jit_vars = var_sp->GetJITVars(GetParserID());
+        ClangExpressionVariable::JITVars *jit_vars = var->GetJITVars(GetParserID());
 
         jit_vars->m_offset = offset;
 
@@ -260,43 +261,43 @@ ClangExpressionDeclMap::AddPersistentVariable
     if (!m_parser_vars->m_target_info.IsValid())
         return false;
 
-    ClangExpressionVariableSP var_sp = m_parser_vars->m_persistent_vars->CreatePersistentVariable (exe_ctx.GetBestExecutionContextScope (),
-                                                                                                   name,
-                                                                                                   user_type,
-                                                                                                   m_parser_vars->m_target_info.byte_order,
-                                                                                                   m_parser_vars->m_target_info.address_byte_size);
+    ClangExpressionVariable *var = m_parser_vars->m_persistent_vars->CreatePersistentVariable (exe_ctx.GetBestExecutionContextScope (),
+                                                                                               name,
+                                                                                               user_type,
+                                                                                               m_parser_vars->m_target_info.byte_order,
+                                                                                               m_parser_vars->m_target_info.address_byte_size);
 
-    if (!var_sp)
+    if (!var)
         return false;
 
-    var_sp->m_frozen_sp->SetHasCompleteType();
+    var->m_frozen_sp->SetHasCompleteType();
 
     if (is_result)
-        var_sp->m_flags |= ClangExpressionVariable::EVNeedsFreezeDry;
+        var->m_flags |= ClangExpressionVariable::EVNeedsFreezeDry;
     else
-        var_sp->m_flags |= ClangExpressionVariable::EVKeepInTarget; // explicitly-declared persistent variables should persist
+        var->m_flags |= ClangExpressionVariable::EVKeepInTarget; // explicitly-declared persistent variables should persist
 
     if (is_lvalue)
     {
-        var_sp->m_flags |= ClangExpressionVariable::EVIsProgramReference;
+        var->m_flags |= ClangExpressionVariable::EVIsProgramReference;
     }
     else
     {
-        var_sp->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
-        var_sp->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
+        var->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
+        var->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
     }
 
     if (m_keep_result_in_memory)
     {
-        var_sp->m_flags |= ClangExpressionVariable::EVKeepInTarget;
+        var->m_flags |= ClangExpressionVariable::EVKeepInTarget;
     }
 
     if (log)
-        log->Printf("Created persistent variable with flags 0x%hx", var_sp->m_flags);
+        log->Printf("Created persistent variable with flags 0x%hx", var->m_flags);
 
-    var_sp->EnableParserVars(GetParserID());
+    var->EnableParserVars(GetParserID());
 
-    ClangExpressionVariable::ParserVars *parser_vars = var_sp->GetParserVars(GetParserID());
+    ClangExpressionVariable::ParserVars *parser_vars = var->GetParserVars(GetParserID());
 
     parser_vars->m_named_decl = decl;
     parser_vars->m_parser_type = parser_type;
@@ -323,33 +324,33 @@ ClangExpressionDeclMap::AddValueToStruct
 
     m_struct_vars->m_struct_laid_out = false;
 
-    if (m_struct_members.GetVariable(decl, GetParserID()))
+    if (ClangExpressionVariable::FindVariableInList(m_struct_members, decl, GetParserID()))
         return true;
 
-    ClangExpressionVariableSP var_sp (m_found_entities.GetVariable(decl, GetParserID()));
+    ClangExpressionVariable *var(ClangExpressionVariable::FindVariableInList(m_found_entities, decl, GetParserID()));
 
-    if (!var_sp)
+    if (!var)
     {
-        var_sp = m_parser_vars->m_persistent_vars->GetVariable(decl, GetParserID());
+        var = ClangExpressionVariable::FindVariableInList(*m_parser_vars->m_persistent_vars, decl, GetParserID());
         is_persistent_variable = true;
     }
 
-    if (!var_sp)
+    if (!var)
         return false;
 
     if (log)
         log->Printf("Adding value for (NamedDecl*)%p [%s - %s] to the structure",
                     static_cast<const void*>(decl), name.GetCString(),
-                    var_sp->GetName().GetCString());
+                    var->GetName().GetCString());
 
     // We know entity->m_parser_vars is valid because we used a parser variable
     // to find it
 
-    ClangExpressionVariable::ParserVars *parser_vars = var_sp->GetParserVars(GetParserID());
+    ClangExpressionVariable::ParserVars *parser_vars = var->AsClangExpressionVariable()->GetParserVars(GetParserID());
 
     parser_vars->m_llvm_value = value;
 
-    if (ClangExpressionVariable::JITVars *jit_vars = var_sp->GetJITVars(GetParserID()))
+    if (ClangExpressionVariable::JITVars *jit_vars = var->AsClangExpressionVariable()->GetJITVars(GetParserID()))
     {
         // We already laid this out; do not touch
 
@@ -357,14 +358,14 @@ ClangExpressionDeclMap::AddValueToStruct
             log->Printf("Already placed at 0x%llx", (unsigned long long)jit_vars->m_offset);
     }
 
-    var_sp->EnableJITVars(GetParserID());
+    var->AsClangExpressionVariable()->EnableJITVars(GetParserID());
 
-    ClangExpressionVariable::JITVars *jit_vars = var_sp->GetJITVars(GetParserID());
+    ClangExpressionVariable::JITVars *jit_vars = var->AsClangExpressionVariable()->GetJITVars(GetParserID());
 
     jit_vars->m_alignment = alignment;
     jit_vars->m_size = size;
 
-    m_struct_members.AddVariable(var_sp);
+    m_struct_members.AddVariable(var->shared_from_this());
 
     if (m_parser_vars->m_materializer)
     {
@@ -374,13 +375,14 @@ ClangExpressionDeclMap::AddValueToStruct
 
         if (is_persistent_variable)
         {
+            ExpressionVariableSP var_sp(var->shared_from_this());
             offset = m_parser_vars->m_materializer->AddPersistentVariable(var_sp, err);
         }
         else
         {
             if (const lldb_private::Symbol *sym = parser_vars->m_lldb_sym)
                 offset = m_parser_vars->m_materializer->AddSymbol(*sym, err);
-            else if (const RegisterInfo *reg_info = var_sp->GetRegisterInfo())
+            else if (const RegisterInfo *reg_info = var->GetRegisterInfo())
                 offset = m_parser_vars->m_materializer->AddRegister(*reg_info, err);
             else if (parser_vars->m_lldb_var)
                 offset = m_parser_vars->m_materializer->AddVariable(parser_vars->m_lldb_var, err);
@@ -452,13 +454,13 @@ ClangExpressionDeclMap::GetStructElement
     if (index >= m_struct_members.GetSize())
         return false;
 
-    ClangExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(index));
+    ExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(index));
 
     if (!member_sp)
         return false;
 
-    ClangExpressionVariable::ParserVars *parser_vars = member_sp->GetParserVars(GetParserID());
-    ClangExpressionVariable::JITVars *jit_vars = member_sp->GetJITVars(GetParserID());
+    ClangExpressionVariable::ParserVars *parser_vars = member_sp->AsClangExpressionVariable()->GetParserVars(GetParserID());
+    ClangExpressionVariable::JITVars *jit_vars = member_sp->AsClangExpressionVariable()->GetJITVars(GetParserID());
 
     if (!parser_vars ||
         !jit_vars ||
@@ -480,15 +482,15 @@ ClangExpressionDeclMap::GetFunctionInfo
     uint64_t &ptr
 )
 {
-    ClangExpressionVariableSP entity_sp(m_found_entities.GetVariable(decl, GetParserID()));
+    ClangExpressionVariable *entity(ClangExpressionVariable::FindVariableInList(m_found_entities, decl, GetParserID()));
 
-    if (!entity_sp)
+    if (!entity)
         return false;
 
     // We know m_parser_vars is valid since we searched for the variable by
     // its NamedDecl
 
-    ClangExpressionVariable::ParserVars *parser_vars = entity_sp->GetParserVars(GetParserID());
+    ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
 
     ptr = parser_vars->m_lldb_value.GetScalar().ULongLong();
 
@@ -1315,7 +1317,7 @@ ClangExpressionDeclMap::FindExternalVisibleDecls (NameSearchContext &context,
             context.AddNamedDecl(parser_ptype_type_decl);
         } while (0);
 
-        ClangExpressionVariableSP pvar_sp(m_parser_vars->m_persistent_vars->GetVariable(name));
+        ExpressionVariableSP pvar_sp(m_parser_vars->m_persistent_vars->GetVariable(name));
 
         if (pvar_sp)
         {
@@ -1771,9 +1773,9 @@ ClangExpressionDeclMap::AddOneVariable (NameSearchContext &context, VariableSP v
 
     std::string decl_name(context.m_decl_name.getAsString());
     ConstString entity_name(decl_name.c_str());
-    ClangExpressionVariableSP entity(m_found_entities.CreateVariable (valobj));
+    ClangExpressionVariable *entity(ClangExpressionVariable::CreateVariableInList(m_found_entities, valobj));
 
-    assert (entity.get());
+    assert (entity);
     entity->EnableParserVars(GetParserID());
     ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
     parser_vars->m_parser_type = pt;
@@ -1795,12 +1797,12 @@ ClangExpressionDeclMap::AddOneVariable (NameSearchContext &context, VariableSP v
 
 void
 ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
-                                       ClangExpressionVariableSP &pvar_sp,
+                                       ExpressionVariableSP &pvar_sp,
                                        unsigned int current_id)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 
-    TypeFromUser user_type (pvar_sp->GetTypeFromUser());
+    TypeFromUser user_type (pvar_sp->AsClangExpressionVariable()->GetTypeFromUser());
 
     TypeFromParser parser_type (GuardedCopyType(user_type));
 
@@ -1813,8 +1815,8 @@ ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
 
     NamedDecl *var_decl = context.AddVarDecl(ClangASTContext::GetLValueReferenceType(parser_type));
 
-    pvar_sp->EnableParserVars(GetParserID());
-    ClangExpressionVariable::ParserVars *parser_vars = pvar_sp->GetParserVars(GetParserID());
+    pvar_sp->AsClangExpressionVariable()->EnableParserVars(GetParserID());
+    ClangExpressionVariable::ParserVars *parser_vars = pvar_sp->AsClangExpressionVariable()->GetParserVars(GetParserID());
     parser_vars->m_parser_type = parser_type;
     parser_vars->m_named_decl = var_decl;
     parser_vars->m_llvm_value = NULL;
@@ -1849,12 +1851,13 @@ ClangExpressionDeclMap::AddOneGenericVariable(NameSearchContext &context,
 
     std::string decl_name(context.m_decl_name.getAsString());
     ConstString entity_name(decl_name.c_str());
-    ClangExpressionVariableSP entity(m_found_entities.CreateVariable (m_parser_vars->m_exe_ctx.GetBestExecutionContextScope (),
-                                                                      entity_name,
-                                                                      user_type,
-                                                                      m_parser_vars->m_target_info.byte_order,
-                                                                      m_parser_vars->m_target_info.address_byte_size));
-    assert (entity.get());
+    ClangExpressionVariable *entity(ClangExpressionVariable::CreateVariableInList(m_found_entities,
+                                                                                  m_parser_vars->m_exe_ctx.GetBestExecutionContextScope (),
+                                                                                  entity_name,
+                                                                                  user_type,
+                                                                                  m_parser_vars->m_target_info.byte_order,
+                                                                                  m_parser_vars->m_target_info.address_byte_size));
+    assert (entity);
 
     entity->EnableParserVars(GetParserID());
     ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
@@ -1892,9 +1895,9 @@ ClangExpressionDeclMap::ResolveUnknownTypes()
          index < num_entities;
          ++index)
     {
-        ClangExpressionVariableSP entity = m_found_entities.GetVariableAtIndex(index);
+        ExpressionVariableSP entity = m_found_entities.GetVariableAtIndex(index);
 
-        ClangExpressionVariable::ParserVars *parser_vars = entity->GetParserVars(GetParserID());
+        ClangExpressionVariable::ParserVars *parser_vars = entity->AsClangExpressionVariable()->GetParserVars(GetParserID());
 
         if (entity->m_flags & ClangExpressionVariable::EVUnknownType)
         {
@@ -1924,7 +1927,7 @@ ClangExpressionDeclMap::ResolveUnknownTypes()
                 if (log)
                     log->Printf("ClangExpressionDeclMap::ResolveUnknownType - Couldn't import the type for a variable");
 
-                return (bool) lldb::ClangExpressionVariableSP();
+                return (bool) lldb::ExpressionVariableSP();
             }
 
             TypeFromUser user_type(copied_type, scratch_ast_context);
@@ -1964,10 +1967,11 @@ ClangExpressionDeclMap::AddOneRegister (NameSearchContext &context,
 
     NamedDecl *var_decl = context.AddVarDecl(parser_clang_type);
 
-    ClangExpressionVariableSP entity(m_found_entities.CreateVariable (m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
-                                                                      m_parser_vars->m_target_info.byte_order,
-                                                                      m_parser_vars->m_target_info.address_byte_size));
-    assert (entity.get());
+    ClangExpressionVariable *entity(ClangExpressionVariable::CreateVariableInList(m_found_entities,
+                                                                                  m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
+                                                                                  m_parser_vars->m_target_info.byte_order,
+                                                                                  m_parser_vars->m_target_info.address_byte_size));
+    assert (entity);
 
     std::string decl_name(context.m_decl_name.getAsString());
     entity->SetName (ConstString (decl_name.c_str()));
@@ -2072,10 +2076,11 @@ ClangExpressionDeclMap::AddOneFunction (NameSearchContext &context,
 
     lldb::addr_t load_addr = fun_address.GetCallableLoadAddress(target, is_indirect_function);
 
-    ClangExpressionVariableSP entity(m_found_entities.CreateVariable (m_parser_vars->m_exe_ctx.GetBestExecutionContextScope (),
-                                                                      m_parser_vars->m_target_info.byte_order,
-                                                                      m_parser_vars->m_target_info.address_byte_size));
-    assert (entity.get());
+    ClangExpressionVariable *entity(ClangExpressionVariable::CreateVariableInList (m_found_entities,
+                                                                                   m_parser_vars->m_exe_ctx.GetBestExecutionContextScope (),
+                                                                                   m_parser_vars->m_target_info.byte_order,
+                                                                                   m_parser_vars->m_target_info.address_byte_size));
+    assert (entity);
 
     std::string decl_name(context.m_decl_name.getAsString());
     entity->SetName(ConstString(decl_name.c_str()));
diff --git a/lldb/source/Expression/ClangPersistentVariables.cpp b/lldb/source/Expression/ClangPersistentVariables.cpp
index db062d2e20b..13859b81ac8 100644
--- a/lldb/source/Expression/ClangPersistentVariables.cpp
+++ b/lldb/source/Expression/ClangPersistentVariables.cpp
@@ -19,35 +19,29 @@ using namespace lldb;
 using namespace lldb_private;
 
 ClangPersistentVariables::ClangPersistentVariables () :
-    ClangExpressionVariableList(),
+    ExpressionVariableList(),
     m_next_persistent_variable_id (0)
 {
 }
 
-ClangExpressionVariableSP
+ExpressionVariableSP
 ClangPersistentVariables::CreatePersistentVariable (const lldb::ValueObjectSP &valobj_sp)
 {
-    ClangExpressionVariableSP var_sp (CreateVariable(valobj_sp));
-    return var_sp;
+    return ClangExpressionVariable::CreateVariableInList(*this, valobj_sp)->shared_from_this();
 }
 
-ClangExpressionVariableSP
+ClangExpressionVariable *
 ClangPersistentVariables::CreatePersistentVariable (ExecutionContextScope *exe_scope, 
                                                     const ConstString &name, 
                                                     const TypeFromUser& user_type, 
                                                     lldb::ByteOrder byte_order, 
                                                     uint32_t addr_byte_size)
 {
-    ClangExpressionVariableSP var_sp (GetVariable(name));
-    
-    if (!var_sp)
-        var_sp = CreateVariable(exe_scope, name, user_type, byte_order, addr_byte_size);
-
-    return var_sp;
+    return ClangExpressionVariable::CreateVariableInList(*this, exe_scope, name, user_type, byte_order, addr_byte_size);
 }
 
 void
-ClangPersistentVariables::RemovePersistentVariable (lldb::ClangExpressionVariableSP variable)
+ClangPersistentVariables::RemovePersistentVariable (lldb::ExpressionVariableSP variable)
 {
     RemoveVariable(variable);
     
diff --git a/lldb/source/Expression/ClangUserExpression.cpp b/lldb/source/Expression/ClangUserExpression.cpp
index b479213ff52..9239389753e 100644
--- a/lldb/source/Expression/ClangUserExpression.cpp
+++ b/lldb/source/Expression/ClangUserExpression.cpp
@@ -797,7 +797,7 @@ ClangUserExpression::PrepareToExecuteJITExpression (Stream &error_stream,
 bool
 ClangUserExpression::FinalizeJITExecution (Stream &error_stream,
                                            ExecutionContext &exe_ctx,
-                                           lldb::ClangExpressionVariableSP &result,
+                                           lldb::ExpressionVariableSP &result,
                                            lldb::addr_t function_stack_bottom,
                                            lldb::addr_t function_stack_top)
 {
@@ -835,7 +835,7 @@ ClangUserExpression::Execute (Stream &error_stream,
                               ExecutionContext &exe_ctx,
                               const EvaluateExpressionOptions& options,
                               lldb::ClangUserExpressionSP &shared_ptr_to_me,
-                              lldb::ClangExpressionVariableSP &result)
+                              lldb::ExpressionVariableSP &result)
 {
     // The expression log is quite verbose, and if you're just tracking the execution of the
     // expression, it's quite convenient to have these logs come out with the STEP log as well.
@@ -1090,7 +1090,7 @@ ClangUserExpression::Evaluate (ExecutionContext &exe_ctx,
     }
     else
     {
-        lldb::ClangExpressionVariableSP expr_result;
+        lldb::ExpressionVariableSP expr_result;
 
         if (execution_policy == eExecutionPolicyNever &&
             !user_expression_sp->CanInterpret())
diff --git a/lldb/source/Expression/ExpressionVariable.cpp b/lldb/source/Expression/ExpressionVariable.cpp
index baeacc48762..1f289b72f48 100644
--- a/lldb/source/Expression/ExpressionVariable.cpp
+++ b/lldb/source/Expression/ExpressionVariable.cpp
@@ -9,3 +9,24 @@
 
 #include "lldb/Expression/ExpressionVariable.h"
 
+using namespace lldb_private;
+
+ExpressionVariable::~ExpressionVariable()
+{
+}
+
+uint8_t *
+ExpressionVariable::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;
+}
diff --git a/lldb/source/Expression/Materializer.cpp b/lldb/source/Expression/Materializer.cpp
index 113ee378194..71467d86870 100644
--- a/lldb/source/Expression/Materializer.cpp
+++ b/lldb/source/Expression/Materializer.cpp
@@ -66,7 +66,7 @@ Materializer::Entity::SetSizeAndAlignmentFromType (CompilerType &type)
 class EntityPersistentVariable : public Materializer::Entity
 {
 public:
-    EntityPersistentVariable (lldb::ClangExpressionVariableSP &persistent_variable_sp) :
+    EntityPersistentVariable (lldb::ExpressionVariableSP &persistent_variable_sp) :
         Entity(),
         m_persistent_variable_sp(persistent_variable_sp)
     {
@@ -99,9 +99,9 @@ public:
             log->Printf("Allocated %s (0x%" PRIx64 ") successfully", m_persistent_variable_sp->GetName().GetCString(), mem);
         
         // Put the location of the spare memory into the live data of the ValueObject.
-                
+        
         m_persistent_variable_sp->m_live_sp = ValueObjectConstResult::Create (map.GetBestExecutionContextScope(),
-                                                                              m_persistent_variable_sp->GetTypeFromUser(),
+                                                                              m_persistent_variable_sp->AsClangExpressionVariable()->GetTypeFromUser(),
                                                                               m_persistent_variable_sp->GetName(),
                                                                               mem,
                                                                               eAddressTypeLoad,
@@ -230,9 +230,9 @@ public:
                     err.SetErrorStringWithFormat("couldn't read the address of program-allocated variable %s: %s", m_persistent_variable_sp->GetName().GetCString(), read_error.AsCString());
                     return;
                 }
-                                
+                
                 m_persistent_variable_sp->m_live_sp = ValueObjectConstResult::Create (map.GetBestExecutionContextScope (),
-                                                                                      m_persistent_variable_sp->GetTypeFromUser(),
+                                                                                      m_persistent_variable_sp->AsClangExpressionVariable()->GetTypeFromUser(),
                                                                                       m_persistent_variable_sp->GetName(),
                                                                                       location,
                                                                                       eAddressTypeLoad,
@@ -390,11 +390,11 @@ public:
     {
     }
 private:
-    lldb::ClangExpressionVariableSP m_persistent_variable_sp;
+    lldb::ExpressionVariableSP m_persistent_variable_sp;
 };
 
 uint32_t
-Materializer::AddPersistentVariable (lldb::ClangExpressionVariableSP &persistent_variable_sp, Error &err)
+Materializer::AddPersistentVariable (lldb::ExpressionVariableSP &persistent_variable_sp, Error &err)
 {
     EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
     iter->reset (new EntityPersistentVariable (persistent_variable_sp));
@@ -820,7 +820,7 @@ public:
         err.SetErrorString("Tried to detmaterialize a result variable with the normal Dematerialize method");
     }
     
-    void Dematerialize (lldb::ClangExpressionVariableSP &result_variable_sp,
+    void Dematerialize (lldb::ExpressionVariableSP &result_variable_sp,
                         lldb::StackFrameSP &frame_sp,
                         IRMemoryMap &map,
                         lldb::addr_t process_address,
@@ -860,13 +860,12 @@ public:
         
         ConstString name = target_sp->GetPersistentVariables().GetNextPersistentVariableName();
         
-        lldb::ClangExpressionVariableSP ret;
-        
-        ret = target_sp->GetPersistentVariables().CreateVariable(exe_scope,
-                                                                 name,
-                                                                 m_type,
-                                                                 map.GetByteOrder(),
-                                                                 map.GetAddressByteSize());
+        lldb::ExpressionVariableSP ret = ClangExpressionVariable::CreateVariableInList(target_sp->GetPersistentVariables(),
+                                                                                       exe_scope,
+                                                                                       name,
+                                                                                       m_type,
+                                                                                       map.GetByteOrder(),
+                                                                                       map.GetAddressByteSize())->shared_from_this();
         
         if (!ret)
         {
@@ -1395,7 +1394,7 @@ Materializer::Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb:
 }
 
 void
-Materializer::Dematerializer::Dematerialize (Error &error, lldb::ClangExpressionVariableSP &result_sp, lldb::addr_t frame_bottom, lldb::addr_t frame_top)
+Materializer::Dematerializer::Dematerialize (Error &error, lldb::ExpressionVariableSP &result_sp, lldb::addr_t frame_bottom, lldb::addr_t frame_top)
 {
     lldb::StackFrameSP frame_sp;
 
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_
diff --git a/lldb/source/Target/ABI.cpp b/lldb/source/Target/ABI.cpp
index 63b22c97166..f5df97c9c50 100644
--- a/lldb/source/Target/ABI.cpp
+++ b/lldb/source/Target/ABI.cpp
@@ -141,7 +141,7 @@ ABI::GetReturnValueObject (Thread &thread,
         
         return_valobj_sp = const_valobj_sp;
 
-        ClangExpressionVariableSP clang_expr_variable_sp(persistent_variables.CreatePersistentVariable(return_valobj_sp));
+        ExpressionVariableSP clang_expr_variable_sp(persistent_variables.CreatePersistentVariable(return_valobj_sp));
                
         assert (clang_expr_variable_sp.get());
         
diff --git a/lldb/source/Target/StopInfo.cpp b/lldb/source/Target/StopInfo.cpp
index ed8025fc235..00fd79aa8fd 100644
--- a/lldb/source/Target/StopInfo.cpp
+++ b/lldb/source/Target/StopInfo.cpp
@@ -1054,7 +1054,7 @@ class StopInfoThreadPlan : public StopInfo
 {
 public:
 
-    StopInfoThreadPlan (ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp, ClangExpressionVariableSP &expression_variable_sp) :
+    StopInfoThreadPlan (ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp, ExpressionVariableSP &expression_variable_sp) :
         StopInfo (plan_sp->GetThread(), LLDB_INVALID_UID),
         m_plan_sp (plan_sp),
         m_return_valobj_sp (return_valobj_sp),
@@ -1090,7 +1090,7 @@ public:
         return m_return_valobj_sp;
     }
     
-    ClangExpressionVariableSP
+    ExpressionVariableSP
     GetExpressionVariable()
     {
         return m_expression_variable_sp;
@@ -1109,7 +1109,7 @@ protected:
 private:
     ThreadPlanSP m_plan_sp;
     ValueObjectSP m_return_valobj_sp;
-    ClangExpressionVariableSP m_expression_variable_sp;
+    ExpressionVariableSP m_expression_variable_sp;
 };
     
 class StopInfoExec : public StopInfo
@@ -1190,7 +1190,7 @@ StopInfo::CreateStopReasonToTrace (Thread &thread)
 StopInfoSP
 StopInfo::CreateStopReasonWithPlan (ThreadPlanSP &plan_sp,
                                     ValueObjectSP return_valobj_sp,
-                                    ClangExpressionVariableSP expression_variable_sp)
+                                    ExpressionVariableSP expression_variable_sp)
 {
     return StopInfoSP (new StopInfoThreadPlan (plan_sp, return_valobj_sp, expression_variable_sp));
 }
@@ -1219,7 +1219,7 @@ StopInfo::GetReturnValueObject(StopInfoSP &stop_info_sp)
         return ValueObjectSP();
 }
 
-ClangExpressionVariableSP
+ExpressionVariableSP
 StopInfo::GetExpressionVariable(StopInfoSP &stop_info_sp)
 {
     if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonPlanComplete)
@@ -1228,5 +1228,5 @@ StopInfo::GetExpressionVariable(StopInfoSP &stop_info_sp)
         return plan_stop_info->GetExpressionVariable();
     }
     else
-        return ClangExpressionVariableSP();
+        return ExpressionVariableSP();
 }
diff --git a/lldb/source/Target/Target.cpp b/lldb/source/Target/Target.cpp
index ecb1895bcee..d58df596b4d 100644
--- a/lldb/source/Target/Target.cpp
+++ b/lldb/source/Target/Target.cpp
@@ -2032,7 +2032,7 @@ Target::EvaluateExpression
     
     // Make sure we aren't just trying to see the value of a persistent
     // variable (something like "$0")
-    lldb::ClangExpressionVariableSP persistent_var_sp;
+    lldb::ExpressionVariableSP persistent_var_sp;
     // Only check for persistent variables the expression starts with a '$' 
     if (expr_cstr[0] == '$')
         persistent_var_sp = m_persistent_variables->GetVariable (expr_cstr);
diff --git a/lldb/source/Target/Thread.cpp b/lldb/source/Target/Thread.cpp
index 666fbf076c1..43652e945c3 100644
--- a/lldb/source/Target/Thread.cpp
+++ b/lldb/source/Target/Thread.cpp
@@ -1244,20 +1244,20 @@ Thread::GetReturnValueObject ()
     return ValueObjectSP();
 }
 
-ClangExpressionVariableSP
+ExpressionVariableSP
 Thread::GetExpressionVariable ()
 {
     if (!m_completed_plan_stack.empty())
     {
         for (int i = m_completed_plan_stack.size() - 1; i >= 0; i--)
         {
-            ClangExpressionVariableSP expression_variable_sp;
+            ExpressionVariableSP expression_variable_sp;
             expression_variable_sp = m_completed_plan_stack[i]->GetExpressionVariable();
             if (expression_variable_sp)
                 return expression_variable_sp;
         }
     }
-    return ClangExpressionVariableSP();
+    return ExpressionVariableSP();
 }
 
 bool