Revert "replace ReferenceLibrary with InteropLibrary"

This reverts commit 69b17d0.

Author: timfel

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/CExtNodes.java

@@ -167,6 +167,7 @@
 import com.oracle.truffle.api.nodes.NodeUtil;
 import com.oracle.truffle.api.profiles.BranchProfile;
 import com.oracle.truffle.api.profiles.ConditionProfile;
+import com.oracle.truffle.llvm.spi.ReferenceLibrary;
 
 public abstract class CExtNodes {
 
@@ -2709,12 +2710,12 @@ public abstract static class GetTypeMemberNode extends PNodeWithContext {
          * native context, so we can be sure that the "nativeClassStableAssumption" (which is
          * per-context) is from the context in which this native object was created.
          */
-        @Specialization(guards = {"interopLibrary.isIdentical(cachedObj, obj, interopLibrary)", "memberName == cachedMemberName"}, //
+        @Specialization(guards = {"referenceLibrary.isSame(cachedObj, obj)", "memberName == cachedMemberName"}, //
                         limit = "1", //
                         assumptions = {"getNativeClassStableAssumption(cachedObj)", "singleContextAssumption()"})
         public Object doCachedObj(@SuppressWarnings("unused") PythonAbstractNativeObject obj, @SuppressWarnings("unused") NativeMember memberName,
                         @Cached("obj") @SuppressWarnings("unused") PythonAbstractNativeObject cachedObj,
-                        @CachedLibrary(limit = "1") @SuppressWarnings("unused") InteropLibrary interopLibrary, // cachedObj and obj should always be the same type
+                        @CachedLibrary("cachedObj") @SuppressWarnings("unused") ReferenceLibrary referenceLibrary,
                         @Cached("memberName") @SuppressWarnings("unused") NativeMember cachedMemberName,
                         @Cached("doSlowPath(obj, memberName)") Object result) {
             return result;
@@ -3156,12 +3157,13 @@ static PythonNativeWrapper resolveLongCached(@SuppressWarnings("unused") long po
             return cachedValue;
         }
 
-        @Specialization(guards = {"interopLib.isIdentical(cachedPointerObject, pointerObject, interopLib)", "cachedValue != null"}, //
+        @Specialization(limit = "3", //
+                        guards = {"isSame(referenceLibrary, cachedPointerObject, pointerObject)", "cachedValue != null"}, //
                         assumptions = "singleContextAssumption()", //
                         rewriteOn = InvalidAssumptionException.class)
         static PythonNativeWrapper resolveObjectCached(@SuppressWarnings("unused") Object pointerObject,
                         @Cached("pointerObject") @SuppressWarnings("unused") Object cachedPointerObject,
-                        @CachedLibrary(limit = "3") @SuppressWarnings("unused") InteropLibrary interopLib,
+                        @CachedLibrary("cachedPointerObject") @SuppressWarnings("unused") ReferenceLibrary referenceLibrary,
                         @Cached("resolveHandleUncached(pointerObject)") PythonNativeWrapper cachedValue,
                         @Cached("getHandleValidAssumption(cachedValue)") Assumption associationValidAssumption) throws InvalidAssumptionException {
             associationValidAssumption.check();
@@ -3193,6 +3195,10 @@ static PythonNativeWrapper resolveHandleUncached(Object pointerObject) {
             return null;
         }
 
+        static boolean isSame(ReferenceLibrary referenceLibrary, Object left, Object right) {
+            return referenceLibrary.isSame(left, right);
+        }
+
         static Assumption singleContextAssumption() {
             return PythonLanguage.getCurrent().singleContextAssumption;
         }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/DynamicObjectNativeWrapper.java

@@ -172,8 +172,8 @@
 import com.oracle.truffle.api.profiles.BranchProfile;
 import com.oracle.truffle.api.profiles.ConditionProfile;
 import com.oracle.truffle.api.profiles.ValueProfile;
-import com.oracle.truffle.api.utilities.TriState;
 import com.oracle.truffle.llvm.spi.NativeTypeLibrary;
+import com.oracle.truffle.llvm.spi.ReferenceLibrary;
 
 @ExportLibrary(InteropLibrary.class)
 @ExportLibrary(NativeTypeLibrary.class)
@@ -1461,6 +1461,7 @@ static boolean isModifiableCached(PythonObjectNativeWrapper receiver, String nam
         }
     }
 
+    @ExportLibrary(ReferenceLibrary.class)
     public static final class PrimitiveNativeWrapper extends DynamicObjectNativeWrapper {
 
         public static final byte PRIMITIVE_STATE_BOOL = 1;
@@ -1703,31 +1704,20 @@ protected static boolean isObType(String key) {
         }
 
         @ExportMessage
-        @TruffleBoundary
-        int identityHashCode() {
-            int val = System.identityHashCode(state) ^ System.identityHashCode(value);
-            if (Double.isNaN(dvalue)) {
-                return val;
-            } else {
-                return val ^ System.identityHashCode(dvalue);
-            }
-        }
-
-        @ExportMessage
-        static class IsIdenticalOrUndefined {
+        static class IsSame {
 
             @Specialization
-            static TriState doPrimitiveWrapper(PrimitiveNativeWrapper receiver, PrimitiveNativeWrapper other) {
+            static boolean doPrimitiveWrapper(PrimitiveNativeWrapper receiver, PrimitiveNativeWrapper other) {
                 // This basically emulates singletons for boxed values. However, we need to do so to
                 // preserve the invariant that storing an object into a list and getting it out (in
                 // the same critical region) returns the same object.
-                return other.state == receiver.state && other.value == receiver.value && (other.dvalue == receiver.dvalue || Double.isNaN(receiver.dvalue) && Double.isNaN(other.dvalue)) ? TriState.TRUE : TriState.FALSE;
+                return other.state == receiver.state && other.value == receiver.value && (other.dvalue == receiver.dvalue || Double.isNaN(receiver.dvalue) && Double.isNaN(other.dvalue));
             }
 
             @Fallback
             @SuppressWarnings("unused")
-            static TriState doGeneric(PrimitiveNativeWrapper receiver, Object other) {
-                return TriState.FALSE;
+            static boolean doGeneric(PrimitiveNativeWrapper receiver, Object other) {
+                return false;
             }
         }
     }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/PythonAbstractNativeObject.java

@@ -43,6 +43,7 @@
 import static com.oracle.graal.python.builtins.objects.cext.NativeCAPISymbols.FUN_GET_OB_TYPE;
 import static com.oracle.graal.python.builtins.objects.cext.NativeCAPISymbols.FUN_PY_OBJECT_GENERIC_GET_DICT;
 
+import java.lang.ref.WeakReference;
 import java.util.Objects;
 
 import com.oracle.graal.python.PythonLanguage;
@@ -74,6 +75,7 @@
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Cached.Exclusive;
 import com.oracle.truffle.api.dsl.Cached.Shared;
+import com.oracle.truffle.api.dsl.Fallback;
 import com.oracle.truffle.api.dsl.GenerateUncached;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.interop.ArityException;
@@ -89,16 +91,17 @@
 import com.oracle.truffle.api.object.Shape;
 import com.oracle.truffle.api.profiles.ConditionProfile;
 import com.oracle.truffle.api.profiles.ValueProfile;
-import com.oracle.truffle.api.utilities.TriState;
+import com.oracle.truffle.llvm.spi.ReferenceLibrary;
 
 @ExportLibrary(PythonObjectLibrary.class)
+@ExportLibrary(ReferenceLibrary.class)
 @ExportLibrary(InteropLibrary.class)
 public final class PythonAbstractNativeObject extends PythonAbstractObject implements PythonNativeObject, PythonNativeClass {
 
-    public final TruffleObject ptr;
+    public final TruffleObject object;
 
-    public PythonAbstractNativeObject(TruffleObject ptr) {
-        this.ptr = ptr;
+    public PythonAbstractNativeObject(TruffleObject object) {
+        this.object = object;
     }
 
     public int compareTo(Object o) {
@@ -118,14 +121,14 @@ public void lookupChanged() {
     }
 
     public TruffleObject getPtr() {
-        return ptr;
+        return object;
     }
 
     @Override
     public int hashCode() {
         CompilerAsserts.neverPartOfCompilation();
         // this is important for the default '__hash__' implementation
-        return Objects.hashCode(ptr);
+        return Objects.hashCode(object);
     }
 
     @Ignore
@@ -138,7 +141,7 @@ public boolean equals(Object obj) {
             return false;
         }
         PythonAbstractNativeObject other = (PythonAbstractNativeObject) obj;
-        return Objects.equals(ptr, other.ptr);
+        return Objects.equals(object, other.object);
     }
 
     public boolean equalsProfiled(Object obj, ValueProfile profile) {
@@ -149,13 +152,13 @@ public boolean equalsProfiled(Object obj, ValueProfile profile) {
             return false;
         }
         PythonAbstractNativeObject other = (PythonAbstractNativeObject) obj;
-        return Objects.equals(profile.profile(ptr), profile.profile(other.ptr));
+        return Objects.equals(profile.profile(object), profile.profile(other.object));
     }
 
     @Override
     public String toString() {
         CompilerAsserts.neverPartOfCompilation();
-        return String.format("PythonAbstractNativeObject(%s)", ptr);
+        return String.format("PythonAbstractNativeObject(%s)", object);
     }
 
     @ExportMessage
@@ -225,11 +228,10 @@ public static Assumption getSingleContextAssumption() {
             return PythonLanguage.getCurrent().singleContextAssumption;
         }
 
-        @Specialization(guards = "object == cachedObject", limit = "1", assumptions = "singleContextAssumption")
+        @Specialization(guards = "object == cachedObject.get()", limit = "1", assumptions = "singleContextAssumption")
         static Object getNativeClassCachedIdentity(PythonAbstractNativeObject object,
-                        // @Shared("assumption") 
-                        @Cached(value = "getSingleContextAssumption()") Assumption singleContextAssumption,
-                        @Exclusive @Cached(value = "object", weak = true) PythonAbstractNativeObject cachedObject,
+                        @Shared("assumption") @Cached(value = "getSingleContextAssumption()") Assumption singleContextAssumption,
+                        @Exclusive @Cached("weak(object)") WeakReference<PythonAbstractNativeObject> cachedObject,
                         @Exclusive @Cached("getNativeClassUncached(object)") Object cachedClass) {
             // TODO: (tfel) is this really something we can do? It's so rare for this class to
             // change that it shouldn't be worth the effort, but in native code, anything can
@@ -238,18 +240,17 @@ static Object getNativeClassCachedIdentity(PythonAbstractNativeObject object,
             return cachedClass;
         }
 
-        @Specialization(guards = "lib.isIdentical(cachedObject, object, lib)", assumptions = "getSingleContextAssumption()")
+        @Specialization(guards = "isSame(referenceLibrary, cachedObject, object)", limit = "1", assumptions = "singleContextAssumption")
         static Object getNativeClassCached(PythonAbstractNativeObject object,
-                        @Exclusive @Cached("object") PythonAbstractNativeObject cachedObject,
+                        @Shared("assumption") @Cached(value = "getSingleContextAssumption()") Assumption singleContextAssumption,
+                        @Exclusive @Cached("weak(object)") WeakReference<PythonAbstractNativeObject> cachedObject,
                         @Exclusive @Cached("getNativeClassUncached(object)") Object cachedClass,
-                        @CachedLibrary(limit = "3") @SuppressWarnings("unused") InteropLibrary lib) {
+                        @CachedLibrary("object.object") @SuppressWarnings("unused") ReferenceLibrary referenceLibrary) {
             // TODO same as for 'getNativeClassCachedIdentity'
             return cachedClass;
         }
 
-        @Specialization(guards = {"lib.hasMembers(object.getPtr())"}, // replaces = {// "getNativeClassCached", 
-                                                                      //             "getNativeClassCachedIdentity"}, 
-                        limit = "1", rewriteOn = {UnknownIdentifierException.class,
+        @Specialization(guards = {"lib.hasMembers(object.getPtr())"}, replaces = {"getNativeClassCached", "getNativeClassCachedIdentity"}, limit = "1", rewriteOn = {UnknownIdentifierException.class,
                         UnsupportedMessageException.class})
         static Object getNativeClassByMember(PythonAbstractNativeObject object,
                         @CachedLibrary("object.getPtr()") InteropLibrary lib,
@@ -260,8 +261,7 @@ static Object getNativeClassByMember(PythonAbstractNativeObject object,
             return classProfile.profile(toJavaNode.execute(lib.readMember(object.getPtr(), NativeMember.OB_TYPE.getMemberName())));
         }
 
-        // @Specialization(replaces = {"getNativeClassCached", "getNativeClassCachedIdentity", "getNativeClassByMember"})
-        @Specialization(replaces = {"getNativeClassByMember", "getNativeClassCached"})
+        @Specialization(replaces = {"getNativeClassCached", "getNativeClassCachedIdentity", "getNativeClassByMember"})
         static Object getNativeClass(PythonAbstractNativeObject object,
                         @Exclusive @Cached PCallCapiFunction callGetObTypeNode,
                         @Exclusive @Cached AsPythonObjectNode toJavaNode,
@@ -270,9 +270,14 @@ static Object getNativeClass(PythonAbstractNativeObject object,
             return classProfile.profile(toJavaNode.execute(callGetObTypeNode.call(FUN_GET_OB_TYPE, object.getPtr())));
         }
 
-        static boolean isSame(InteropLibrary lib, PythonAbstractNativeObject cachedObject, PythonAbstractNativeObject object) {
+        static WeakReference<PythonAbstractNativeObject> weak(PythonAbstractNativeObject object) {
+            return new WeakReference<>(object);
+        }
+
+        static boolean isSame(ReferenceLibrary referenceLibrary, WeakReference<PythonAbstractNativeObject> cachedObjectRef, PythonAbstractNativeObject object) {
+            PythonAbstractNativeObject cachedObject = cachedObjectRef.get();
             if (cachedObject != null) {
-                return lib.isIdentical(cachedObject, object, lib);
+                return referenceLibrary.isSame(cachedObject.object, object.object);
             }
             return false;
         }
@@ -284,14 +289,19 @@ public static Object getNativeClassUncached(PythonAbstractNativeObject object) {
     }
 
     @ExportMessage
-    int identityHashCode(@CachedLibrary("this.ptr") InteropLibrary lib) throws UnsupportedMessageException {
-        return lib.identityHashCode(ptr);
-    }
+    static class IsSame {
 
-    @ExportMessage
-    TriState isIdenticalOrUndefined(Object other,
-                    @CachedLibrary(limit = "3") InteropLibrary lib) {
-        return lib.isIdentical(ptr, other, lib) ? TriState.TRUE : TriState.FALSE;
+        @Specialization
+        static boolean doNativeObject(PythonAbstractNativeObject receiver, PythonAbstractNativeObject other,
+                        @CachedLibrary("receiver.object") ReferenceLibrary referenceLibrary) {
+            return referenceLibrary.isSame(receiver.object, other.object);
+        }
+
+        @Fallback
+        @SuppressWarnings("unused")
+        static boolean doOther(PythonAbstractNativeObject receiver, Object other) {
+            return false;
+        }
     }
 
     @ExportMessage(library = PythonObjectLibrary.class, name = "isLazyPythonClass")

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/PythonNativeNull.java

@@ -46,14 +46,15 @@
 import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.library.ExportLibrary;
 import com.oracle.truffle.api.library.ExportMessage;
-import com.oracle.truffle.api.utilities.TriState;
 import com.oracle.truffle.llvm.spi.NativeTypeLibrary;
+import com.oracle.truffle.llvm.spi.ReferenceLibrary;
 
 /**
  * A simple wrapper around native {@code NULL}.
  */
 @ExportLibrary(InteropLibrary.class)
 @ExportLibrary(NativeTypeLibrary.class)
+@ExportLibrary(ReferenceLibrary.class)
 public class PythonNativeNull implements TruffleObject {
     private Object ptr;
 
@@ -95,14 +96,8 @@ public Object getNativeType() {
     }
 
     @ExportMessage(limit = "1")
-    int identityHashCode(@CachedLibrary("this.getPtr()") InteropLibrary delegateLib) throws UnsupportedMessageException {
-        return delegateLib.identityHashCode(ptr);
-    }
-
-    @ExportMessage(limit = "1")
-    TriState isIdenticalOrUndefined(Object other,
-                    @CachedLibrary("this.getPtr()") InteropLibrary delegateLib,
-                    @CachedLibrary("other") InteropLibrary otherLib) {
-        return delegateLib.isIdentical(ptr, other, otherLib) ? TriState.TRUE : TriState.FALSE;
+    boolean isSame(Object other,
+                    @CachedLibrary("this.getPtr()") ReferenceLibrary delegateLib) {
+        return delegateLib.isSame(ptr, other);
     }
 }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/capi/CApiContext.java

@@ -89,6 +89,7 @@
 import com.oracle.truffle.api.interop.UnsupportedMessageException;
 import com.oracle.truffle.api.profiles.BranchProfile;
 import com.oracle.truffle.api.profiles.ConditionProfile;
+import com.oracle.truffle.llvm.spi.ReferenceLibrary;
 
 public final class CApiContext extends CExtContext {
     private static final TruffleLogger LOGGER = PythonLanguage.getLogger(CApiContext.class);
@@ -118,7 +119,7 @@ public final class CApiContext extends CExtContext {
     @CompilationFinal(dimensions = 1) private final PrimitiveNativeWrapper[] primitiveNativeWrapperCache;
 
     /** Just used for integrity checks if assertions are enabled. */
-    @CompilationFinal private InteropLibrary interopLibrary;
+    @CompilationFinal private ReferenceLibrary referenceLibrary;
 
     /**
      * Required to emulate PyLongObject's ABI; number of bits per digit (equal to
@@ -522,14 +523,14 @@ PythonAbstractNativeObject createPythonAbstractNativeObject(TruffleObject native
 
     /**
      * Checks if the given {@link NativeObjectReference} objects point to the same native object.
-     * This method lazily initializes {@link #interopLibrary} as a side-effect.
+     * This method lazily initializes {@link #referenceLibrary} as a side-effect.
      */
     private boolean isReferenceToSameNativeObject(NativeObjectReference old, NativeObjectReference ref) {
-        if (interopLibrary == null) {
+        if (referenceLibrary == null) {
             CompilerDirectives.transferToInterpreterAndInvalidate();
-            interopLibrary = InteropLibrary.getFactory().getUncached();
+            referenceLibrary = ReferenceLibrary.getFactory().getUncached(old.ptrObject);
         }
-        return interopLibrary.isIdentical(old.ptrObject, ref.ptrObject, interopLibrary);
+        return referenceLibrary.isSame(old.ptrObject, ref.ptrObject);
     }
 
     static int idFromRefCnt(long refCnt) {