Added support for breakpoint conditions. I also had to separate the "run the expression" part of ClangFunction::Execute from the "Gather the expression result" so that in the case of the Breakpoint condition I can move the condition evaluation into the normal thread plan processing.

Also added support for remembering the "last set breakpoint" so that "break modify" will act on the last set breakpoint.

llvm-svn: 116542

Author: jimingham

lldb/include/lldb/Breakpoint/Breakpoint.h

@@ -370,12 +370,41 @@ class Breakpoint:
     ClearCallback ();
 
     //------------------------------------------------------------------
-    /// Set the condition expression to be checked when the breakpoint is hit.
-    /// @param[in] expression
-    ///    The method that will get called when the breakpoint is hit.
+    /// Set the breakpoint's condition.
+    ///
+    /// @param[in] condition
+    ///    The condition expression to evaluate when the breakpoint is hit.
+    ///    Pass in NULL to clear the condition.
     //------------------------------------------------------------------
-    void
-    SetCondition (void *expression);
+    void SetCondition (const char *condition);
+    
+    //------------------------------------------------------------------
+    /// Test the breakpoint condition in the Execution context passed in.
+    ///
+    /// @param[in] exe_ctx
+    ///    The execution context in which to evaluate this expression.
+    /// 
+    /// @param[in] break_loc_sp
+    ///    A shared pointer to the location that we are testing thsi condition for.
+    ///
+    /// @param[in] error
+    ///    Error messages will be written to this stream.
+    ///
+    /// @return
+    ///     A thread plan to run to test the condition or NULL if no condition.
+    //------------------------------------------------------------------
+    ThreadPlan *GetThreadPlanToTestCondition (ExecutionContext &exe_ctx, 
+                                              lldb::BreakpointLocationSP break_loc_sp, 
+                                              Stream &error);
+    
+    //------------------------------------------------------------------
+    /// Return a pointer to the text of the condition expression.
+    ///
+    /// @return
+    ///    A pointer to the condition expression text, or NULL if no
+    //     condition has been set.
+    //------------------------------------------------------------------
+    const char *GetConditionText ();
 
     //------------------------------------------------------------------
     // The next section are various utility functions.

lldb/include/lldb/Breakpoint/BreakpointLocation.h

@@ -160,13 +160,35 @@ class BreakpointLocation : public StoppointLocation
     ClearCallback ();
 
     //------------------------------------------------------------------
-    /// Set the condition expression to be checked when the breakpoint is hit.
+    /// Set the breakpoint location's condition.
     ///
-    /// @param[in] expression
-    ///    The method that will get called when the breakpoint is hit.
+    /// @param[in] condition
+    ///    The condition expression to evaluate when the breakpoint is hit.
     //------------------------------------------------------------------
-    void
-    SetCondition (void *condition);
+    void SetCondition (const char *condition);
+    
+    //------------------------------------------------------------------
+    /// Test the breakpoint location's condition in the Execution context passed in.
+    ///
+    /// @param[in] exe_ctx
+    ///    The execution context in which to evaluate this expression.
+    /// 
+    /// @param[in] error
+    ///    Error messages will be written to this stream.
+    ///
+    /// @return
+    ///     A thread plan to run to test the condition, or NULL if there is no condition.
+    //------------------------------------------------------------------
+    ThreadPlan *GetThreadPlanToTestCondition (ExecutionContext &exe_ctx, Stream &error);
+    
+    //------------------------------------------------------------------
+    /// Return a pointer to the text of the condition expression.
+    ///
+    /// @return
+    ///    A pointer to the condition expression text, or NULL if no
+    //     condition has been set.
+    //------------------------------------------------------------------
+    const char *GetConditionText ();
 
 
     //------------------------------------------------------------------
@@ -211,6 +233,9 @@ class BreakpointLocation : public StoppointLocation
     //------------------------------------------------------------------
     bool
     IsResolved () const;
+    
+    lldb::BreakpointSiteSP
+    GetBreakpointSite() const;
 
     //------------------------------------------------------------------
     // The next section are generic report functions.

lldb/include/lldb/Breakpoint/BreakpointOptions.h

@@ -18,6 +18,7 @@
 #include "lldb/lldb-private.h"
 #include "lldb/Core/Baton.h"
 #include "lldb/Core/StringList.h"
+#include "lldb/Expression/ClangUserExpression.h"
 
 namespace lldb_private {
 
@@ -88,7 +89,46 @@ class BreakpointOptions
     Baton *GetBaton ();
     const Baton *GetBaton () const;
     void ClearCallback ();
-
+    
+    //------------------------------------------------------------------
+    // Condition
+    //------------------------------------------------------------------
+    //------------------------------------------------------------------
+    /// Set the breakpoint option's condition.
+    ///
+    /// @param[in] condition
+    ///    The condition expression to evaluate when the breakpoint is hit.
+    //------------------------------------------------------------------
+    void SetCondition (const char *condition);
+    
+    //------------------------------------------------------------------
+    /// Test the breakpoint condition in the Execution context passed in.
+    ///
+    /// @param[in] exe_ctx
+    ///    The execution context in which to evaluate this expression.
+    /// 
+    /// @param[in] break_loc_sp
+    ///    A shared pointer to the location that we are testing thsi condition for.
+    ///
+    /// @param[in] error
+    ///    Error messages will be written to this stream.
+    ///
+    /// @return
+    ///     A thread plan to run to test the condition, or NULL if there is no thread plan.
+    //------------------------------------------------------------------
+    ThreadPlan *GetThreadPlanToTestCondition (ExecutionContext &exe_ctx, 
+                                              lldb::BreakpointLocationSP break_loc_sp, 
+                                              Stream &error);
+    
+    //------------------------------------------------------------------
+    /// Return a pointer to the text of the condition expression.
+    ///
+    /// @return
+    ///    A pointer to the condition expression text, or NULL if no
+    //     condition has been set.
+    //------------------------------------------------------------------
+    const char *GetConditionText ();
+    
     //------------------------------------------------------------------
     // Enabled/Ignore Count
     //------------------------------------------------------------------
@@ -107,6 +147,12 @@ class BreakpointOptions
     void
     SetEnabled (bool enabled);
 
+    //------------------------------------------------------------------
+    /// Set the breakpoint to ignore the next \a count breakpoint hits.
+    /// @param[in] count
+    ///    The number of breakpoint hits to ignore.
+    //------------------------------------------------------------------
+
     void
     SetIgnoreCount (uint32_t n);
 
@@ -118,12 +164,6 @@ class BreakpointOptions
     uint32_t
     GetIgnoreCount () const;
 
-    //------------------------------------------------------------------
-    /// Set the breakpoint to ignore the next \a count breakpoint hits.
-    /// @param[in] count
-    ///    The number of breakpoint hits to ignore.
-    //------------------------------------------------------------------
-
     //------------------------------------------------------------------
     /// Return the current thread spec for this option.  This will return NULL if the no thread
     /// specifications have been set for this Option yet.     
@@ -218,6 +258,7 @@ class BreakpointOptions
     bool m_enabled;
     uint32_t m_ignore_count; // Number of times to ignore this breakpoint
     std::auto_ptr<ThreadSpec> m_thread_spec_ap; // Thread for which this breakpoint will take
+    std::auto_ptr<ClangUserExpression> m_condition_ap;  // The condition to test.
 
 };
 

lldb/include/lldb/Core/Event.h

@@ -134,22 +134,52 @@ class Event
     Dump (Stream *s) const;
 
     EventData *
-    GetData ();
+    GetData ()
+    {
+        return m_data_ap.get();
+    }
 
     const EventData *
-    GetData () const;
+    GetData () const
+    {
+        return m_data_ap.get();
+    }
+    
+    void
+    SetData (EventData *new_data)
+    {
+        m_data_ap.reset (new_data);
+    }
 
     uint32_t
-    GetType () const;
+    GetType () const
+    {
+        return m_type;
+    }
+    
+    void
+    SetType (uint32_t new_type)
+    {
+        m_type = new_type;
+    }
 
     Broadcaster *
-    GetBroadcaster () const;
-
+    GetBroadcaster () const
+    {
+        return m_broadcaster;
+    }
+    
     bool
-    BroadcasterIs (Broadcaster *broadcaster);
+    BroadcasterIs (Broadcaster *broadcaster)
+    {
+        return broadcaster == m_broadcaster;
+    }
 
     void
-    Clear();
+    Clear()
+    {
+        m_data_ap.reset();
+    }
 
 
 private:
@@ -164,7 +194,11 @@ class Event
     // know about it update the contained broadcaster so that events can be
     // popped off one queue and re-broadcast to others.
     void
-    SetBroadcaster (Broadcaster *broadcaster);
+    SetBroadcaster (Broadcaster *broadcaster)
+    {
+        m_broadcaster = broadcaster;
+    }
+
 
     Broadcaster *   m_broadcaster;  // The broadcaster that sent this event
     uint32_t        m_type;         // The bit describing this event

lldb/include/lldb/Expression/ClangExpressionVariable.h

@@ -89,7 +89,8 @@ struct ClangExpressionVariable
     /// The following values should stay valid for the life of the variable
     //----------------------------------------------------------------------
     std::string             m_name;         ///< The name of the variable
-    TypeFromUser            m_user_type;    ///< The type of the variable according to some LLDB context; NULL if the type hasn't yet been migrated to one
+    TypeFromUser            m_user_type;    ///< The type of the variable according to some LLDB context; 
+                                            ///< NULL if the type hasn't yet been migrated to one
 
     //----------------------------------------------------------------------
     /// The following values indicate where the variable originally came from

lldb/include/lldb/Expression/ClangUserExpression.h

@@ -24,6 +24,7 @@
 #include "lldb/lldb-private.h"
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Expression/ClangExpression.h"
+#include "lldb/Expression/ClangExpressionVariable.h"
 
 #include "llvm/ExecutionEngine/JITMemoryManager.h"
 
@@ -90,7 +91,15 @@ class ClangUserExpression : public ClangExpression
     bool
     Execute (Stream &error_stream,
              ExecutionContext &exe_ctx,
-             ClangExpressionVariable *& result);
+             ClangExpressionVariable *&result);
+             
+    ThreadPlan *
+    GetThreadPlanToExecuteJITExpression (Stream &error_stream,
+                                 ExecutionContext &exe_ctx);
+    bool
+    FinalizeJITExecution (Stream &error_stream,
+                        ExecutionContext &exe_ctx,
+                        ClangExpressionVariable *&result);
 
     //------------------------------------------------------------------
     /// Return the string that the parser should parse.  Must be a full
@@ -102,6 +111,15 @@ class ClangUserExpression : public ClangExpression
         return m_transformed_text.c_str();
     }
 
+    //------------------------------------------------------------------
+    /// Return the string that the user typed.
+    //------------------------------------------------------------------
+    const char *
+    GetUserText ()
+    {
+        return m_expr_text.c_str();
+    }
+    
     //------------------------------------------------------------------
     /// Return the function name that should be used for executing the
     /// expression.  Text() should contain the definition of this
@@ -181,6 +199,12 @@ class ClangUserExpression : public ClangExpression
     //------------------------------------------------------------------
     void
     ScanContext(ExecutionContext &exe_ctx);
+
+    bool
+    PrepareToExecuteJITExpression (Stream &error_stream,
+                                       ExecutionContext &exe_ctx,
+                                       lldb::addr_t &struct_address,
+                                       lldb::addr_t object_ptr);
 
     std::string                                 m_expr_text;            ///< The text of the expression, as typed by the user
     std::string                                 m_transformed_text;     ///< The text of the expression, as send to the parser

lldb/include/lldb/Target/Process.h

@@ -232,6 +232,7 @@ class Process :
     public ProcessInstanceSettings
 {
 friend class ThreadList;
+friend class ClangFunction; // For WaitForStateChangeEventsPrivate
 
 public:
 
@@ -316,7 +317,6 @@ friend class ThreadList;
             static bool
             SetUpdateStateOnRemoval (Event *event_ptr);
 
-
        private:
 
             void
@@ -1592,12 +1592,12 @@ friend class ThreadList;
 
     DynamicCheckerFunctions *GetDynamicCheckers()
     {
-        return m_dynamic_checkers.get();
+        return m_dynamic_checkers_ap.get();
     }
 
     void SetDynamicCheckers(DynamicCheckerFunctions *dynamic_checkers)
     {
-        m_dynamic_checkers.reset(dynamic_checkers);
+        m_dynamic_checkers_ap.reset(dynamic_checkers);
     }
 
     //------------------------------------------------------------------
@@ -1646,7 +1646,7 @@ friend class ThreadList;
     BreakpointSiteList          m_breakpoint_site_list; ///< This is the list of breakpoint locations we intend
                                                         ///< to insert in the target.
     ClangPersistentVariables    m_persistent_vars;      ///< These are the persistent variables associated with this process for the expression parser.
-    std::auto_ptr<DynamicCheckerFunctions>  m_dynamic_checkers; ///< The functions used by the expression parser to validate data that expressions use.
+    std::auto_ptr<DynamicCheckerFunctions>  m_dynamic_checkers_ap; ///< The functions used by the expression parser to validate data that expressions use.
     UnixSignals                 m_unix_signals;         /// This is the current signal set for this process.
     ConstString                 m_target_triple;
     lldb::ABISP                 m_abi_sp;

lldb/include/lldb/Target/StopInfo.h

@@ -90,6 +90,10 @@ class StopInfo
     static lldb::StopInfoSP
     CreateStopReasonWithBreakpointSiteID (Thread &thread, lldb::break_id_t break_id);
 
+    // This creates a StopInfo for the thread where the should_stop is already set, and won't be recalculated.
+    static lldb::StopInfoSP
+    CreateStopReasonWithBreakpointSiteID (Thread &thread, lldb::break_id_t break_id, bool should_stop);
+
     static lldb::StopInfoSP
     CreateStopReasonWithWatchpointID (Thread &thread, lldb::break_id_t watch_id);
 

lldb/include/lldb/Target/Target.h

@@ -204,6 +204,12 @@ class Target :
 
     const BreakpointList &
     GetBreakpointList(bool internal = false) const;
+    
+    lldb::BreakpointSP
+    GetLastCreatedBreakpoint ()
+    {
+        return m_last_created_breakpoint;
+    }
 
     lldb::BreakpointSP
     GetBreakpointByID (lldb::break_id_t break_id);
@@ -443,6 +449,7 @@ class Target :
     SectionLoadList m_section_load_list;
     BreakpointList  m_breakpoint_list;
     BreakpointList  m_internal_breakpoint_list;
+    lldb::BreakpointSP m_last_created_breakpoint;
     // We want to tightly control the process destruction process so
     // we can correctly tear down everything that we need to, so the only
     // class that knows about the process lifespan is this target class.