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

   //------------------------------------------------------------------
   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:

include/lldb/Target/ThreadPlanCallFunction.h

                         lldb::addr_t &start_load_addr,
                         lldb::addr_t &function_load_addr);
 
-  void DoTakedown(bool success);
+  virtual void DoTakedown(bool success);
 
   void SetBreakpoints();
 

include/lldb/Target/ThreadPlanCallUserExpression.h

 
   void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
 
+  void DidPush() override;
+
   void WillPop() override;
 
   lldb::StopInfoSP GetRealStopInfo() override;

   }
 
 protected:
+  void DoTakedown(bool success) override;
 private:
   lldb::UserExpressionSP
       m_user_expression_sp; // This is currently just used to ensure the

source/Target/ThreadPlanCallUserExpression.cpp

     ThreadPlanCallFunction::GetDescription(s, level);
 }
 
+void ThreadPlanCallUserExpression::DidPush() {
+  ThreadPlanCallFunction::DidPush();
+  if (m_user_expression_sp)
+    m_user_expression_sp->WillStartExecuting();
+}
+
 void ThreadPlanCallUserExpression::WillPop() {
   ThreadPlanCallFunction::WillPop();
   if (m_user_expression_sp)

 
   return stop_info_sp;
 }
+
+void ThreadPlanCallUserExpression::DoTakedown(bool success) {
+  ThreadPlanCallFunction::DoTakedown(success);
+  m_user_expression_sp->DidFinishExecuting();
+}