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

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).

Reviewers: teemperor, clayborg, jingham, zturner, labath, davide, spyffe, serge-sans-paille

Reviewed By: jingham

Subscribers: abidh, lldb-commits, leonid.mashinskiy

Tags: #lldb

Differential Revision: https://reviews.llvm.org/D55318

llvm-svn: 353149

Author: Aleksandr Urakov

lldb/include/lldb/API/SBValue.h

@@ -306,6 +306,13 @@ class LLDB_API SBValue {
   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;
+  lldb::SBValue EvaluateExpression(const char *expr,
+                                   const SBExpressionOptions &options,
+                                   const char *name) const;
+
   SBValue(const lldb::ValueObjectSP &value_sp);
 
   //------------------------------------------------------------------

lldb/include/lldb/Expression/ExpressionSourceCode.h

@@ -36,7 +36,8 @@ class ExpressionSourceCode {
   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

lldb/include/lldb/Expression/UserExpression.h

@@ -272,6 +272,16 @@ class UserExpression : public Expression {
   /// @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.
@@ -281,7 +291,8 @@ class UserExpression : public Expression {
            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,
+           ValueObject *ctx_obj = nullptr);
 
   static const Status::ValueType kNoResult =
       0x1001; ///< ValueObject::GetError() returns this if there is no result

lldb/include/lldb/Symbol/ClangASTContext.h

@@ -1060,7 +1060,8 @@ class ClangASTContextForExpressions : public ClangASTContext {
   GetUserExpression(llvm::StringRef expr, llvm::StringRef prefix,
                     lldb::LanguageType language,
                     Expression::ResultType desired_type,
-                    const EvaluateExpressionOptions &options) override;
+                    const EvaluateExpressionOptions &options,
+                    ValueObject *ctx_obj) override;
 
   FunctionCaller *GetFunctionCaller(const CompilerType &return_type,
                                     const Address &function_address,

lldb/include/lldb/Symbol/TypeSystem.h

@@ -449,7 +449,8 @@ class TypeSystem : public PluginInterface {
   GetUserExpression(llvm::StringRef expr, llvm::StringRef prefix,
                     lldb::LanguageType language,
                     Expression::ResultType desired_type,
-                    const EvaluateExpressionOptions &options) {
+                    const EvaluateExpressionOptions &options,
+                    ValueObject *ctx_obj) {
     return nullptr;
   }
 

lldb/include/lldb/Target/Target.h

@@ -1043,7 +1043,8 @@ class Target : public std::enable_shared_from_this<Target>,
   UserExpression *GetUserExpressionForLanguage(
       llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language,
       Expression::ResultType desired_type,
-      const EvaluateExpressionOptions &options, Status &error);
+      const EvaluateExpressionOptions &options,
+      ValueObject *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.
@@ -1107,7 +1108,8 @@ class Target : public std::enable_shared_from_this<Target>,
       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,
+      ValueObject *ctx_obj = nullptr);
 
   lldb::ExpressionVariableSP GetPersistentVariable(const ConstString &name);
 

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

@@ -0,0 +1,6 @@
+LEVEL = ../../make
+
+OBJC_SOURCES := main.m
+
+include $(LEVEL)/Makefile.rules
+LDFLAGS += -framework Foundation

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

@@ -0,0 +1,78 @@
+"""
+Tests expression evaluation in context of an objc class.
+"""
+
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+
+class ContextObjectObjcTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipUnlessDarwin
+    def test_context_object_objc(self):
+        """Tests expression evaluation in context of an objc class."""
+        self.build()
+
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self, '// Break here', self.main_source_spec)
+        frame = thread.GetFrameAtIndex(0)
+
+        #
+        # Test objc class variable
+        #
+
+        obj_val = frame.FindVariable("objcClass")
+        self.assertTrue(obj_val.IsValid())
+        obj_val = obj_val.Dereference()
+        self.assertTrue(obj_val.IsValid())
+
+        # Test an empty expression evaluation
+        value = obj_val.EvaluateExpression("")
+        self.assertFalse(value.IsValid())
+        self.assertFalse(value.GetError().Success())
+
+        # Test retrieving 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 if the self pointer is properly evaluated
+
+        # Test retrieving of an objcClass's property through the self pointer
+        value = obj_val.EvaluateExpression("self.property")
+        self.assertTrue(value.IsValid())
+        self.assertTrue(value.GetError().Success())
+        self.assertEqual(value.GetValueAsSigned(), 2222)
+
+        # Test objcClass's methods evaluation through the self pointer
+        value = obj_val.EvaluateExpression("[self method]")
+        self.assertTrue(value.IsValid())
+        self.assertTrue(value.GetError().Success())
+        self.assertEqual(value.GetValueAsSigned(), 3333)
+
+        # Test if we can use a computation result reference object correctly
+
+        obj_val = frame.EvaluateExpression("[ObjcClass createNew]")
+        self.assertTrue(obj_val.IsValid())
+        obj_val = obj_val.Dereference()
+        self.assertTrue(obj_val.IsValid())
+
+        # Test an expression evaluation on it
+        value = obj_val.EvaluateExpression("1")
+        self.assertTrue(value.IsValid())
+        self.assertTrue(value.GetError().Success())
+
+        # Test retrieving of a field on it
+        value = obj_val.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.m"
+        self.main_source_spec = lldb.SBFileSpec(self.main_source)

lldb/packages/Python/lldbsuite/test/expression_command/context-object-objc/main.m

@@ -0,0 +1,47 @@
+#import <Foundation/Foundation.h>
+
+@interface ObjcClass : NSObject {
+    int field;
+}
+
+@property int property;
+
++(ObjcClass*)createNew;
+
+-(id)init;
+
+-(int)method;
+
+@end
+
+@implementation ObjcClass
+
++(ObjcClass*)createNew {
+    return [ObjcClass new];
+}
+
+-(id)init {
+    self = [super init];
+    if (self) {
+        field = 1111;
+        _property = 2222;
+    }
+    return self;
+}
+
+-(int)method {
+    return 3333;
+}
+
+@end
+
+int main()
+{
+    @autoreleasepool {
+        ObjcClass* objcClass = [ObjcClass new];
+        
+        int field = 4444;
+        
+        return 0; // Break here
+    }
+}

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

@@ -0,0 +1,5 @@
+LEVEL = ../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

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

@@ -0,0 +1,145 @@
+"""
+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)