Support expressions in the context of a reference

[emrekultursay]

Summary

...type variable by dereferencing the variable before
evaluating the expression.

[emrekultursay]

Rebased

[emrekultursay]

re-rebase

[labath]

lldb/test/API/commands/expression/context-object/TestContextObject.py

22

wrap this in something like: for obj in "cpp_struct","cpp_struct_ref" instead of duplicating everything?

[emrekultursay]

Use loop instead of code duplication in test

[emrekultursay]

Thanks. Please submit the change on my behalf.

lldb/source/Expression/UserExpression.cpp

 UserExpression::Evaluate(ExecutionContext &exe_ctx,
                          const EvaluateExpressionOptions &options,
                          llvm::StringRef expr, llvm::StringRef prefix,
                          lldb::ValueObjectSP &result_valobj_sp, Status &error,
                          std::string *fixed_expression, ValueObject *ctx_obj) {
   Log *log(GetLog(LLDBLog::Expressions | LLDBLog::Step));
 
   if (ctx_obj) {
-    static unsigned const ctx_type_mask =
-        lldb::TypeFlags::eTypeIsClass | lldb::TypeFlags::eTypeIsStructUnion;
+    static unsigned const ctx_type_mask = lldb::TypeFlags::eTypeIsClass |
+                                          lldb::TypeFlags::eTypeIsStructUnion |
+                                          lldb::TypeFlags::eTypeIsReference;
     if (!(ctx_obj->GetTypeInfo() & ctx_type_mask)) {
       LLDB_LOG(log, "== [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;
     }
   }
 
+  if (ctx_obj && ctx_obj->GetTypeInfo() & lldb::TypeFlags::eTypeIsReference) {
+    Status error;
+    lldb::ValueObjectSP deref_ctx_sp = ctx_obj->Dereference(error);
+    if (!error.Success()) {
+      LLDB_LOG(log, "== [UserExpression::Evaluate] Passed a context object of "
+                    "a reference type that can't be dereferenced, can't run expressions.");
+      error.SetErrorString("passed context object of an reference type cannot be deferenced");
+      return lldb::eExpressionSetupError;
+    }
+
+    ctx_obj = deref_ctx_sp.get();
+  }
+
   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();

lldb/test/API/commands/expression/context-object/TestContextObject.py

def test_context_object(self):
 
         (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)
def test_context_object(self):
 
         # Test that we retrieve the right global
         value = obj_val.EvaluateExpression("global.field")
         self.assertTrue(value.IsValid())
         self.assertSuccess(value.GetError())
         self.assertEqual(value.GetValueAsSigned(), 1111)
 
         #
+        # Test C++ reference-to-struct variable
+        #
+
+        obj_val = frame.FindVariable("cpp_struct_ref")
+        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.assertSuccess(value.GetError())
+        self.assertEqual(value.GetValueAsSigned(), 1111)
+
+        # Test functions evaluation
+        value = obj_val.EvaluateExpression("function()")
+        self.assertTrue(value.IsValid())
+        self.assertSuccess(value.GetError())
+        self.assertEqual(value.GetValueAsSigned(), 2222)
+
+        # Test that we retrieve the right global
+        value = obj_val.EvaluateExpression("global.field")
+        self.assertTrue(value.IsValid())
+        self.assertSuccess(value.GetError())
+        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")

lldb/test/API/commands/expression/context-object/main.cpp

 
 int global = 3333;
 
 int main()
 {
   cpp_namespace::CppStruct cpp_struct = cpp_namespace::GetCppStruct();
   cpp_struct.function();
 
+  cpp_namespace::CppStruct& cpp_struct_ref = cpp_struct;
+  cpp_struct_ref.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
 }