[GR-51550] Added callback for method exit and use suspendHere() to suspend immediately.

PullRequest: graal/21733

Author: entlicher

espresso/src/com.oracle.truffle.espresso.jdwp/src/com/oracle/truffle/espresso/jdwp/api/VMEventListenerImpl.java

@@ -36,6 +36,7 @@
 import com.oracle.truffle.api.interop.InvalidArrayIndexException;
 import com.oracle.truffle.api.interop.UnknownIdentifierException;
 import com.oracle.truffle.api.interop.UnsupportedMessageException;
+import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.espresso.jdwp.impl.BreakpointInfo;
 import com.oracle.truffle.espresso.jdwp.impl.ClassPrepareRequest;
 import com.oracle.truffle.espresso.jdwp.impl.DebuggerController;
@@ -161,13 +162,13 @@ public void clearAllBreakpointRequests() {
 
     @Override
     @TruffleBoundary
-    public boolean onFieldModification(FieldRef field, Object receiver, Object value) {
+    public boolean onFieldModification(FieldRef field, Node node, Object receiver, Object value) {
         boolean active = false;
         for (FieldBreakpoint info : field.getFieldBreakpointInfos()) {
             if (info.isModificationBreakpoint()) {
                 // OK, tell the Debug API to suspend the thread now
                 debuggerController.prepareFieldBreakpoint(new FieldBreakpointEvent((FieldBreakpointInfo) info, receiver, value));
-                debuggerController.suspend(context.asGuestThread(Thread.currentThread()));
+                debuggerController.suspendHere(node);
                 active = true;
             }
         }
@@ -176,13 +177,13 @@ public boolean onFieldModification(FieldRef field, Object receiver, Object value
 
     @Override
     @TruffleBoundary
-    public boolean onFieldAccess(FieldRef field, Object receiver) {
+    public boolean onFieldAccess(FieldRef field, Node node, Object receiver) {
         boolean active = false;
         for (FieldBreakpoint info : field.getFieldBreakpointInfos()) {
             if (info.isAccessBreakpoint()) {
                 // OK, tell the Debug API to suspend the thread now
                 debuggerController.prepareFieldBreakpoint(new FieldBreakpointEvent((FieldBreakpointInfo) info, receiver));
-                debuggerController.suspend(context.asGuestThread(Thread.currentThread()));
+                debuggerController.suspendHere(node);
                 active = true;
             }
         }
@@ -191,7 +192,7 @@ public boolean onFieldAccess(FieldRef field, Object receiver) {
 
     @Override
     @TruffleBoundary
-    public boolean onMethodEntry(MethodRef method, Object scope) {
+    public boolean onMethodEntry(MethodRef method, Node node, Object scope) {
         boolean active = false;
         // collect variable information from scope
         List<MethodVariable> variables = new ArrayList<>(1);
@@ -216,7 +217,7 @@ public boolean onMethodEntry(MethodRef method, Object scope) {
             if (hook.onMethodEnter(method, variables.toArray(new MethodVariable[variables.size()]))) {
                 // OK, tell the Debug API to suspend the thread now
                 debuggerController.prepareMethodBreakpoint(new MethodBreakpointEvent((MethodBreakpointInfo) hook, null));
-                debuggerController.suspend(context.asGuestThread(Thread.currentThread()));
+                debuggerController.suspendHere(node);
                 active = true;
 
                 switch (hook.getKind()) {
@@ -236,13 +237,13 @@ public boolean onMethodEntry(MethodRef method, Object scope) {
 
     @Override
     @TruffleBoundary
-    public boolean onMethodReturn(MethodRef method, Object returnValue) {
+    public boolean onMethodReturn(MethodRef method, Node node, Object returnValue) {
         boolean active = false;
         for (MethodHook hook : method.getMethodHooks()) {
             if (hook.onMethodExit(method, returnValue)) {
                 // OK, tell the Debug API to suspend the thread now
                 debuggerController.prepareMethodBreakpoint(new MethodBreakpointEvent((MethodBreakpointInfo) hook, returnValue));
-                debuggerController.suspend(context.asGuestThread(Thread.currentThread()));
+                debuggerController.suspendHere(node);
                 active = true;
 
                 switch (hook.getKind()) {

espresso/src/com.oracle.truffle.espresso.jdwp/src/com/oracle/truffle/espresso/jdwp/api/VMListener.java

@@ -22,6 +22,8 @@
  */
 package com.oracle.truffle.espresso.jdwp.api;
 
+import com.oracle.truffle.api.nodes.Node;
+
 public interface VMListener {
 
     void vmStarted(boolean suspend);
@@ -57,7 +59,7 @@ public interface VMListener {
      * @param value the new field value
      * @return true if a breakpoint should be hit due to the modification
      */
-    boolean onFieldModification(FieldRef field, Object receiver, Object value);
+    boolean onFieldModification(FieldRef field, Node node, Object receiver, Object value);
 
     /**
      * This method will be called when a field is about to be accessed. The method will determine if
@@ -67,7 +69,7 @@ public interface VMListener {
      * @param receiver owner of the field
      * @return true if a breakpoint should be hit due to the modification
      */
-    boolean onFieldAccess(FieldRef field, Object receiver);
+    boolean onFieldAccess(FieldRef field, Node node, Object receiver);
 
     /**
      * This method will be called when a method is entered iff there is an active
@@ -79,7 +81,7 @@ public interface VMListener {
      *            local variables in scope
      * @return true a breakpoint should be hit on method entry
      */
-    boolean onMethodEntry(MethodRef method, Object scope);
+    boolean onMethodEntry(MethodRef method, Node node, Object scope);
 
     /**
      * This method will be called when a method is about to return iff there is an active
@@ -90,7 +92,7 @@ public interface VMListener {
      * @param returnValue the return value
      * @return true if a breakpoint should be hit on method exit
      */
-    boolean onMethodReturn(MethodRef method, Object returnValue);
+    boolean onMethodReturn(MethodRef method, Node node, Object returnValue);
 
     /**
      * This method should be called when when the monitor wait(timeout) method is invoked in the

espresso/src/com.oracle.truffle.espresso.jdwp/src/com/oracle/truffle/espresso/jdwp/impl/DebuggerController.java

@@ -547,6 +547,11 @@ public void resumeAll() {
         }
     }
 
+    public void suspendHere(Node node) {
+        boolean success = debuggerSession.suspendHere(node);
+        assert success : "Immediate suspend was not successful, must be called on language execution thread";
+    }
+
     public void suspend(Object guestThread) {
         SimpleLock suspendLock = getSuspendLock(guestThread);
         synchronized (suspendLock) {

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/nodes/BytecodeNode.java

@@ -1279,7 +1279,8 @@ private Object executeBodyFromBCI(VirtualFrame frame, int startBCI, int startTop
                         }
                         Object returnValue = getReturnValueAsObject(frame, top);
                         if (instrument != null) {
-                            instrument.exitAt(frame, statementIndex, returnValue);
+                            instrument.notifyExit(frame, this, returnValue);
+                            instrument.notifyStatementExit(frame, statementIndex, returnValue);
                         }
 
                         // This branch must not be a loop exit.
@@ -2739,64 +2740,64 @@ private int putField(VirtualFrame frame, int top, Field field, int curBCI, int o
             case 'Z':
                 boolean booleanValue = stackIntToBoolean(popInt(frame, top - 1));
                 if (instrumentation != null) {
-                    instrumentation.notifyFieldModification(frame, statementIndex, field, receiver, booleanValue);
+                    instrumentation.notifyFieldModification(frame, statementIndex, field, this, receiver, booleanValue);
                 }
                 InterpreterToVM.setFieldBoolean(booleanValue, receiver, field);
                 break;
             case 'B':
                 byte byteValue = (byte) popInt(frame, top - 1);
                 if (instrumentation != null) {
-                    instrumentation.notifyFieldModification(frame, statementIndex, field, receiver, byteValue);
+                    instrumentation.notifyFieldModification(frame, statementIndex, field, this, receiver, byteValue);
                 }
                 InterpreterToVM.setFieldByte(byteValue, receiver, field);
                 break;
             case 'C':
                 char charValue = (char) popInt(frame, top - 1);
                 if (instrumentation != null) {
-                    instrumentation.notifyFieldModification(frame, statementIndex, field, receiver, charValue);
+                    instrumentation.notifyFieldModification(frame, statementIndex, field, this, receiver, charValue);
                 }
                 InterpreterToVM.setFieldChar(charValue, receiver, field);
                 break;
             case 'S':
                 short shortValue = (short) popInt(frame, top - 1);
                 if (instrumentation != null) {
-                    instrumentation.notifyFieldModification(frame, statementIndex, field, receiver, shortValue);
+                    instrumentation.notifyFieldModification(frame, statementIndex, field, this, receiver, shortValue);
                 }
                 InterpreterToVM.setFieldShort(shortValue, receiver, field);
                 break;
             case 'I':
                 int intValue = popInt(frame, top - 1);
                 if (instrumentation != null) {
-                    instrumentation.notifyFieldModification(frame, statementIndex, field, receiver, intValue);
+                    instrumentation.notifyFieldModification(frame, statementIndex, field, this, receiver, intValue);
                 }
                 InterpreterToVM.setFieldInt(intValue, receiver, field);
                 break;
             case 'D':
                 double doubleValue = popDouble(frame, top - 1);
                 if (instrumentation != null) {
-                    instrumentation.notifyFieldModification(frame, statementIndex, field, receiver, doubleValue);
+                    instrumentation.notifyFieldModification(frame, statementIndex, field, this, receiver, doubleValue);
                 }
                 InterpreterToVM.setFieldDouble(doubleValue, receiver, field);
                 break;
             case 'F':
                 float floatValue = popFloat(frame, top - 1);
                 if (instrumentation != null) {
-                    instrumentation.notifyFieldModification(frame, statementIndex, field, receiver, floatValue);
+                    instrumentation.notifyFieldModification(frame, statementIndex, field, this, receiver, floatValue);
                 }
                 InterpreterToVM.setFieldFloat(floatValue, receiver, field);
                 break;
             case 'J':
                 long longValue = popLong(frame, top - 1);
                 if (instrumentation != null) {
-                    instrumentation.notifyFieldModification(frame, statementIndex, field, receiver, longValue);
+                    instrumentation.notifyFieldModification(frame, statementIndex, field, this, receiver, longValue);
                 }
                 InterpreterToVM.setFieldLong(longValue, receiver, field);
                 break;
             case '[': // fall through
             case 'L':
                 StaticObject value = popObject(frame, top - 1);
                 if (instrumentation != null) {
-                    instrumentation.notifyFieldModification(frame, statementIndex, field, receiver, value);
+                    instrumentation.notifyFieldModification(frame, statementIndex, field, this, receiver, value);
                 }
                 InterpreterToVM.setFieldObject(value, receiver, field);
                 break;
@@ -2847,7 +2848,7 @@ private int getField(VirtualFrame frame, int top, Field field, int curBCI, int o
         }
 
         if (instrumentation != null) {
-            instrumentation.notifyFieldAccess(frame, statementIndex, field, receiver);
+            instrumentation.notifyFieldAccess(frame, statementIndex, field, this, receiver);
         }
 
         int resultAt = mode.isStatic() ? top : (top - 1);
@@ -2901,14 +2902,14 @@ public String toString() {
     public void notifyFieldModification(VirtualFrame frame, int index, Field field, StaticObject receiver, Object value) {
         // Notifications are only for Espresso objects
         if (instrumentation != null && (noForeignObjects.isValid() || receiver.isEspressoObject())) {
-            instrumentation.notifyFieldModification(frame, index, field, receiver, value);
+            instrumentation.notifyFieldModification(frame, index, field, this, receiver, value);
         }
     }
 
     public void notifyFieldAccess(VirtualFrame frame, int index, Field field, StaticObject receiver) {
         // Notifications are only for Espresso objects
         if (instrumentation != null && (noForeignObjects.isValid() || receiver.isEspressoObject())) {
-            instrumentation.notifyFieldAccess(frame, index, field, receiver);
+            instrumentation.notifyFieldAccess(frame, index, field, this, receiver);
         }
     }
 
@@ -2980,7 +2981,7 @@ private static boolean assertionsEnabled() {
          */
         void notifyStatementChange(VirtualFrame frame, int statementIndex, int nextStatementIndex, int targetBci) {
             assert statementIndex != nextStatementIndex;
-            notifyStatementExit(frame, statementIndex);
+            notifyStatementExit(frame, statementIndex, StaticObject.NULL);
             setBCI(frame, targetBci);
             notifyStatementEnter(frame, nextStatementIndex);
         }
@@ -2995,20 +2996,26 @@ void notifyStatementResume(VirtualFrame frame, int statementIndex) {
             resumeAt(frame, statementIndex);
         }
 
-        void notifyStatementExit(VirtualFrame frame, int statementIndex) {
+        void notifyStatementExit(VirtualFrame frame, int statementIndex, Object returnValue) {
             CompilerAsserts.partialEvaluationConstant(statementIndex);
-            exitAt(frame, statementIndex, StaticObject.NULL);
+            exitAt(frame, statementIndex, returnValue);
         }
 
         public void notifyEntry(VirtualFrame frame, AbstractInstrumentableBytecodeNode instrumentableNode) {
             if (context.shouldReportVMEvents() && method.getMethod().hasActiveHook()) {
-                context.reportOnMethodEntry(method, instrumentableNode.getScope(frame, true));
+                context.reportOnMethodEntry(method, instrumentableNode, instrumentableNode.getScope(frame, true));
             }
         }
 
         public void notifyResume(VirtualFrame frame, AbstractInstrumentableBytecodeNode instrumentableNode) {
             if (context.shouldReportVMEvents() && method.getMethod().hasActiveHook()) {
-                context.reportOnMethodEntry(method, instrumentableNode.getScope(frame, true));
+                context.reportOnMethodEntry(method, instrumentableNode, instrumentableNode.getScope(frame, true));
+            }
+        }
+
+        public void notifyExit(@SuppressWarnings("unused") VirtualFrame frame, AbstractInstrumentableBytecodeNode instrumentableNode, Object returnValue) {
+            if (context.shouldReportVMEvents() && method.getMethod().hasActiveHook()) {
+                context.reportOnMethodReturn(method, instrumentableNode, returnValue);
             }
         }
 
@@ -3028,17 +3035,17 @@ void notifyYieldAt(VirtualFrame frame, Object o, int statementIndex) {
             probeNode.onYield(frame, o);
         }
 
-        public void notifyFieldModification(VirtualFrame frame, int index, Field field, StaticObject receiver, Object value) {
+        public void notifyFieldModification(VirtualFrame frame, int index, Field field, AbstractInstrumentableBytecodeNode instrumentableNode, StaticObject receiver, Object value) {
             if (context.shouldReportVMEvents() && field.hasActiveBreakpoint()) {
-                if (context.reportOnFieldModification(field, receiver, value)) {
+                if (context.reportOnFieldModification(field, instrumentableNode, receiver, value)) {
                     enterAt(frame, index);
                 }
             }
         }
 
-        public void notifyFieldAccess(VirtualFrame frame, int index, Field field, StaticObject receiver) {
+        public void notifyFieldAccess(VirtualFrame frame, int index, Field field, AbstractInstrumentableBytecodeNode instrumentableNode, StaticObject receiver) {
             if (context.shouldReportVMEvents() && field.hasActiveBreakpoint()) {
-                if (context.reportOnFieldAccess(field, receiver)) {
+                if (context.reportOnFieldAccess(field, instrumentableNode, receiver)) {
                     enterAt(frame, index);
                 }
             }

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/runtime/EspressoContext.java

@@ -1250,24 +1250,24 @@ public void reportOnContendedMonitorEntered(StaticObject obj) {
         espressoEnv.getEventListener().onContendedMonitorEntered(obj);
     }
 
-    public boolean reportOnMethodEntry(Method.MethodVersion methodVersion, Object scope) {
+    public boolean reportOnMethodEntry(Method.MethodVersion methodVersion, Node node, Object scope) {
         assert shouldReportVMEvents();
-        return espressoEnv.getEventListener().onMethodEntry(methodVersion.getMethod(), scope);
+        return espressoEnv.getEventListener().onMethodEntry(methodVersion.getMethod(), node, scope);
     }
 
-    public boolean reportOnMethodReturn(Method.MethodVersion methodVersion, Object returnValue) {
+    public boolean reportOnMethodReturn(Method.MethodVersion methodVersion, Node node, Object returnValue) {
         assert shouldReportVMEvents();
-        return espressoEnv.getEventListener().onMethodReturn(methodVersion.getMethod(), returnValue);
+        return espressoEnv.getEventListener().onMethodReturn(methodVersion.getMethod(), node, returnValue);
     }
 
-    public boolean reportOnFieldModification(Field field, StaticObject receiver, Object value) {
+    public boolean reportOnFieldModification(Field field, Node node, StaticObject receiver, Object value) {
         assert shouldReportVMEvents();
-        return espressoEnv.getEventListener().onFieldModification(field, receiver, value);
+        return espressoEnv.getEventListener().onFieldModification(field, node, receiver, value);
     }
 
-    public boolean reportOnFieldAccess(Field field, StaticObject receiver) {
+    public boolean reportOnFieldAccess(Field field, Node node, StaticObject receiver) {
         assert shouldReportVMEvents();
-        return espressoEnv.getEventListener().onFieldAccess(field, receiver);
+        return espressoEnv.getEventListener().onFieldAccess(field, node, receiver);
     }
     // endregion VM event reporting