Only handle well-known locks in AbstractOwnableSynchronizer substitution

Other subclasses (which can be user-defined) can have semantics that
don't match well with what we are trying to do here regarding
continuations and locks.

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/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);
     }