[GR-55179] [GR-55187] Follow-up fixes for continuations.

PullRequest: graal/18245

Author: gilles-duboscq

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/descriptors/Symbol.java

@@ -982,6 +982,8 @@ public static void ensureInitialized() {
         public static final Symbol<Type> java_util_regex_IntHashSet_array = StaticSymbols.putType("[Ljava/util/regex/IntHashSet;");
 
         public static final Symbol<Type> java_util_concurrent_locks_AbstractOwnableSynchronizer = StaticSymbols.putType("Ljava/util/concurrent/locks/AbstractOwnableSynchronizer;");
+        public static final Symbol<Type> java_util_concurrent_locks_ReentrantLock_Sync = StaticSymbols.putType("Ljava/util/concurrent/locks/ReentrantLock$Sync;");
+        public static final Symbol<Type> java_util_concurrent_locks_ReentrantReadWriteLock_Sync = StaticSymbols.putType("Ljava/util/concurrent/locks/ReentrantReadWriteLock$Sync;");
 
         // java math
         public static final Symbol<Type> java_math_BigInteger = StaticSymbols.putType("Ljava/math/BigInteger;");

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/meta/Meta.java

@@ -1057,6 +1057,8 @@ public Meta(EspressoContext context) {
         java_util_concurrent_locks_abstractOwnableSynchronizer = knownKlass(Type.java_util_concurrent_locks_AbstractOwnableSynchronizer);
         java_util_concurrent_locks_AbstractOwnableSynchronizer_exclusiveOwnerThread = java_util_concurrent_locks_abstractOwnableSynchronizer.requireDeclaredField(Name.exclusiveOwnerThread,
                         Type.java_lang_Thread);
+        java_util_concurrent_locks_ReentrantLock_Sync = knownKlass(Type.java_util_concurrent_locks_ReentrantLock_Sync);
+        java_util_concurrent_locks_ReentrantReadWriteLock_Sync = knownKlass(Type.java_util_concurrent_locks_ReentrantReadWriteLock_Sync);
 
         java_math_BigInteger = knownKlass(Type.java_math_BigInteger);
         java_math_BigInteger_init = java_math_BigInteger.requireDeclaredMethod(Name._init_, Signature._void_byte_array);
@@ -1888,6 +1890,8 @@ private DiffVersionLoadHelper diff() {
 
     public final ObjectKlass java_util_concurrent_locks_abstractOwnableSynchronizer;
     public final Field java_util_concurrent_locks_AbstractOwnableSynchronizer_exclusiveOwnerThread;
+    public final ObjectKlass java_util_concurrent_locks_ReentrantLock_Sync;
+    public final ObjectKlass java_util_concurrent_locks_ReentrantReadWriteLock_Sync;
 
     public final ObjectKlass java_math_BigInteger;
     public final Method java_math_BigInteger_init;

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

@@ -599,7 +599,7 @@ public Object resumeContinuation(VirtualFrame frame, int bci, int top) {
 
         // set up local state.
         InstrumentationSupport instrument = instrumentation;
-        int statementIndex = instrument == null ? 0 : instrument.hookBCIToNodeIndex.lookup(0, 0, bs.endBCI());
+        int statementIndex = instrument == null ? 0 : instrument.getStatementIndexAfterJump(0, 0, bs.endBCI());
         assert bs.opcode(bci) == QUICK && nodes[bs.readCPI2(bci)] instanceof InvokeContinuableNode;
 
         return executeBodyFromBCI(frame, bci, top, statementIndex, true, true);

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

@@ -102,11 +102,11 @@ private Object[] preprocessArgs(JniEnv env, Object[] args) {
 
     @Override
     public Object execute(VirtualFrame frame) {
-        var tls = getContext().getLanguage().getThreadLocalState();
-        tls.blockContinuationSuspension();   // Can't unwind through native frames.
         final JniEnv env = getContext().getJNI();
         int nativeFrame = env.getHandles().pushFrame();
         NATIVE_METHOD_CALLS.inc();
+        var tls = getContext().getLanguage().getThreadLocalState();
+        tls.blockContinuationSuspension();   // Can't unwind through native frames.
         try {
             Object[] nativeArgs = preprocessArgs(env, frame.getArguments());
             Object result = executeNative.execute(boundNative, nativeArgs);

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/substitutions/Target_java_util_concurrent_locks_AbstractOwnableSynchronizer.java

@@ -25,6 +25,7 @@
 import com.oracle.truffle.espresso.EspressoLanguage;
 import com.oracle.truffle.espresso.meta.Meta;
 import com.oracle.truffle.espresso.runtime.staticobject.StaticObject;
+import com.oracle.truffle.espresso.vm.InterpreterToVM;
 
 @EspressoSubstitutions
 public final class Target_java_util_concurrent_locks_AbstractOwnableSynchronizer {
@@ -33,12 +34,22 @@ private Target_java_util_concurrent_locks_AbstractOwnableSynchronizer() {
 
     @Substitution(hasReceiver = true, isTrivial = true)
     public static void setExclusiveOwnerThread(StaticObject self, @JavaType(Thread.class) StaticObject thread, @Inject Meta meta) {
-        // We don't want to have continuations that "own" anything
-        EspressoLanguage language = meta.getLanguage();
-        if (StaticObject.isNull(thread)) {
-            language.getThreadLocalState().unblockContinuationSuspension();
-        } else if (language.getCurrentVirtualThread() == thread) {
-            language.getThreadLocalState().blockContinuationSuspension();
+        if (InterpreterToVM.instanceOf(self, meta.java_util_concurrent_locks_ReentrantLock_Sync) ||
+                        InterpreterToVM.instanceOf(self, meta.java_util_concurrent_locks_ReentrantReadWriteLock_Sync)) {
+            // We don't want to have continuations that "own" Locks
+            // We only handle ReentrantLock$Sync and ReentrantReadWriteLock$Sync which have well
+            // known semantics that follow the assertions below.
+            // There are other subclasses of AbstractOwnableSynchronizer in the JDK or in
+            // user-defined code, but we don't want to guess their semantics or rely on how they use
+            // this method for our own correctness.
+            EspressoLanguage language = meta.getLanguage();
+            if (StaticObject.isNull(thread)) {
+                assert StaticObject.notNull(meta.java_util_concurrent_locks_AbstractOwnableSynchronizer_exclusiveOwnerThread.getObject(self));
+                language.getThreadLocalState().unblockContinuationSuspension();
+            } else if (language.getCurrentVirtualThread() == thread) {
+                assert meta.java_util_concurrent_locks_AbstractOwnableSynchronizer_exclusiveOwnerThread.getObject(self) != thread;
+                language.getThreadLocalState().blockContinuationSuspension();
+            }
         }
         meta.java_util_concurrent_locks_AbstractOwnableSynchronizer_exclusiveOwnerThread.setObject(self, thread);
     }