Add DidStartExecuting/WillFinishExecuting methods to Expression.

[lhames]

Summary

These methods can be used by the derived expression types to perform expression
specific and/or language specific actions before and after the expression runs.
(ThreadPlanCallUserExpression is modified to call these methods on the
expression immediately before/after execution of the expression).

The immediate motivation is allowing Swift expressions to notify the swift
runtime that exclusivity enforcement should be suspended while the expression
runs (we want LLDB expressions to be able to access variables even when they're
considered exclusively owned by someone else in the original program).

[jingham]

So there's one subtly here that doesn't matter at present but will trip you up if the WillStartExecuting needs to call a function - for instance. The problem is that when you are in the ThreadPlan constructor, the thread plan is not yet on the plan stack of the thread it is going to run on. If you wanted to call a function in WillStartExecuting, then what you'd do in make another ThreadPlanCallFunction and push it on the stack, then when the process continued, that plan would run and do it's job. But since you are still in the parent plan's constructor you would in fact be pushing the subsidiary plan on first, and then the parent plan second, and things wouldn't work.

The ThreadPlan has another method: DidPush that gets called when the plan is actually pushed onto the thread plan stack. That would be a better place to put this hook, since at that point everything is regular.

Other than that, everything is fine.

[lhames]

Updated based on feedback.

[jingham]

Yup, that's right.

[lhames]

Thanks Jim!

Committed in r302314.

include/lldb/Expression/Expression.h

public:
   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::addr_t StartAddress() { return m_jit_start_addr; }
 
+  //------------------------------------------------------------------
+  /// Called to notify the expression that it is about to be executed.
+  //------------------------------------------------------------------
+  virtual void WillStartExecuting() {}
+
+  //------------------------------------------------------------------
+  /// Called to notify the expression that its execution has finished.
+  //------------------------------------------------------------------
+  virtual void DidFinishExecuting() {}
+
   virtual ExpressionTypeSystemHelper *GetTypeSystemHelper() { return nullptr; }
 
 protected:
   lldb::TargetWP m_target_wp; /// Expression's always have to have a target...
   lldb::ProcessWP m_jit_process_wp; /// An expression might have a process, but
                                     /// it doesn't need to (e.g. calculator
                                     /// mode.)
   lldb::addr_t m_jit_start_addr; ///< The address of the JITted function within

include/lldb/Target/ThreadPlanCallFunction.h

protected:
   bool DoPlanExplainsStop(Event *event_ptr) override;
 
   virtual void SetReturnValue();
 
   bool ConstructorSetup(Thread &thread, ABI *&abi,
                         lldb::addr_t &start_load_addr,
                         lldb::addr_t &function_load_addr);
 
-  void DoTakedown(bool success);
+  virtual void DoTakedown(bool success);
 
   void SetBreakpoints();
 
   void ClearBreakpoints();
 
   bool BreakpointsExplainStop();
 
   bool m_valid;

include/lldb/Target/ThreadPlanCallUserExpression.h

public:
 
   void TransferExpressionOwnership() { m_manage_materialization = true; }
 
   lldb::ExpressionVariableSP GetExpressionVariable() override {
     return m_result_var_sp;
   }
 
 protected:
+  void DoTakedown(bool success) override;
 private:
   lldb::UserExpressionSP
       m_user_expression_sp; // This is currently just used to ensure the
                             // User expression the initiated this ThreadPlan
                             // lives as long as the thread plan does.
   bool m_manage_materialization = false;
   lldb::ExpressionVariableSP
       m_result_var_sp; // If we are left to manage the materialization,
                        // then stuff the result expression variable here.
 
   DISALLOW_COPY_AND_ASSIGN(ThreadPlanCallUserExpression);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ThreadPlanCallUserExpression_h_

source/Target/ThreadPlanCallUserExpression.cpp

ThreadPlanCallUserExpression::ThreadPlanCallUserExpression(
     const EvaluateExpressionOptions &options,
     lldb::UserExpressionSP &user_expression_sp)
     : ThreadPlanCallFunction(thread, function, CompilerType(), args, options),
       m_user_expression_sp(user_expression_sp) {
   // User expressions are generally "User generated" so we should set them up to
   // stop when done.
   SetIsMasterPlan(true);
   SetOkayToDiscard(false);
+  m_user_expression_sp->WillStartExecuting();
 }
 
 ThreadPlanCallUserExpression::~ThreadPlanCallUserExpression() {}
 
 void ThreadPlanCallUserExpression::GetDescription(
     Stream *s, lldb::DescriptionLevel level) {
   if (level == eDescriptionLevelBrief)
     s->Printf("User Expression thread plan");
if (stop_info_sp) {
     StreamString s;
 
     if (checkers && checkers->DoCheckersExplainStop(addr, s))
       stop_info_sp->SetDescription(s.GetData());
   }
 
   return stop_info_sp;
 }
+
+void ThreadPlanCallUserExpression::DoTakedown(bool success) {
+  ThreadPlanCallFunction::DoTakedown(success);
+  m_user_expression_sp->DidFinishExecuting();
+}