Added support for breakpoints with simple run-time conditions

Signed-off-by: Stefan Marr <git@stefan-marr.de>

Author: smarr

truffle/src/com.oracle.truffle.api.debug.test/src/com/oracle/truffle/api/debug/test/BreakpointTest.java

@@ -179,7 +179,7 @@ public void testBreakpointCondition() {
             expectDone();
             assertEquals(2, breakpoint.getHitCount());
 
-            breakpoint.setCondition(null); // remove the condition
+            breakpoint.setCondition((String) null); // remove the condition
             startEval(testSource);
             expectSuspended((SuspendedEvent event) -> {
                 assertSame(breakpoint, event.getBreakpoints().iterator().next());
@@ -328,8 +328,8 @@ public void testBreakpointsAtSamePlaceHitCorrectly() {
                     assertEquals(1, event.getBreakpoints().size());
                     Breakpoint hit = event.getBreakpoints().get(0);
                     assertSame(breakpoint1, hit);
-                    breakpoint1.setCondition(null);
-                    breakpoint2.setCondition(null);
+                    breakpoint1.setCondition((String) null);
+                    breakpoint2.setCondition((String) null);
                     assertEquals(out3, getOutput());
                 });
                 expectSuspended((SuspendedEvent event) -> {
@@ -801,7 +801,7 @@ public void testGlobalBreakpoints() throws Throwable {
             // O.K.
         }
         try {
-            newBP.setCondition(null);
+            newBP.setCondition((String) null);
             Assert.fail();
         } catch (IllegalStateException ex) {
             // O.K.

truffle/src/com.oracle.truffle.api.debug/src/com/oracle/truffle/api/debug/Breakpoint.java

@@ -143,6 +143,15 @@ public enum Kind {
         static final Kind[] VALUES = values();
     }
 
+    /**
+     * A simple way to have conditional breakpoints, without language-level expressions.
+     *
+     * This is meant to implement complex breakpoints for the debugger.
+     */
+    public interface SimpleCondition {
+        boolean evaluate();
+    }
+
     private static final Breakpoint BUILDER_INSTANCE = new Breakpoint();
 
     private final SuspendAnchor suspendAnchor;
@@ -159,10 +168,13 @@ public enum Kind {
     private volatile boolean resolved;
     private volatile int ignoreCount;
     private volatile boolean disposed;
+
     private volatile String condition;
     private volatile boolean global;
     private volatile GlobalBreakpoint roWrapper;
 
+    private volatile SimpleCondition simpleCondition;
+
     /* We use long instead of int in the implementation to avoid not hitting again on overflows. */
     private final AtomicLong hitCount = new AtomicLong();
     private volatile Assumption conditionUnchanged;
@@ -294,8 +306,18 @@ public boolean isResolved() {
      * @since 0.9
      */
     public synchronized void setCondition(String expression) {
-        boolean existsChanged = (this.condition == null) != (expression == null);
+        boolean existsChanged = conditionIsNotSet() != (expression == null);
+
         this.condition = expression;
+        this.simpleCondition = null;
+        invalidateConditionUnchangedAssumption(existsChanged);
+    }
+
+    private boolean conditionIsNotSet() {
+        return this.condition == null && this.simpleCondition == null;
+    }
+
+    private void invalidateConditionUnchangedAssumption(boolean existsChanged) {
         Assumption assumption = conditionUnchanged;
         if (assumption != null) {
             this.conditionUnchanged = null;
@@ -310,6 +332,13 @@ public synchronized void setCondition(String expression) {
         }
     }
 
+    public synchronized void setCondition(SimpleCondition condition) {
+        boolean existsChanged = conditionIsNotSet() != (condition == null);
+        this.simpleCondition = condition;
+        this.condition = null;
+        invalidateConditionUnchangedAssumption(existsChanged);
+    }
+
     /**
      * Returns the expression used to create the current breakpoint condition, null if no condition
      * set.
@@ -1162,7 +1191,7 @@ private abstract static class AbstractBreakpointNode extends DebuggerNode {
         private final Breakpoint breakpoint;
         protected final BranchProfile breakBranch = BranchProfile.create();
 
-        @Child private ConditionalBreakNode breakCondition;
+        @Child private AbstractConditionalBreakNode breakCondition;
         @CompilationFinal private Assumption conditionExistsUnchanged;
         @CompilationFinal(dimensions = 1) private DebuggerSession[] sessions;
         @CompilationFinal private Assumption sessionsUnchanged;
@@ -1173,8 +1202,13 @@ private abstract static class AbstractBreakpointNode extends DebuggerNode {
             initializeSessions();
             this.conditionExistsUnchanged = breakpoint.getConditionExistsUnchanged();
             if (breakpoint.condition != null) {
+                assert breakpoint.simpleCondition == null : "We don't support both conditions being set at the same time.";
                 this.breakCondition = new ConditionalBreakNode(context, breakpoint);
             }
+            if (breakpoint.simpleCondition != null) {
+                assert breakpoint.condition == null : "We don't support both conditions being set at the same time.";
+                this.breakCondition = new SimpleConditionalBreakNode(context, breakpoint);
+            }
         }
 
         private void initializeSessions() {
@@ -1275,7 +1309,7 @@ boolean testCondition(VirtualFrame frame) throws BreakpointConditionFailure {
             }
             if (breakCondition != null) {
                 try {
-                    return breakCondition.executeBreakCondition(frame, sessions);
+                    return breakCondition.shouldBreak(frame, sessions);
                 } catch (Throwable e) {
                     CompilerDirectives.transferToInterpreter();
                     throw new BreakpointConditionFailure(breakpoint, e);
@@ -1328,24 +1362,56 @@ public Throwable getConditionFailure() {
 
     }
 
-    private static class ConditionalBreakNode extends Node {
+    private abstract static class AbstractConditionalBreakNode extends Node {
+
+        protected final EventContext context;
+        protected final Breakpoint breakpoint;
+
+        @Child protected SetThreadSuspensionEnabledNode suspensionEnabledNode = SetThreadSuspensionEnabledNodeGen.create();
+
+        @CompilationFinal protected Assumption conditionUnchanged;
+
+        AbstractConditionalBreakNode(EventContext context, Breakpoint breakpoint) {
+            this.context = context;
+            this.breakpoint = breakpoint;
+            this.conditionUnchanged = breakpoint.getConditionUnchanged();
+        }
+
+        abstract boolean shouldBreak(VirtualFrame frame, DebuggerSession[] sessions);
+    }
+
+    private static class SimpleConditionalBreakNode extends AbstractConditionalBreakNode {
+        @CompilationFinal private SimpleCondition condition;
+
+        SimpleConditionalBreakNode(EventContext context, Breakpoint breakpoint) {
+            super(context, breakpoint);
+            this.condition = breakpoint.simpleCondition;
+        }
+
+        @Override
+        boolean shouldBreak(VirtualFrame frame, DebuggerSession[] sessions) {
+            if (!conditionUnchanged.isValid()) {
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                condition = breakpoint.simpleCondition;
+            }
+
+            return condition.evaluate();
+        }
+    }
+
+    private static class ConditionalBreakNode extends AbstractConditionalBreakNode {
 
         private static final Object[] EMPTY_ARRAY = new Object[0];
 
-        private final EventContext context;
-        private final Breakpoint breakpoint;
-        @Child private SetThreadSuspensionEnabledNode suspensionEnabledNode = SetThreadSuspensionEnabledNodeGen.create();
         @Child private DirectCallNode conditionCallNode;
         @Child private ExecutableNode conditionSnippet;
-        @CompilationFinal private Assumption conditionUnchanged;
 
         ConditionalBreakNode(EventContext context, Breakpoint breakpoint) {
-            this.context = context;
-            this.breakpoint = breakpoint;
-            this.conditionUnchanged = breakpoint.getConditionUnchanged();
+            super(context, breakpoint);
         }
 
-        boolean executeBreakCondition(VirtualFrame frame, DebuggerSession[] sessions) {
+        @Override
+        boolean shouldBreak(VirtualFrame frame, DebuggerSession[] sessions) {
             if ((conditionSnippet == null && conditionCallNode == null) || !conditionUnchanged.isValid()) {
                 CompilerDirectives.transferToInterpreterAndInvalidate();
                 initializeConditional(frame.materialize());