[lldb] Add support for evaluating expressions in static member functions

[teemperor]

Summary

At the moment the expression parser doesn't support evaluating expressions in static member functions
and just pretends the expression is evaluated within a non-member function. This causes that all static
members are inaccessible when doing unqualified name lookup.

This patch adds support for evaluating in static member functions. It essentially just does the same setup
as what LLDB is already doing for non-static member functions (i.e., wrapping the expression in a fake
member function) with the difference that we now mark the wrapping function as static (to prevent
access to non-static members).

[teemperor]

ping :)

[jarin]

This is looking great, thanks!

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

179

Non-blocking comment: Perhaps this should fall back into the static method context (rather than the generic context). That way, at least the static members would be visible to the expression.

[shafik]

LGTM besides the minor comments.

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

1919

ontext -> context

lldb/test/API/lang/cpp/stopped_in_static_member_function/main.cpp

2

You might want to throw in a static constexpr and static const member variable as well.

[teemperor]

Reopen because of the revert.

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h

private:
   /// expression LLDB is trying to evaluate).
   ///
   /// \param[in] context
   ///     The NameSearchContext to which the class should be added as a lookup
   ///     result.
   ///
   /// \param[in] type
   ///     The type of the class that serves as the evaluation context.
-  void AddContextClassType(NameSearchContext &context,
-                           const TypeFromUser &type);
+  ///
+  /// \param[in] context_method
+  ///     The member function declaration in which the expression is being
+  ///     evaluated or null if the expression is not evaluated in the context
+  ///     of a member function.
+  void AddContextClassType(NameSearchContext &context, const TypeFromUser &type,
+                           clang::CXXMethodDecl *context_method = nullptr);
 
   /// 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 TypeSystemClang to move to.
   /// \param[in] source
   ///     The TypeSystemClang to move from.  This is assumed to be going away.

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

if (method_decl) {
     QualType class_qual_type(class_decl->getTypeForDecl(), 0);
 
     TypeFromUser class_user_type(class_qual_type.getAsOpaquePtr(),
                                  function_decl_ctx.GetTypeSystem());
 
     LLDB_LOG(log, "  CEDM::FEVD Adding type for $__lldb_class: {1}",
              class_qual_type.getAsString());
 
-    AddContextClassType(context, class_user_type);
+    AddContextClassType(context, class_user_type, method_decl);
 
     if (method_decl->isInstance()) {
       // self is a pointer to the object
 
       QualType class_pointer_type =
           method_decl->getASTContext().getPointerType(class_qual_type);
 
       TypeFromUser self_user_type(class_pointer_type.getAsOpaquePtr(),
if (log) {
     LLDB_LOG(log,
              "  CEDM::FEVD Found {1} function {2} (description {3}), "
              "returned\n{4}",
              (function ? "specific" : "generic"), decl_name, ss.GetData(),
              ClangUtil::DumpDecl(function_decl));
   }
 }
 
-void ClangExpressionDeclMap::AddContextClassType(NameSearchContext &context,
-                                                 const TypeFromUser &ut) {
+void ClangExpressionDeclMap::AddContextClassType(
+    NameSearchContext &context, const TypeFromUser &ut,
+    CXXMethodDecl *context_method) {
   CompilerType copied_clang_type = GuardedCopyType(ut);
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   if (!copied_clang_type) {
     LLDB_LOG(log,
              "ClangExpressionDeclMap::AddThisType - Couldn't import the type");
 
     return;
   }
 
   if (copied_clang_type.IsAggregateType() &&
       copied_clang_type.GetCompleteType()) {
     CompilerType void_clang_type =
         m_clang_ast_context->GetBasicType(eBasicTypeVoid);
     CompilerType void_ptr_clang_type = void_clang_type.GetPointerType();
 
     CompilerType method_type = m_clang_ast_context->CreateFunctionType(
         void_clang_type, &void_ptr_clang_type, 1, false, 0);
 
     const bool is_virtual = false;
-    const bool is_static = false;
+    // If we evaluate an expression inside a static method, we also need to
+    // make our lldb_expr method static so that Clang denies access to
+    // non-static members.
+    // If we don't have a context_method we are evaluating within a context
+    // object and we can allow access to non-static members.
+    const bool is_static = context_method ? context_method->isStatic() : false;
     const bool is_inline = false;
     const bool is_explicit = false;
     const bool is_attr_used = true;
     const bool is_artificial = false;
 
     CXXMethodDecl *method_decl = m_clang_ast_context->AddMethodToCXXRecordType(
         copied_clang_type.GetOpaqueQualType(), "$__lldb_expr", nullptr,
         method_type, lldb::eAccessPublic, is_virtual, is_static, is_inline,

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionSourceCode.h

public:
   static const llvm::StringRef g_prefix_file_name;
   static const char *g_expression_prefix;
   static const char *g_expression_suffix;
 
   /// The possible ways an expression can be wrapped.
   enum class WrapKind {
     /// Wrapped in a non-static member function of a C++ class.
     CppMemberFunction,
+    /// Wrapped in a static member function of a C++ class.
+    CppStaticMemberFunction,
     /// Wrapped in an instance Objective-C method.
     ObjCInstanceMethod,
     /// Wrapped in a static Objective-C method.
     ObjCStaticMethod,
     /// Wrapped in a non-member function.
-    /// Note that this is also used for static member functions of a C++ class.
     Function
   };
 
   static ClangExpressionSourceCode *CreateWrapped(llvm::StringRef filename,
                                                   llvm::StringRef prefix,
                                                   llvm::StringRef body,
                                                   WrapKind wrap_kind) {
     return new ClangExpressionSourceCode(filename, "$__lldb_expr", prefix, body,

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionSourceCode.cpp

case WrapKind::Function:
                          "%s(void *$__lldb_arg)          \n"
                          "{                              \n"
                          "    %s;                        \n"
                          "%s"
                          "}                              \n",
                          module_imports.c_str(), m_name.c_str(),
                          lldb_local_var_decls.GetData(), tagged_body.c_str());
       break;
+    case WrapKind::CppStaticMemberFunction:
     case WrapKind::CppMemberFunction:
       wrap_stream.Printf("%s"
                          "void                                   \n"
                          "$__lldb_class::%s(void *$__lldb_arg)   \n"
                          "{                                      \n"
                          "    %s;                                \n"
                          "%s"
                          "}                                      \n",

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h

private:
   /// True if the expression is compiled as a C++ member function (true if it
   /// was parsed when exe_ctx was in a C++ method).
   bool m_in_cplusplus_method = false;
   /// True if the expression is compiled as an Objective-C method (true if it
   /// was parsed when exe_ctx was in an Objective-C method).
   bool m_in_objectivec_method = false;
   /// True if the expression is compiled as a static (or class) method
   /// (currently true if it was parsed when exe_ctx was in an Objective-C class
-  /// method).
+  /// method or static C++ member function).
   bool m_in_static_method = false;
   /// True if "this" or "self" must be looked up and passed in.  False if the
   /// expression doesn't really use them and they can be NULL.
   bool m_needs_object_ptr = false;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGUSEREXPRESSION_H

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

case lldb::eLanguageTypeObjC_plus_plus:
       m_in_objectivec_method = true;
       break;
     default:
       break;
     }
     m_needs_object_ptr = true;
   } else if (clang::CXXMethodDecl *method_decl =
           TypeSystemClang::DeclContextGetAsCXXMethodDecl(decl_context)) {
-    if (m_allow_cxx && method_decl->isInstance()) {
+    if (m_allow_cxx) {
+      if (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 "
-                                      "generic context";
+          const char *thisErrorString =
+              "Stopped in a C++ method, but 'this' "
 
           if (!variable_list_sp) {
             err.SetErrorString(thisErrorString);
             return;
           }
 
           lldb::VariableSP this_var_sp(
               variable_list_sp->FindVariable(ConstString("this")));
 
           if (!this_var_sp || !this_var_sp->IsInScope(frame) ||
               !this_var_sp->LocationIsValidForFrame(frame)) {
             err.SetErrorString(thisErrorString);
             return;
           }
         }
-
-      m_in_cplusplus_method = true;
         m_needs_object_ptr = true;
       }
+      m_in_cplusplus_method = true;
+      m_in_static_method = !method_decl->isInstance();
+    }
   } else if (clang::ObjCMethodDecl *method_decl =
                  TypeSystemClang::DeclContextGetAsObjCMethodDecl(
                      decl_context)) {
     if (m_allow_objc) {
       if (m_enforce_valid_object) {
         lldb::VariableListSP variable_list_sp(
             function_block->GetBlockVariableList(true));
 
diagnostic_manager.PutString(eDiagnosticSeverityError,
                                "Unknown error while loading modules needed for "
                                "current compilation unit.");
 }
 
 ClangExpressionSourceCode::WrapKind ClangUserExpression::GetWrapKind() const {
   assert(m_options.GetExecutionPolicy() != eExecutionPolicyTopLevel &&
          "Top level expressions aren't wrapped.");
   using Kind = ClangExpressionSourceCode::WrapKind;
-  if (m_in_cplusplus_method)
+  if (m_in_cplusplus_method) {
+    if (m_in_static_method)
+      return Kind::CppStaticMemberFunction;
     return Kind::CppMemberFunction;
-  else if (m_in_objectivec_method) {
+  } else if (m_in_objectivec_method) {
     if (m_in_static_method)
       return Kind::ObjCStaticMethod;
     return Kind::ObjCInstanceMethod;
   }
   // Not in any kind of 'special' function, so just wrap it in a normal C
   // function.
   return Kind::Function;
 }

lldb/test/API/lang/cpp/stopped_in_static_member_function/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/lang/cpp/stopped_in_static_member_function/TestStoppedInStaticMemberFunction.py

+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @no_debug_info_test
+    def test(self):
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, "// break in static member function", lldb.SBFileSpec("main.cpp"))
+
+        # Evaluate a static member and call a static member function.
+        self.expect_expr("static_member_var", result_type="int", result_value="2")
+        self.expect_expr("static_const_member_var", result_type="const int", result_value="3")
+        self.expect_expr("static_constexpr_member_var", result_type="const int", result_value="4")
+        self.expect_expr("static_func()", result_type="int", result_value="6")
+
+        # Check that accessing non-static members just reports a diagnostic.
+        self.expect("expr member_var", error=True,
+                    substrs=["invalid use of member 'member_var' in static member function"])
+        self.expect("expr member_func()", error=True,
+                    substrs=["call to non-static member function without an object argument"])
+        self.expect("expr this", error=True,
+                    substrs=["invalid use of 'this' outside of a non-static member function"])
+
+        # Continue to a non-static member function of the same class and make
+        # sure that evaluating non-static members now works.
+        breakpoint = self.target().BreakpointCreateBySourceRegex(
+            "// break in member function", lldb.SBFileSpec("main.cpp"))
+        self.assertNotEqual(breakpoint.GetNumResolvedLocations(), 0)
+        stopped_threads = lldbutil.continue_to_breakpoint(self.process(), breakpoint)
+
+        self.expect_expr("member_var", result_type="int", result_value="1")
+        self.expect_expr("member_func()", result_type="int", result_value="5")

lldb/test/API/lang/cpp/stopped_in_static_member_function/main.cpp

+struct A {
+  int member_var = 1;
+  static int static_member_var;
+  static const int static_const_member_var;
+  static constexpr int static_constexpr_member_var = 4;
+  int member_func() { return 5; }
+  static int static_func() { return 6; }
+
+  static int context_static_func() {
+    int i = static_member_var;
+    i += static_func();
+    return i; // break in static member function
+  }
+
+  int context_member_func() {
+    int i = member_var;
+    i += member_func();
+    return i; // break in member function
+  }
+};
+
+int A::static_member_var = 2;
+const int A::static_const_member_var = 3;
+constexpr int A::static_constexpr_member_var;
+
+int main() {
+  int i = A::context_static_func();
+  A a;
+  a.context_member_func();
+  return i;
+}