Add the ability to pass an EvaluateExpressionOptions when you make a UserExpression. This

isn't used in this commit but will be in a future commit.

llvm-svn: 251887

lldb/include/lldb/Expression/Expression.h

@@ -109,6 +109,8 @@ public:
     virtual bool
     NeedsVariableResolution () = 0;
 
+    virtual EvaluateExpressionOptions *GetOptions() { return nullptr; };
+
     //------------------------------------------------------------------
     /// Return the address of the function's JIT-compiled code, or
     /// LLDB_INVALID_ADDRESS if the function is not JIT compiled

lldb/include/lldb/Expression/LLVMUserExpression.h

@@ -35,15 +35,23 @@ namespace lldb_private
 class LLVMUserExpression : public UserExpression
 {
   public:
-    LLVMUserExpression(ExecutionContextScope &exe_scope, const char *expr, const char *expr_prefix,
+    LLVMUserExpression(ExecutionContextScope &exe_scope,
-                       lldb::LanguageType language, ResultType desired_type);
+                       const char *expr,
+                       const char *expr_prefix,
+                       lldb::LanguageType language,
+                       ResultType desired_type,
+                       const EvaluateExpressionOptions &options);
     ~LLVMUserExpression() override;
 
-    lldb::ExpressionResults Execute(Stream &error_stream, ExecutionContext &exe_ctx,
+    lldb::ExpressionResults Execute(Stream &error_stream,
-                                    const EvaluateExpressionOptions &options, lldb::UserExpressionSP &shared_ptr_to_me,
+                                    ExecutionContext &exe_ctx,
+                                    const EvaluateExpressionOptions &options,
+                                    lldb::UserExpressionSP &shared_ptr_to_me,
                                     lldb::ExpressionVariableSP &result) override;
 
-    bool FinalizeJITExecution(Stream &error_stream, ExecutionContext &exe_ctx, lldb::ExpressionVariableSP &result,
+    bool FinalizeJITExecution(Stream &error_stream,
+                              ExecutionContext &exe_ctx,
+                              lldb::ExpressionVariableSP &result,
                               lldb::addr_t function_stack_bottom = LLDB_INVALID_ADDRESS,
                               lldb::addr_t function_stack_top = LLDB_INVALID_ADDRESS) override;
 

lldb/include/lldb/Expression/UserExpression.h

@@ -24,6 +24,7 @@
 #include "lldb/Expression/Expression.h"
 #include "lldb/Expression/Materializer.h"
 #include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Target.h"
 
 namespace lldb_private
 {
@@ -67,7 +68,8 @@ public:
                     const char *expr,
                     const char *expr_prefix,
                     lldb::LanguageType language,
-                    ResultType desired_type);
+                    ResultType desired_type,
+                    const EvaluateExpressionOptions &options);
 
     //------------------------------------------------------------------
     /// Destructor
@@ -236,6 +238,12 @@ public:
         return true;
     }
     
+    EvaluateExpressionOptions *
+    GetOptions() override
+    {
+        return &m_options;
+    }
+    
     virtual lldb::ExpressionVariableSP
     GetResultAfterDematerialization(ExecutionContextScope *exe_scope)
     {
@@ -319,7 +327,7 @@ protected:
     std::string                                 m_expr_prefix;          ///< The text of the translation-level definitions, as provided by the user
     lldb::LanguageType                          m_language;             ///< The language to use when parsing (eLanguageTypeUnknown means use defaults)
     ResultType                                  m_desired_type;         ///< The type to coerce the expression's result to.  If eResultTypeAny, inferred from the expression.
-
+    EvaluateExpressionOptions                   m_options;              ///< Additional options provided by the user.
 };
 
 } // namespace lldb_private

lldb/include/lldb/Symbol/ClangASTContext.h

@@ -1184,7 +1184,8 @@ public:
     GetUserExpression (const char *expr,
                        const char *expr_prefix,
                        lldb::LanguageType language,
-                       Expression::ResultType desired_type) override;
+                       Expression::ResultType desired_type,
+                       const EvaluateExpressionOptions &options) override;
     
     FunctionCaller *
     GetFunctionCaller (const CompilerType &return_type,

lldb/include/lldb/Symbol/GoASTContext.h

@@ -398,7 +398,8 @@ class GoASTContextForExpr : public GoASTContext
   public:
     GoASTContextForExpr(lldb::TargetSP target) : m_target_wp(target) {}
     UserExpression *GetUserExpression(const char *expr, const char *expr_prefix, lldb::LanguageType language,
-                                      Expression::ResultType desired_type) override;
+                                      Expression::ResultType desired_type,
+                                      const EvaluateExpressionOptions &options) override;
 
   private:
     lldb::TargetWP m_target_wp;

lldb/include/lldb/Symbol/TypeSystem.h

@@ -496,7 +496,8 @@ public:
     GetUserExpression (const char *expr,
                        const char *expr_prefix,
                        lldb::LanguageType language,
-                       Expression::ResultType desired_type)
+                       Expression::ResultType desired_type,
+                       const EvaluateExpressionOptions &options)
     {
         return nullptr;
     }

lldb/include/lldb/Target/Target.h

@@ -1256,6 +1256,7 @@ public:
                                  const char *expr_prefix,
                                  lldb::LanguageType language,
                                  Expression::ResultType desired_type,
+                                 const EvaluateExpressionOptions &options,
                                  Error &error);
     
     // Creates a FunctionCaller for the given language, the rest of the parameters have the

lldb/source/Breakpoint/BreakpointLocation.cpp

@@ -293,6 +293,7 @@ BreakpointLocation::ConditionSaysStop (ExecutionContext &exe_ctx, Error &error)
                                                                             nullptr,
                                                                             language,
                                                                             Expression::eResultTypeAny,
+                                                                            EvaluateExpressionOptions(),
                                                                             error));
         if (error.Fail())
         {

lldb/source/Breakpoint/Watchpoint.cpp

@@ -387,6 +387,7 @@ Watchpoint::SetCondition (const char *condition)
                                                                    nullptr,
                                                                    lldb::eLanguageTypeUnknown,
                                                                    UserExpression::eResultTypeAny,
+                                                                   EvaluateExpressionOptions(),
                                                                    error));
         if (error.Fail())
         {

lldb/source/Expression/LLVMUserExpression.cpp

@@ -40,9 +40,13 @@
 
 using namespace lldb_private;
 
-LLVMUserExpression::LLVMUserExpression(ExecutionContextScope &exe_scope, const char *expr, const char *expr_prefix,
+LLVMUserExpression::LLVMUserExpression(ExecutionContextScope &exe_scope, 
-                                       lldb::LanguageType language, ResultType desired_type)
+                                       const char *expr, 
-    : UserExpression(exe_scope, expr, expr_prefix, language, desired_type),
+                                       const char *expr_prefix,
+                                       lldb::LanguageType language, 
+                                       ResultType desired_type, 
+                                       const EvaluateExpressionOptions &options)
+    : UserExpression(exe_scope, expr, expr_prefix, language, desired_type, options),
       m_stack_frame_bottom(LLDB_INVALID_ADDRESS),
       m_stack_frame_top(LLDB_INVALID_ADDRESS),
       m_transformed_text(),

lldb/source/Expression/UserExpression.cpp

@@ -45,13 +45,18 @@
 
 using namespace lldb_private;
 
-UserExpression::UserExpression(ExecutionContextScope &exe_scope, const char *expr, const char *expr_prefix,
+UserExpression::UserExpression (ExecutionContextScope &exe_scope,
-                               lldb::LanguageType language, ResultType desired_type)
+                                const char *expr,
-    : Expression(exe_scope),
+                                const char *expr_prefix,
+                                lldb::LanguageType language,
+                                ResultType desired_type,
+                                const EvaluateExpressionOptions &options) :
+      Expression(exe_scope),
       m_expr_text(expr),
       m_expr_prefix(expr_prefix ? expr_prefix : ""),
       m_language(language),
-      m_desired_type(desired_type)
+      m_desired_type(desired_type),
+      m_options (options)
 {
 }
 
@@ -219,6 +224,7 @@ UserExpression::Evaluate (ExecutionContext &exe_ctx,
                                                                                     full_prefix,
                                                                                     language,
                                                                                     desired_type,
+                                                                                    options,
                                                                                     error));
     if (error.Fail())
     {

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

@@ -55,9 +55,13 @@
 
 using namespace lldb_private;
 
-ClangUserExpression::ClangUserExpression(ExecutionContextScope &exe_scope, const char *expr, const char *expr_prefix,
+ClangUserExpression::ClangUserExpression (ExecutionContextScope &exe_scope,
-                                         lldb::LanguageType language, ResultType desired_type)
+                                          const char *expr,
-    : LLVMUserExpression(exe_scope, expr, expr_prefix, language, desired_type),
+                                          const char *expr_prefix,
+                                          lldb::LanguageType language,
+                                          ResultType desired_type,
+                                          const EvaluateExpressionOptions &options) :
+    LLVMUserExpression (exe_scope, expr, expr_prefix, language, desired_type, options),
     m_type_system_helper(*m_target_wp.lock().get())
 {
     switch (m_language)

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

@@ -118,7 +118,8 @@ public:
                          const char *expr,
                          const char *expr_prefix,
                          lldb::LanguageType language,
-                         ResultType desired_type);
+                         ResultType desired_type,
+                         const EvaluateExpressionOptions &options);
 
     ~ClangUserExpression() override;
 

lldb/source/Plugins/ExpressionParser/Go/GoUserExpression.cpp

@@ -218,8 +218,9 @@ LookupType(TargetSP target, ConstString name)
     return CompilerType();
 }
 GoUserExpression::GoUserExpression(ExecutionContextScope &exe_scope, const char *expr, const char *expr_prefix,
-                                   lldb::LanguageType language, ResultType desired_type)
+                                   lldb::LanguageType language, ResultType desired_type,
-    : UserExpression(exe_scope, expr, expr_prefix, language, desired_type)
+                                   const EvaluateExpressionOptions &options)
+    : UserExpression(exe_scope, expr, expr_prefix, language, desired_type, options)
 {
 }
 

lldb/source/Plugins/ExpressionParser/Go/GoUserExpression.h

@@ -66,7 +66,7 @@ class GoUserExpression : public UserExpression
 {
   public:
     GoUserExpression(ExecutionContextScope &exe_scope, const char *expr, const char *expr_prefix,
-                     lldb::LanguageType language, ResultType desired_type);
+                     lldb::LanguageType language, ResultType desired_type, const EvaluateExpressionOptions &options);
 
     virtual bool Parse(Stream &error_stream, ExecutionContext &exe_ctx, lldb_private::ExecutionPolicy execution_policy,
                        bool keep_result_in_memory, bool generate_debug_info) override;

lldb/source/Symbol/ClangASTContext.cpp

@@ -9227,13 +9227,14 @@ UserExpression *
 ClangASTContextForExpressions::GetUserExpression (const char *expr,
                    const char *expr_prefix,
                    lldb::LanguageType language,
-                   Expression::ResultType desired_type)
+                   Expression::ResultType desired_type,
+                   const EvaluateExpressionOptions &options)
 {
     TargetSP target_sp = m_target_wp.lock();
     if (!target_sp)
         return nullptr;
     
-    return new ClangUserExpression(*target_sp.get(), expr, expr_prefix, language, desired_type);
+    return new ClangUserExpression(*target_sp.get(), expr, expr_prefix, language, desired_type, options);
 }
 
 FunctionCaller *

lldb/source/Symbol/GoASTContext.cpp

@@ -1509,10 +1509,10 @@ GoASTContext::GetDWARFParser()
 
 UserExpression *
 GoASTContextForExpr::GetUserExpression(const char *expr, const char *expr_prefix, lldb::LanguageType language,
-                                       Expression::ResultType desired_type)
+                                       Expression::ResultType desired_type, const EvaluateExpressionOptions &options)
 {
     TargetSP target = m_target_wp.lock();
     if (target)
-        return new GoUserExpression(*target, expr, expr_prefix, language, desired_type);
+        return new GoUserExpression(*target, expr, expr_prefix, language, desired_type, options);
     return nullptr;
 }

lldb/source/Target/Target.cpp

@@ -1993,6 +1993,7 @@ Target::GetUserExpressionForLanguage(const char *expr,
                                      const char *expr_prefix,
                                      lldb::LanguageType language,
                                      Expression::ResultType desired_type,
+                                     const EvaluateExpressionOptions &options,
                                      Error &error)
 {
     Error type_system_error;
@@ -2006,7 +2007,7 @@ Target::GetUserExpressionForLanguage(const char *expr,
         return nullptr;
     }
     
-    user_expr = type_system->GetUserExpression(expr, expr_prefix, language, desired_type);
+    user_expr = type_system->GetUserExpression(expr, expr_prefix, language, desired_type, options);
     if (!user_expr)
         error.SetErrorStringWithFormat("Could not create an expression for language %s", Language::GetNameForLanguageType(language));