[Expressions] Add support of expressions evaluation in some object's context

[aleksandr.urakov]

Summary

This patch adds support of expression evaluation in a context of some object. Consider the following example:

struct S {
  int a = 11;
  int b = 12;
};

int main() {
  S s;
  int a = 1;
  int b = 2;
  // We have stopped here
  return 0;
}

This patch allows to do something like that:

lldb.frame.FindVariable("s").EvaluateExpression("a + b")

and the result will be 33 (not 3) because fields a and b of s will be used (not locals a and b).

This is achieved by replacing of this type and object for the expression. This has some limitations: an expression can be evaluated only for values located in the debuggee process memory (they must have an address of eAddressTypeLoad type).

Our company needs this functionality to implement some UI visualization of variables in our IDEs. I understand that the community may be not interested in this functionality, and I'll just abandon it if so. But if the community is interested in this, we can save some time on merging in the future :)

[aleksandr.urakov]

Btw, it can be useful if there ever would be a declarative format for pretty printers in LLDB.

[jingham]

This is a little bit odd, but it does make it easy to call methods on a value you got from FindVariable without having to cons up an expression. That seems worthwhile.

It would be good to add a little more explanation of what this is doing in the docs: "in the context of the object" is a little vague.

You should add some tests where the operation doesn't make sense, for instance what if the SBValue is a scalar? Or what if it is an expression result so it's not in memory. You have some error handling in the patch but your test doesn't exercise it. Be good to make sure that actually works.

You also only test the case where the value is a struct, can you test a pointer to a struct and an ObjC class? They both should work but you don't have tests for them.

As an implementation detail, the fact that lldb has to get local variable lookup right by textually injecting the local variables declarations into the expression is a bug, these should be provided on demand from the ASTSource. But that doesn't work correctly at present - the AST source gets asked AFTER looking in the class context which is to late - and we have do the local variable insertion trick instead. So if we ever fix the bug in clang lookup, your implementation will break, and you will have to interfere in that lookup instead. But that's for the future.

[labath]

Sounds like an interesting feature to me.

[aleksandr.urakov]

Thanks for the interest to the feature! I've updated the patch due to the comments.

The only problem is that I'm not familiar with Objective C and have no Mac OS to test it, so I haven't written the test for Objective C case. I've added the "support" of Objective C blindly, so I even not sure that it works correctly. I can remove it from the patch (or, may be some person more familiar with the theme can check if it is ok?). I'm not sure, is it better to leave a preparation of the feature implementation for Objective C or to completely remove it?

[zturner]

include/lldb/API/SBValue.h

310–312

Can you use StringRef instead of const char * here?

include/lldb/Expression/UserExpression.h

296

A reference to a shared_ptr seems odd. Why don't we just say const ValueObject* ctx_obj = nullptr?

include/lldb/Symbol/ClangASTContext.h

1057

Same thing here.

source/API/SBValue.cpp

1325–1327

Instead of the lines like if (log) log->Printf(...) you can instead write:

LLDB_LOG(log, "SBValue::EvaluateExpression called with an empty expression");

1367–1371

If you decide to make that change, note that the macros call Format, not Printf, so in this case you would have to change your format string to something like:

LLDB_LOG(log, "SBValue({0}::EvaluateExpression (expr=\"{1}\") => SBValue({2}) (execution result = {3})",
    value_sp.get(), expr, res_val_sp.get(), expr_res);

BTW, I would discourage logging pointer values, as it makes log output non-deterministic and doesn't often help when reading log files. That said, it wouldn't be the first time we logged pointer values.

[jingham]

include/lldb/API/SBValue.h

310–312

This is an SB API. We don't use StringRef's or any other llvm data types in the SB API's.

[jingham]

source/API/SBValue.cpp

1367–1371

Logging the pointer value of something long-lived can often be really helpful when you are actually debugging lldb, since you can notice some oddity by looking at the log and then get directly to the object that was logged. Logging the values of short-lived pointers is not so useful. I think this is more of the latter case, and maybe logging the incoming value_sp's name and whether the result was successful might be more useful.

[zturner]

include/lldb/API/SBValue.h

310–312

Ahh, you are right of course. My bad.

[aleksandr.urakov]

include/lldb/Expression/UserExpression.h

296

Yes, I agree. I wasn't sure about the lifetime of the context object, that's why I've used a shared pointer here. But now it is obvious that there should be no problems with the lifetime - an expression evaluation with a context object is called from SBValue only, so it is guaranteed that the required value exists during the evaluation.

The only thing is that the pointer points to a non-const value object - non-const methods are used.

[aleksandr.urakov]

Thanks for the comments, I've updated the patch.

[aleksandr.urakov]

Ping! What do you think about this?

[jingham]

The only reservation I have is that this really ought to work correctly for ObjC as well as C++, and there's code to support that, but it isn't tested. I don't have time to write ObjC tests before the new year for sure. Is it possible to rope somebody else into that? If that's not possible, maybe check it in with the ObjC support off and a big FIXME and file a bug to re-enable that support with tests.

[aleksandr.urakov]

Sorry for the long delay with reply. My colleague with a Mac (and Obj-C knowledge) have created the test for the Obj-C case. Can you take a look, please?

[aleksandr.urakov]

Ping! Can you take a look, please?

[jingham]

Thanks for adding the ObjC tests! I had two trivial requests for the test comments to be a little clearer, but even without that this is fine.

packages/Python/lldbsuite/test/expression_command/context-object-objc/TestContextObjectObjc.py

42–52 ↗

(On Diff #183816)

IIUC, these last two are testing that evaluating in the context of an object doesn't effect computations that don't refer to that object. Is that right? After all "self.property" doesn't need any help from the objcClass variable to look up the result. Can you make the comment a little clearer.

54 ↗

(On Diff #183816)

This one is testing that when the reference object is an lldb result object, we can still use it correctly. "Test computation result" is a little terse. Can you make this a little clearer.

[aleksandr.urakov]

Thank you! I've updated the comments in the commit.

include/lldb/API/SBValue.h

#endif
 
   bool GetDescription(lldb::SBStream &description);
 
   bool GetExpressionPath(lldb::SBStream &description);
 
   bool GetExpressionPath(lldb::SBStream &description,
                          bool qualify_cxx_base_classes);
 
+  lldb::SBValue EvaluateExpression(const char *expr) const;
+  lldb::SBValue EvaluateExpression(const char *expr,
+                                   const SBExpressionOptions &options) const;
+
   SBValue(const lldb::ValueObjectSP &value_sp);
 
   //------------------------------------------------------------------
   /// Watch this value if it resides in memory.
   ///
   /// Sets a watchpoint on the value.
   ///
   /// @param[in] resolve_location

include/lldb/Expression/ExpressionSourceCode.h

static ExpressionSourceCode *CreateUnwrapped(const char *name,
     return new ExpressionSourceCode(name, "", body, false);
   }
 
   bool NeedsWrapping() const { return m_wrap; }
 
   const char *GetName() const { return m_name.c_str(); }
 
   bool GetText(std::string &text, lldb::LanguageType wrapping_language,
-               bool static_method, ExecutionContext &exe_ctx) const;
+               bool static_method, ExecutionContext &exe_ctx,
+               bool add_locals) const;
 
   // Given a string returned by GetText, find the beginning and end of the body
   // passed to CreateWrapped. Return true if the bounds could be found.  This
   // will also work on text with FixItHints applied.
   static bool GetOriginalBodyBounds(std::string transformed_text,
                                     lldb::LanguageType wrapping_language,
                                     size_t &start_loc, size_t &end_loc);
 

include/lldb/Expression/UserExpression.h

public:
   ///
   /// @param[out] fixed_expression
   ///     If non-nullptr, the fixed expression is copied into the provided
   ///     string.
   ///
   /// @param[out] jit_module_sp_ptr
   ///     If non-nullptr, used to persist the generated IR module.
   ///
+  /// @param[in] ctx_obj
+  ///     If specified, then the expression will be evaluated in the context of
+  ///     this object. It means that the context object's address will be
+  ///     treated as `this` for the expression (the expression will be
+  ///     evaluated as if it was inside of a method of the context object's
+  ///     class, and its `this` parameter were pointing to the context object).
+  ///     The parameter makes sense for class and union types only.
+  ///     Currently there is a limitation: the context object must be located
+  ///     in the debuggee process' memory (and have the load address).
+  ///
   /// @result
   ///      A Process::ExpressionResults value.  eExpressionCompleted for
   ///      success.
   //------------------------------------------------------------------
   static lldb::ExpressionResults
   Evaluate(ExecutionContext &exe_ctx, const EvaluateExpressionOptions &options,
            llvm::StringRef expr_cstr, llvm::StringRef expr_prefix,
            lldb::ValueObjectSP &result_valobj_sp, Status &error,
            uint32_t line_offset = 0, std::string *fixed_expression = nullptr,
-           lldb::ModuleSP *jit_module_sp_ptr = nullptr);
+           lldb::ModuleSP *jit_module_sp_ptr = nullptr,
+           const lldb::ValueObjectSP &ctx_obj = lldb::ValueObjectSP());
 
   static const Status::ValueType kNoResult =
       0x1001; ///< ValueObject::GetError() returns this if there is no result
               /// from the expression.
 
   const char *GetFixedText() {
     if (m_fixed_text.empty())
       return nullptr;

include/lldb/Symbol/ClangASTContext.h

public:
   ClangASTContextForExpressions(Target &target);
 
   ~ClangASTContextForExpressions() override = default;
 
   UserExpression *
   GetUserExpression(llvm::StringRef expr, llvm::StringRef prefix,
                     lldb::LanguageType language,
                     Expression::ResultType desired_type,
-                    const EvaluateExpressionOptions &options) override;
+                    const EvaluateExpressionOptions &options,
+                    const lldb::ValueObjectSP &ctx_obj) override;
 
   FunctionCaller *GetFunctionCaller(const CompilerType &return_type,
                                     const Address &function_address,
                                     const ValueList &arg_value_list,
                                     const char *name) override;
 
   UtilityFunction *GetUtilityFunction(const char *text,
                                       const char *name) override;

include/lldb/Symbol/TypeSystem.h

public:
   ShouldTreatScalarValueAsAddress(lldb::opaque_compiler_type_t type) {
     return IsPointerOrReferenceType(type, nullptr);
   }
 
   virtual UserExpression *
   GetUserExpression(llvm::StringRef expr, llvm::StringRef prefix,
                     lldb::LanguageType language,
                     Expression::ResultType desired_type,
-                    const EvaluateExpressionOptions &options) {
+                    const EvaluateExpressionOptions &options,
+                    const lldb::ValueObjectSP &ctx_obj) {
     return nullptr;
   }
 
   virtual FunctionCaller *GetFunctionCaller(const CompilerType &return_type,
                                             const Address &function_address,
                                             const ValueList &arg_value_list,
                                             const char *name) {
     return nullptr;

include/lldb/Target/Target.h

void ApplyNameToBreakpoints(BreakpointName &bp_name);
 
   // Creates a UserExpression for the given language, the rest of the
   // parameters have the same meaning as for the UserExpression constructor.
   // Returns a new-ed object which the caller owns.
 
   UserExpression *GetUserExpressionForLanguage(
       llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language,
       Expression::ResultType desired_type,
-      const EvaluateExpressionOptions &options, Status &error);
+      const EvaluateExpressionOptions &options,
+      const lldb::ValueObjectSP &ctx_obj, Status &error);
 
   // Creates a FunctionCaller for the given language, the rest of the
   // parameters have the same meaning as for the FunctionCaller constructor.
   // Since a FunctionCaller can't be
   // IR Interpreted, it makes no sense to call this with an
   // ExecutionContextScope that lacks
   // a Process.
   // Returns a new-ed object which the caller owns.
void ApplyNameToBreakpoints(BreakpointName &bp_name);
   // and the const expression results are available after a process is gone, we
   // provide a way for expressions to be evaluated from the Target itself. If
   // an expression is going to be run, then it should have a frame filled in in
   // th execution context.
   lldb::ExpressionResults EvaluateExpression(
       llvm::StringRef expression, ExecutionContextScope *exe_scope,
       lldb::ValueObjectSP &result_valobj_sp,
       const EvaluateExpressionOptions &options = EvaluateExpressionOptions(),
-      std::string *fixed_expression = nullptr);
+      std::string *fixed_expression = nullptr,
+      const lldb::ValueObjectSP &ctx_obj = lldb::ValueObjectSP());
 
   lldb::ExpressionVariableSP GetPersistentVariable(const ConstString &name);
 
   /// Return the next available number for numbered persistent variables.
   unsigned GetNextPersistentVariableIndex() {
     return m_next_persistent_variable_index++;
   }
 

packages/Python/lldbsuite/test/expression_command/context-object/Makefile

+LEVEL = ../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/expression_command/context-object/TestContextObject.py

+"""
+Tests expression evaluation in context of an object.
+"""
+
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.lldbtest import *
+
+class ContextObjectTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test_context_object(self):
+        """Tests expression evaluation in context of an object."""
+        self.build()
+
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self, '// Break here', self.main_source_spec)
+        frame = thread.GetFrameAtIndex(0)
+
+        #
+        # Test C++ struct variable
+        #
+
+        obj_val = frame.FindVariable("cpp_struct")
+        self.assertTrue(obj_val.IsValid())
+
+        # Test an empty expression evaluation
+        value = obj_val.EvaluateExpression("")
+        self.assertFalse(value.IsValid())
+        self.assertFalse(value.GetError().Success())
+
+        # Test retrieveing of a field (not a local with the same name)
+        value = obj_val.EvaluateExpression("field")
+        self.assertTrue(value.IsValid())
+        self.assertTrue(value.GetError().Success())
+        self.assertEqual(value.GetValueAsSigned(), 1111)
+
+        # Test functions evaluation
+        value = obj_val.EvaluateExpression("function()")
+        self.assertTrue(value.IsValid())
+        self.assertTrue(value.GetError().Success())
+        self.assertEqual(value.GetValueAsSigned(), 2222)
+
+        # Test that we retrieve the right global
+        value = obj_val.EvaluateExpression("global.field")
+        self.assertTrue(value.IsValid())
+        self.assertTrue(value.GetError().Success())
+        self.assertEqual(value.GetValueAsSigned(), 1111)
+
+        #
+        # Test C++ union variable
+        #
+
+        obj_val = frame.FindVariable("cpp_union")
+        self.assertTrue(obj_val.IsValid())
+
+        # Test retrieveing of a field
+        value = obj_val.EvaluateExpression("field_int")
+        self.assertTrue(value.IsValid())
+        self.assertTrue(value.GetError().Success())
+        self.assertEqual(value.GetValueAsSigned(), 5555)
+
+        #
+        # Test C++ scalar
+        #
+
+        obj_val = frame.FindVariable("cpp_scalar")
+        self.assertTrue(obj_val.IsValid())
+
+        # Test an expression evaluation
+        value = obj_val.EvaluateExpression("1")
+        self.assertFalse(value.IsValid())
+        self.assertFalse(value.GetError().Success())
+
+        #
+        # Test C++ array
+        #
+
+        obj_val = frame.FindVariable("cpp_array")
+        self.assertTrue(obj_val.IsValid())
+
+        # Test an expression evaluation
+        value = obj_val.EvaluateExpression("1")
+        self.assertFalse(value.IsValid())
+        self.assertFalse(value.GetError().Success())
+
+        # Test retrieveing of an element's field
+        value = obj_val.GetValueForExpressionPath("[7]").EvaluateExpression("field")
+        self.assertTrue(value.IsValid())
+        self.assertTrue(value.GetError().Success())
+        self.assertEqual(value.GetValueAsSigned(), 1111)
+
+        #
+        # Test C++ pointer
+        #
+
+        obj_val = frame.FindVariable("cpp_pointer")
+        self.assertTrue(obj_val.IsValid())
+
+        # Test an expression evaluation
+        value = obj_val.EvaluateExpression("1")
+        self.assertFalse(value.IsValid())
+        self.assertFalse(value.GetError().Success())
+
+        # Test retrieveing of a dereferenced object's field
+        value = obj_val.Dereference().EvaluateExpression("field")
+        self.assertTrue(value.IsValid())
+        self.assertTrue(value.GetError().Success())
+        self.assertEqual(value.GetValueAsSigned(), 1111)
+
+        #
+        # Test C++ computation result
+        #
+
+        obj_val = frame.EvaluateExpression("cpp_namespace::GetCppStruct()")
+        self.assertTrue(obj_val.IsValid())
+
+        # Test an expression evaluation
+        value = obj_val.EvaluateExpression("1")
+        self.assertTrue(value.IsValid())
+        self.assertFalse(value.GetError().Success())
+
+        #
+        # Test C++ computation result located in debuggee memory
+        #
+
+        obj_val = frame.EvaluateExpression("cpp_namespace::GetCppStructPtr()")
+        self.assertTrue(obj_val.IsValid())
+
+        # Test an expression evaluation
+        value = obj_val.EvaluateExpression("1")
+        self.assertFalse(value.IsValid())
+        self.assertFalse(value.GetError().Success())
+
+        # Test retrieveing of a dereferenced object's field
+        value = obj_val.Dereference().EvaluateExpression("field")
+        self.assertTrue(value.IsValid())
+        self.assertTrue(value.GetError().Success())
+        self.assertEqual(value.GetValueAsSigned(), 1111)
+
+    def setUp(self):
+        TestBase.setUp(self)
+
+        self.main_source = "main.cpp"
+        self.main_source_spec = lldb.SBFileSpec(self.main_source)

packages/Python/lldbsuite/test/expression_command/context-object/main.cpp

+namespace cpp_namespace {
+  struct CppStruct {
+    int field = 1111;
+
+    int function() {
+      return 2222;
+    }
+  };
+
+  union CppUnion {
+    char field_char;
+    short field_short;
+    int field_int;
+  };
+
+  CppStruct GetCppStruct() {
+    return CppStruct();
+  }
+
+  CppStruct global;
+
+  CppStruct *GetCppStructPtr() {
+    return &global;
+  }
+}
+
+int global = 3333;
+
+int main()
+{
+  cpp_namespace::CppStruct cpp_struct = cpp_namespace::GetCppStruct();
+  cpp_struct.function();
+
+  int field = 4444;
+
+  cpp_namespace::CppUnion cpp_union;
+  cpp_union.field_int = 5555;
+
+  int cpp_scalar = 6666;
+
+  cpp_namespace::CppStruct cpp_array[16];
+
+  cpp_namespace::CppStruct *cpp_pointer = cpp_namespace::GetCppStructPtr();
+
+  return 0; // Break here
+}

scripts/interface/SBValue.i

GetAddress();
     
     lldb::SBValue
     Persist ();
              
     %feature("docstring", "Returns an expression path for this value."
     ) GetExpressionPath;
     bool
     GetExpressionPath (lldb::SBStream &description, bool qualify_cxx_base_classes);
-    
+    lldb::SBValue
+    EvaluateExpression(const char *expr) const;
+
+    lldb::SBValue
+    EvaluateExpression(const char *expr,
+                       const SBExpressionOptions &options) const;
+
     %pythoncode %{
         def __get_dynamic__ (self):
             '''Helper function for the "SBValue.dynamic" property.'''
             return self.GetDynamicValue (eDynamicCanRunTarget)
         
         class children_access(object):
             '''A helper object that will lazily hand out thread for a process when supplied an index.'''
             

source/API/SBValue.cpp

bool SBValue::GetExpressionPath(SBStream &description,
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     value_sp->GetExpressionPath(description.ref(), qualify_cxx_base_classes);
     return true;
   }
   return false;
 }
 
+lldb::SBValue SBValue::EvaluateExpression(const char* expr) const {
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (!value_sp)
+    return SBValue();
+
+  lldb::TargetSP target_sp = value_sp->GetTargetSP();
+  if (!target_sp)
+    return SBValue();
+
+  lldb::SBExpressionOptions options;
+  options.SetFetchDynamicValue(target_sp->GetPreferDynamicValue());
+  options.SetUnwindOnError(true);
+  options.SetIgnoreBreakpoints(true);
+
+  return EvaluateExpression(expr, options);
+}
+
+lldb::SBValue
+SBValue::EvaluateExpression(const char* expr,
+                            const SBExpressionOptions& options) const {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+
+  if (!expr || expr[0] == '\0') {
+    if (log)
+      log->Printf(
+          "SBValue::EvaluateExpression called with an empty expression");
+    return SBValue();
+  }
+
+  if (log)
+    log->Printf("SBValue()::EvaluateExpression (expr=\"%s\")...", expr);
+
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (!value_sp) {
+    if (log)
+      log->Printf("SBValue::EvaluateExpression () => error: could not "
+                  "reconstruct value object for this SBValue");
+    return SBValue();
+  }
+
+  lldb::TargetSP target_sp = value_sp->GetTargetSP();
+  if (!target_sp) {
+    if (log)
+      log->Printf("SBValue::EvaluateExpression () => error: could not "
+                  "retrieve target");
+    return SBValue();
+  }
+
+  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
+  ExecutionContext exe_ctx(target_sp.get());
+
+  StackFrame *frame = exe_ctx.GetFramePtr();
+  if (!frame) {
+    if (log)
+      log->Printf("SBValue::EvaluateExpression () => error: could not "
+                  "retrieve current stack frame");
+    return SBValue();
+  }
+
+  ValueObjectSP res_val_sp;
+  ExpressionResults expr_res =
+      target_sp->EvaluateExpression(expr, frame, res_val_sp, options.ref(),
+                                    nullptr, value_sp);
+
+  if (log)
+    log->Printf("SBValue(%p)::EvaluateExpression (expr=\"%s\") => SBValue(%p) "
+                "(execution result=%d)",
+                static_cast<void *>(value_sp.get()), expr,
+                static_cast<void *>(res_val_sp.get()), expr_res);
+
+  SBValue result;
+  result.SetSP(res_val_sp, options.GetFetchDynamicValue());
+  return result;
+}
+
 bool SBValue::GetDescription(SBStream &description) {
   Stream &strm = description.ref();
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp)
     value_sp->Dump(strm);
   else

source/Breakpoint/BreakpointLocation.cpp

if (condition_hash != m_condition_hash || !m_user_expression_sp ||
     // See if we can figure out the language from the frame, otherwise use the
     // default language:
     CompileUnit *comp_unit = m_address.CalculateSymbolContextCompileUnit();
     if (comp_unit)
       language = comp_unit->GetLanguage();
 
     m_user_expression_sp.reset(GetTarget().GetUserExpressionForLanguage(
         condition_text, llvm::StringRef(), language, Expression::eResultTypeAny,
-        EvaluateExpressionOptions(), error));
+        EvaluateExpressionOptions(), nullptr, error));
     if (error.Fail()) {
       if (log)
         log->Printf("Error getting condition expression: %s.",
                     error.AsCString());
       m_user_expression_sp.reset();
       return true;
     }
 

source/Breakpoint/Watchpoint.cpp

void Watchpoint::SetCondition(const char *condition) {
   if (condition == nullptr || condition[0] == '\0') {
     if (m_condition_ap.get())
       m_condition_ap.reset();
   } else {
     // Pass nullptr for expr_prefix (no translation-unit level definitions).
     Status error;
     m_condition_ap.reset(m_target.GetUserExpressionForLanguage(
         condition, llvm::StringRef(), lldb::eLanguageTypeUnknown,
-        UserExpression::eResultTypeAny, EvaluateExpressionOptions(), error));
+        UserExpression::eResultTypeAny, EvaluateExpressionOptions(),
+        nullptr, error));
     if (error.Fail()) {
       // FIXME: Log something...
       m_condition_ap.reset();
     }
   }
   SendWatchpointChangedEvent(eWatchpointEventTypeConditionChanged);
 }
 

source/Commands/CommandObjectExpression.cpp

int CommandObjectExpression::HandleCompletion(CompletionRequest &request) {
   assert(cursor_pos >= raw_start);
   cursor_pos -= raw_start;
 
   auto language = exe_ctx.GetFrameRef().GetLanguage();
 
   Status error;
   lldb::UserExpressionSP expr(target->GetUserExpressionForLanguage(
       code, llvm::StringRef(), language, UserExpression::eResultTypeAny,
-      options, error));
+      options, nullptr, error));
   if (error.Fail())
     return 0;
 
   expr->Complete(exe_ctx, request, cursor_pos);
   return request.GetNumberOfMatches();
 }
 
 static lldb_private::Status

source/Expression/ExpressionSourceCode.cpp

for (size_t i = 0; i < var_list_sp->GetSize(); i++) {
 
     stream.Printf("using $__lldb_local_vars::%s;\n", var_name.AsCString());
   }
 }
 
 bool ExpressionSourceCode::GetText(std::string &text,
                                    lldb::LanguageType wrapping_language,
                                    bool static_method,
-                                   ExecutionContext &exe_ctx) const {
+                                   ExecutionContext &exe_ctx,
+                                   bool add_locals) const {
   const char *target_specific_defines = "typedef signed char BOOL;\n";
   std::string module_macros;
 
   Target *target = exe_ctx.GetTargetPtr();
   if (target) {
     if (target->GetArchitecture().GetMachine() == llvm::Triple::aarch64) {
       target_specific_defines = "typedef bool BOOL;\n";
     }
if (StackFrame *frame = exe_ctx.GetFramePtr()) {
     if (sc.comp_unit && sc.line_entry.IsValid()) {
       DebugMacros *dm = sc.comp_unit->GetDebugMacros();
       if (dm) {
         AddMacroState state(sc.line_entry.file, sc.line_entry.line);
         AddMacros(dm, sc.comp_unit, state, debug_macros_stream);
       }
     }
 
-    ConstString object_name;
+    if (add_locals) {
       if (Language::LanguageIsCPlusPlus(frame->GetLanguage())) {
         if (target->GetInjectLocalVariables(&exe_ctx)) {
           lldb::VariableListSP var_list_sp =
               frame->GetInScopeVariableList(false, true);
           AddLocalVariableDecls(var_list_sp, lldb_local_var_decls);
         }
       }
     }
+  }
 
   if (m_wrap) {
     switch (wrapping_language) {
     default:
       return false;
     case lldb::eLanguageTypeC:
     case lldb::eLanguageTypeC_plus_plus:
     case lldb::eLanguageTypeObjC:

source/Expression/UserExpression.cpp

lldb::addr_t UserExpression::GetObjectPointer(lldb::StackFrameSP frame_sp,
 
   return ret;
 }
 
 lldb::ExpressionResults UserExpression::Evaluate(
     ExecutionContext &exe_ctx, const EvaluateExpressionOptions &options,
     llvm::StringRef expr, llvm::StringRef prefix,
     lldb::ValueObjectSP &result_valobj_sp, Status &error, uint32_t line_offset,
-    std::string *fixed_expression, lldb::ModuleSP *jit_module_sp_ptr) {
+    std::string *fixed_expression, lldb::ModuleSP *jit_module_sp_ptr,
+    const lldb::ValueObjectSP &ctx_obj) {
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS |
                                                   LIBLLDB_LOG_STEP));
 
+  if (ctx_obj) {
+    static unsigned const ctx_type_mask =
+        lldb::TypeFlags::eTypeIsClass | lldb::TypeFlags::eTypeIsStructUnion;
+    if (!(ctx_obj->GetTypeInfo() & ctx_type_mask)) {
+      if (log)
+        log->Printf("== [UserExpression::Evaluate] Passed a context object of "
+                    "an invalid type, can't run expressions.");
+      error.SetErrorString("a context object of an invalid type passed");
+      return lldb::eExpressionSetupError;
+    }
+  }
+
   lldb_private::ExecutionPolicy execution_policy = options.GetExecutionPolicy();
   lldb::LanguageType language = options.GetLanguage();
   const ResultType desired_type = options.DoesCoerceToId()
                                       ? UserExpression::eResultTypeId
                                       : UserExpression::eResultTypeAny;
   lldb::ExpressionResults execution_results = lldb::eExpressionSetupError;
 
   Target *target = exe_ctx.GetTargetPtr();
if (language == lldb::eLanguageTypeUnknown) {
     if (target->GetLanguage() != lldb::eLanguageTypeUnknown)
       language = target->GetLanguage();
     else if (StackFrame *frame = exe_ctx.GetFramePtr())
       language = frame->GetLanguage();
   }
 
   lldb::UserExpressionSP user_expression_sp(
       target->GetUserExpressionForLanguage(expr, full_prefix, language,
-                                           desired_type, options, error));
+                                           desired_type, options, ctx_obj,
+                                           error));
   if (error.Fail()) {
     if (log)
       log->Printf("== [UserExpression::Evaluate] Getting expression: %s ==",
                   error.AsCString());
     return lldb::eExpressionSetupError;
   }
 
   if (log)
lldb::ExpressionResults UserExpression::Evaluate(
   // If there is a fixed expression, try to parse it:
   if (!parse_success) {
     execution_results = lldb::eExpressionParseError;
     if (fixed_expression && !fixed_expression->empty() &&
         options.GetAutoApplyFixIts()) {
       lldb::UserExpressionSP fixed_expression_sp(
           target->GetUserExpressionForLanguage(fixed_expression->c_str(),
                                                full_prefix, language,
-                                               desired_type, options, error));
+                                               desired_type, options, ctx_obj,
+                                               error));
       DiagnosticManager fixed_diagnostic_manager;
       parse_success = fixed_expression_sp->Parse(
           fixed_diagnostic_manager, exe_ctx, execution_policy,
           keep_expression_in_memory, generate_debug_info);
       if (parse_success) {
         diagnostic_manager.Clear();
         user_expression_sp = fixed_expression_sp;
       } else {

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h

public:
   ///     as persisting.
   ///
   /// @param[in] delegate
   ///     If non-NULL, use this delegate to report result values.  This
   ///     allows the client ClangUserExpression to report a result.
   ///
   /// @param[in] exe_ctx
   ///     The execution context to use when parsing.
+  ///
+  /// @param[in] ctx_obj
+  ///     If not empty, then expression is evaluated in context of this object.
+  ///     See the comment to `UserExpression::Evaluate` for details.
   //------------------------------------------------------------------
   ClangExpressionDeclMap(
       bool keep_result_in_memory,
       Materializer::PersistentVariableDelegate *result_delegate,
-      ExecutionContext &exe_ctx);
+      ExecutionContext &exe_ctx,
+      const lldb::ValueObjectSP &ctx_obj);
 
   //------------------------------------------------------------------
   /// Destructor
   //------------------------------------------------------------------
   ~ClangExpressionDeclMap() override;
 
   //------------------------------------------------------------------
   /// Enable the state needed for parsing and IR transformation.
private:
   ExpressionVariableList
       m_struct_members; ///< All entities that need to be placed in the struct.
   bool m_keep_result_in_memory; ///< True if result persistent variables
                                 ///generated by this expression should stay in
                                 ///memory.
   Materializer::PersistentVariableDelegate
       *m_result_delegate; ///< If non-NULL, used to report expression results to
                           ///ClangUserExpression.
+  lldb::ValueObjectSP m_ctx_obj; ///< If not empty, then expression is
+                                 ///evaluated in context of this object.
+                                 ///For details see the comment to
+                                 ///`UserExpression::Evaluate`.
 
   //----------------------------------------------------------------------
   /// The following values should not live beyond parsing
   //----------------------------------------------------------------------
   class ParserVars {
   public:
     ParserVars() {}
 
private:
   /// are not placed in the Tuple list.)
   ///
   /// @param[in] context
   ///     The NameSearchContext to use when constructing the Decl.
   ///
   /// @param[in] type
   ///     The type that needs to be created.
   //------------------------------------------------------------------
-  void AddOneType(NameSearchContext &context, TypeFromUser &type,
+  void AddOneType(NameSearchContext &context, const TypeFromUser &type,
                   unsigned int current_id);
 
   //------------------------------------------------------------------
   /// Generate a Decl for "*this" and add a member function declaration to it
   /// for the expression, then report it.
   ///
   /// @param[in] context
   ///     The NameSearchContext to use when constructing the Decl.
   ///
   /// @param[in] type
   ///     The type for *this.
   //------------------------------------------------------------------
-  void AddThisType(NameSearchContext &context, TypeFromUser &type,
+  void AddThisType(NameSearchContext &context, const TypeFromUser &type,
                    unsigned int current_id);
 
   //------------------------------------------------------------------
   /// Move a type out of the current ASTContext into another, but make sure to
   /// export all components of the type also.
   ///
   /// @param[in] target
   ///     The ClangASTContext to move to.

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

 
 namespace {
 const char *g_lldb_local_vars_namespace_cstr = "$__lldb_local_vars";
 } // anonymous namespace
 
 ClangExpressionDeclMap::ClangExpressionDeclMap(
     bool keep_result_in_memory,
     Materializer::PersistentVariableDelegate *result_delegate,
-    ExecutionContext &exe_ctx)
+    ExecutionContext &exe_ctx,
+    const lldb::ValueObjectSP &ctx_obj)
     : ClangASTSource(exe_ctx.GetTargetSP()), m_found_entities(),
       m_struct_members(), m_keep_result_in_memory(keep_result_in_memory),
-      m_result_delegate(result_delegate), m_parser_vars(), m_struct_vars() {
+      m_result_delegate(result_delegate), m_parser_vars(), m_struct_vars(),
+      m_ctx_obj(ctx_obj) {
   EnableStructVars();
 }
 
 ClangExpressionDeclMap::~ClangExpressionDeclMap() {
   // Note: The model is now that the parser's AST context and all associated
   //   data does not vanish until the expression has been executed.  This means
   //   that valuable lookup data (like namespaces) doesn't vanish, but
 
do {
       context.AddNamedDecl(parser_named_decl);
     } while (0);
   }
 
   if (name.GetCString()[0] == '$' && !namespace_decl) {
     static ConstString g_lldb_class_name("$__lldb_class");
 
     if (name == g_lldb_class_name) {
+      if (m_ctx_obj) {
+        Status status;
+        lldb::ValueObjectSP ctx_obj_ptr = m_ctx_obj->AddressOf(status);
+        if (!ctx_obj_ptr || status.Fail())
+          return;
+
+        AddThisType(context, TypeFromUser(m_ctx_obj->GetCompilerType()),
+                    current_id);
+
+        m_struct_vars->m_object_pointer_type =
+            TypeFromUser(ctx_obj_ptr->GetCompilerType());
+
+        return;
+      }
+
       // Clang is looking for the type of "this"
 
       if (frame == NULL)
         return;
 
       // Find the block that defines the function represented by "sym_ctx"
       Block *function_block = sym_ctx.GetFunctionBlock();
 
if (name == g_lldb_class_name) {
         }
       }
 
       return;
     }
 
     static ConstString g_lldb_objc_class_name("$__lldb_objc_class");
     if (name == g_lldb_objc_class_name) {
+      if (m_ctx_obj) {
+        Status status;
+        lldb::ValueObjectSP ctx_obj_ptr = m_ctx_obj->AddressOf(status);
+        if (!ctx_obj_ptr || status.Fail())
+          return;
+
+        AddOneType(context, TypeFromUser(m_ctx_obj->GetCompilerType()),
+                    current_id);
+
+        m_struct_vars->m_object_pointer_type =
+            TypeFromUser(ctx_obj_ptr->GetCompilerType());
+
+        return;
+      }
+
       // Clang is looking for the type of "*self"
 
       if (!frame)
         return;
 
       SymbolContext sym_ctx = frame->GetSymbolContext(
           lldb::eSymbolContextFunction | lldb::eSymbolContextBlock);
 
if (log) {
     log->Printf(
         "  CEDM::FEVD[%u] Found %s function %s (description %s), returned %s",
         current_id, (function ? "specific" : "generic"), decl_name.c_str(),
         ss.GetData(), function_str.c_str());
   }
 }
 
 void ClangExpressionDeclMap::AddThisType(NameSearchContext &context,
-                                         TypeFromUser &ut,
+                                         const TypeFromUser &ut,
                                          unsigned int current_id) {
   CompilerType copied_clang_type = GuardedCopyType(ut);
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   if (!copied_clang_type) {
     if (log)
       log->Printf(
if (!typedef_decl)
     return;
 
   context.AddNamedDecl(typedef_decl);
 
   return;
 }
 
 void ClangExpressionDeclMap::AddOneType(NameSearchContext &context,
-                                        TypeFromUser &ut,
+                                        const TypeFromUser &ut,
                                         unsigned int current_id) {
   CompilerType copied_clang_type = GuardedCopyType(ut);
 
   if (!copied_clang_type) {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
     if (log)
       log->Printf(
           "ClangExpressionDeclMap::AddOneType - Couldn't import the type");
 
     return;
   }
 
   context.AddTypeDecl(copied_clang_type);
 }

source/Plugins/ExpressionParser/Clang/ClangUserExpression.h

public:
     ClangExpressionDeclMap *DeclMap() override {
       return m_expr_decl_map_up.get();
     }
 
     void ResetDeclMap() { m_expr_decl_map_up.reset(); }
 
     void ResetDeclMap(ExecutionContext &exe_ctx,
                       Materializer::PersistentVariableDelegate &result_delegate,
-                      bool keep_result_in_memory);
+                      bool keep_result_in_memory,
+                      const lldb::ValueObjectSP &ctx_obj);
 
     //------------------------------------------------------------------
     /// Return the object that the parser should allow to access ASTs. May be
     /// NULL if the ASTs do not need to be transformed.
     ///
     /// @param[in] passthrough
     ///     The ASTConsumer that the returned transformer should send
     ///     the ASTs to after transformation.
public:
   /// @param[in] language
   ///     If not eLanguageTypeUnknown, a language to use when parsing
   ///     the expression.  Currently restricted to those languages
   ///     supported by Clang.
   ///
   /// @param[in] desired_type
   ///     If not eResultTypeAny, the type to use for the expression
   ///     result.
+  ///
+  /// @param[in] ctx_obj
+  ///     The object (if any) in which context the expression
+  ///     must be evaluated. For details see the comment to
+  ///     `UserExpression::Evaluate`.
   //------------------------------------------------------------------
   ClangUserExpression(ExecutionContextScope &exe_scope, llvm::StringRef expr,
                       llvm::StringRef prefix, lldb::LanguageType language,
                       ResultType desired_type,
-                      const EvaluateExpressionOptions &options);
+                      const EvaluateExpressionOptions &options,
+                      const lldb::ValueObjectSP &ctx_obj);
 
   ~ClangUserExpression() override;
 
   //------------------------------------------------------------------
   /// Parse the expression
   ///
   /// @param[in] diagnostic_manager
   ///     A diagnostic manager to report parse errors and warnings to.
public:
   ClangExpressionDeclMap *DeclMap() { return m_type_system_helper.DeclMap(); }
 
   void ResetDeclMap() { m_type_system_helper.ResetDeclMap(); }
 
   void ResetDeclMap(ExecutionContext &exe_ctx,
                     Materializer::PersistentVariableDelegate &result_delegate,
                     bool keep_result_in_memory) {
     m_type_system_helper.ResetDeclMap(exe_ctx, result_delegate,
-                                      keep_result_in_memory);
+                                      keep_result_in_memory,
+                                      m_ctx_obj);
   }
 
   lldb::ExpressionVariableSP
   GetResultAfterDematerialization(ExecutionContextScope *exe_scope) override;
 
 private:
   //------------------------------------------------------------------
   /// Populate m_in_cplusplus_method and m_in_objectivec_method based on the
private:
   /// The language type of the current expression.
   lldb::LanguageType m_expr_lang = lldb::eLanguageTypeUnknown;
 
   /// The absolute character position in the transformed source code where the
   /// user code (as typed by the user) starts. If the variable is empty, then we
   /// were not able to calculate this position.
   llvm::Optional<size_t> m_user_expression_start_pos;
   ResultDelegate m_result_delegate;
+
+  /// The object (if any) in which context the expression is evaluated.
+  /// See the comment to `UserExpression::Evaluate` for details.
+  lldb::ValueObjectSP m_ctx_obj;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ClangUserExpression_h_

source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 
 using namespace lldb_private;
 
 ClangUserExpression::ClangUserExpression(
     ExecutionContextScope &exe_scope, llvm::StringRef expr,
     llvm::StringRef prefix, lldb::LanguageType language,
-    ResultType desired_type, const EvaluateExpressionOptions &options)
+    ResultType desired_type, const EvaluateExpressionOptions &options,
+    const lldb::ValueObjectSP &ctx_obj)
     : LLVMUserExpression(exe_scope, expr, prefix, language, desired_type,
                          options),
       m_type_system_helper(*m_target_wp.lock().get(),
                            options.GetExecutionPolicy() ==
                                eExecutionPolicyTopLevel),
-      m_result_delegate(exe_scope.CalculateTarget()) {
+      m_result_delegate(exe_scope.CalculateTarget()),
+      m_ctx_obj(ctx_obj) {
   switch (m_language) {
   case lldb::eLanguageTypeC_plus_plus:
     m_allow_cxx = true;
     break;
   case lldb::eLanguageTypeObjC:
     m_allow_objc = true;
     break;
   case lldb::eLanguageTypeObjC_plus_plus:
void ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Status &err) {
   CompilerDeclContext decl_context = function_block->GetDeclContext();
 
   if (!decl_context) {
     if (log)
       log->Printf("  [CUE::SC] Null decl context");
     return;
   }
 
-  if (clang::CXXMethodDecl *method_decl =
+  if (m_ctx_obj) {
+    switch (m_ctx_obj->GetObjectRuntimeLanguage()) {
+    case lldb::eLanguageTypeC:
+    case lldb::eLanguageTypeC89:
+    case lldb::eLanguageTypeC99:
+    case lldb::eLanguageTypeC11:
+    case lldb::eLanguageTypeC_plus_plus:
+    case lldb::eLanguageTypeC_plus_plus_03:
+    case lldb::eLanguageTypeC_plus_plus_11:
+    case lldb::eLanguageTypeC_plus_plus_14:
+      m_in_cplusplus_method = true;
+      break;
+    case lldb::eLanguageTypeObjC:
+    case lldb::eLanguageTypeObjC_plus_plus:
+      m_in_objectivec_method = true;
+      break;
+    default:
+      break;
+    }
+    m_needs_object_ptr = true;
+  } else if (clang::CXXMethodDecl *method_decl =
           ClangASTContext::DeclContextGetAsCXXMethodDecl(decl_context)) {
     if (m_allow_cxx && method_decl->isInstance()) {
       if (m_enforce_valid_object) {
         lldb::VariableListSP variable_list_sp(
             function_block->GetBlockVariableList(true));
 
         const char *thisErrorString = "Stopped in a C++ method, but 'this' "
                                       "isn't available; pretending we are in a "
if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) {
     if (m_in_cplusplus_method)
       m_expr_lang = lldb::eLanguageTypeC_plus_plus;
     else if (m_in_objectivec_method)
       m_expr_lang = lldb::eLanguageTypeObjC;
     else
       m_expr_lang = lldb::eLanguageTypeC;
 
     if (!source_code->GetText(m_transformed_text, m_expr_lang,
-                              m_in_static_method, exe_ctx)) {
+                              m_in_static_method, exe_ctx,
+                              m_ctx_obj.empty())) {
       diagnostic_manager.PutString(eDiagnosticSeverityError,
                                    "couldn't construct expression body");
       return;
     }
 
     // Find and store the start position of the original code inside the
     // transformed code. We need this later for the code completion.
     std::size_t original_start;
if (m_in_cplusplus_method) {
       diagnostic_manager.PutString(
           eDiagnosticSeverityError,
           "need object pointer but don't know the language");
       return false;
     }
 
     Status object_ptr_error;
 
+    if (m_ctx_obj) {
+      AddressType address_type;
+      object_ptr = m_ctx_obj->GetAddressOf(false, &address_type);
+      if (object_ptr == LLDB_INVALID_ADDRESS ||
+          address_type != eAddressTypeLoad)
+        object_ptr_error.SetErrorString("Can't get context object's "
+                                        "debuggee address");
+    } else
       object_ptr = GetObjectPointer(frame_sp, object_name, object_ptr_error);
 
     if (!object_ptr_error.Success()) {
       exe_ctx.GetTargetRef().GetDebugger().GetAsyncOutputStream()->Printf(
           "warning: `%s' is not accessible (substituting 0)\n",
           object_name.AsCString());
       object_ptr = 0;
     }
 

 lldb::ExpressionVariableSP ClangUserExpression::GetResultAfterDematerialization(
     ExecutionContextScope *exe_scope) {
   return m_result_delegate.GetVariable();
 }
 
 void ClangUserExpression::ClangUserExpressionHelper::ResetDeclMap(
     ExecutionContext &exe_ctx,
     Materializer::PersistentVariableDelegate &delegate,
-    bool keep_result_in_memory) {
+    bool keep_result_in_memory,
+    const lldb::ValueObjectSP &ctx_obj) {
   m_expr_decl_map_up.reset(
-      new ClangExpressionDeclMap(keep_result_in_memory, &delegate, exe_ctx));
+      new ClangExpressionDeclMap(keep_result_in_memory, &delegate, exe_ctx,
+                                 ctx_obj));
 }
 
 clang::ASTConsumer *
 ClangUserExpression::ClangUserExpressionHelper::ASTTransformer(
     clang::ASTConsumer *passthrough) {
   m_result_synthesizer_up.reset(
       new ASTResultSynthesizer(passthrough, m_top_level, m_target));
 

source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.cpp

if (jit_error.Success()) {
     }
     return false;
   }
 }
 
 void ClangUtilityFunction::ClangUtilityFunctionHelper::ResetDeclMap(
     ExecutionContext &exe_ctx, bool keep_result_in_memory) {
   m_expr_decl_map_up.reset(
-      new ClangExpressionDeclMap(keep_result_in_memory, nullptr, exe_ctx));
+      new ClangExpressionDeclMap(keep_result_in_memory, nullptr, exe_ctx,
+                                 nullptr));
 }

source/Symbol/ClangASTContext.cpp

 ClangASTContextForExpressions::ClangASTContextForExpressions(Target &target)
     : ClangASTContext(target.GetArchitecture().GetTriple().getTriple().c_str()),
       m_target_wp(target.shared_from_this()),
       m_persistent_variables(new ClangPersistentVariables) {}
 
 UserExpression *ClangASTContextForExpressions::GetUserExpression(
     llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language,
     Expression::ResultType desired_type,
-    const EvaluateExpressionOptions &options) {
+    const EvaluateExpressionOptions &options,
+    const lldb::ValueObjectSP &ctx_obj) {
   TargetSP target_sp = m_target_wp.lock();
   if (!target_sp)
     return nullptr;
 
   return new ClangUserExpression(*target_sp.get(), expr, prefix, language,
-                                 desired_type, options);
+                                 desired_type, options, ctx_obj);
 }
 
 FunctionCaller *ClangASTContextForExpressions::GetFunctionCaller(
     const CompilerType &return_type, const Address &function_address,
     const ValueList &arg_value_list, const char *name) {
   TargetSP target_sp = m_target_wp.lock();
   if (!target_sp)
     return nullptr;

source/Target/Target.cpp

Target::GetPersistentExpressionStateForLanguage(lldb::LanguageType language) {
   } else {
     return nullptr;
   }
 }
 
 UserExpression *Target::GetUserExpressionForLanguage(
     llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language,
     Expression::ResultType desired_type,
-    const EvaluateExpressionOptions &options, Status &error) {
+    const EvaluateExpressionOptions &options,
+    const lldb::ValueObjectSP &ctx_obj, Status &error) {
   Status type_system_error;
 
   TypeSystem *type_system =
       GetScratchTypeSystemForLanguage(&type_system_error, language);
   UserExpression *user_expr = nullptr;
 
   if (!type_system) {
     error.SetErrorStringWithFormat(
         "Could not find type system for language %s: %s",
         Language::GetNameForLanguageType(language),
         type_system_error.AsCString());
     return nullptr;
   }
 
   user_expr = type_system->GetUserExpression(expr, prefix, language,
-                                             desired_type, options);
+                                             desired_type, options, ctx_obj);
   if (!user_expr)
     error.SetErrorStringWithFormat(
         "Could not create an expression for language %s",
         Language::GetNameForLanguageType(language));
 
   return user_expr;
 }
 
Target *Target::GetTargetFromContexts(const ExecutionContext *exe_ctx_ptr,
   if (target == nullptr && exe_ctx_ptr)
     target = exe_ctx_ptr->GetTargetPtr();
   return target;
 }
 
 ExpressionResults Target::EvaluateExpression(
     llvm::StringRef expr, ExecutionContextScope *exe_scope,
     lldb::ValueObjectSP &result_valobj_sp,
-    const EvaluateExpressionOptions &options, std::string *fixed_expression) {
+    const EvaluateExpressionOptions &options, std::string *fixed_expression,
+    const lldb::ValueObjectSP &ctx_obj) {
   result_valobj_sp.reset();
 
   ExpressionResults execution_results = eExpressionSetupError;
 
   if (expr.empty())
     return execution_results;
 
   // We shouldn't run stop hooks in expressions. Be sure to reset this if you
if (persistent_var_sp) {
     result_valobj_sp = persistent_var_sp->GetValueObject();
     execution_results = eExpressionCompleted;
   } else {
     llvm::StringRef prefix = GetExpressionPrefixContents();
     Status error;
     execution_results = UserExpression::Evaluate(exe_ctx, options, expr, prefix,
                                                  result_valobj_sp, error,
                                                  0, // Line Number
-                                                 fixed_expression);
+                                                 fixed_expression,
+                                                 nullptr, // Module
+                                                 ctx_obj);
   }
 
   m_suppress_stop_hooks = old_suppress_value;
 
   return execution_results;
 }
 
 lldb::ExpressionVariableSP