8188055: (ref) Add Reference::refersTo predicate

Reviewed-by: mchung, pliden, rriggs, dholmes, ihse, smarks, alanb

Author: Kim Barrett

make/hotspot/symbols/symbols-unix

@@ -171,11 +171,13 @@ JVM_NativePath
 JVM_NewArray
 JVM_NewInstanceFromConstructor
 JVM_NewMultiArray
+JVM_PhantomReferenceRefersTo
 JVM_RaiseSignal
 JVM_RawMonitorCreate
 JVM_RawMonitorDestroy
 JVM_RawMonitorEnter
 JVM_RawMonitorExit
+JVM_ReferenceRefersTo
 JVM_RegisterLambdaProxyClassForArchiving
 JVM_RegisterSignal
 JVM_ReleaseUTF

src/hotspot/share/classfile/javaClasses.hpp

@@ -904,8 +904,9 @@ class java_lang_ref_Reference: AllStatic {
 
  public:
   // Accessors
-  static inline oop referent(oop ref);
-  static inline void set_referent(oop ref, oop value);
+  static inline oop weak_referent_no_keepalive(oop ref);
+  static inline oop phantom_referent_no_keepalive(oop ref);
+  static inline oop unknown_referent_no_keepalive(oop ref);
   static inline void set_referent_raw(oop ref, oop value);
   static inline HeapWord* referent_addr_raw(oop ref);
   static inline oop next(oop ref);

src/hotspot/share/classfile/javaClasses.inline.hpp

@@ -100,12 +100,17 @@ bool java_lang_String::is_instance_inlined(oop obj) {
 }
 
 // Accessors
-oop java_lang_ref_Reference::referent(oop ref) {
-  return ref->obj_field(_referent_offset);
+
+oop java_lang_ref_Reference::weak_referent_no_keepalive(oop ref) {
+  return ref->obj_field_access<ON_WEAK_OOP_REF | AS_NO_KEEPALIVE>(_referent_offset);
+}
+
+oop java_lang_ref_Reference::phantom_referent_no_keepalive(oop ref) {
+  return ref->obj_field_access<ON_PHANTOM_OOP_REF | AS_NO_KEEPALIVE>(_referent_offset);
 }
 
-void java_lang_ref_Reference::set_referent(oop ref, oop value) {
-  ref->obj_field_put(_referent_offset, value);
+oop java_lang_ref_Reference::unknown_referent_no_keepalive(oop ref) {
+  return ref->obj_field_access<ON_UNKNOWN_OOP_REF | AS_NO_KEEPALIVE>(_referent_offset);
 }
 
 void java_lang_ref_Reference::set_referent_raw(oop ref, oop value) {

src/hotspot/share/gc/shared/referenceProcessor.cpp

@@ -262,7 +262,7 @@ void DiscoveredListIterator::load_ptrs(DEBUG_ONLY(bool allow_null_referent)) {
   _next_discovered = discovered;
 
   _referent_addr = java_lang_ref_Reference::referent_addr_raw(_current_discovered);
-  _referent = java_lang_ref_Reference::referent(_current_discovered);
+  _referent = java_lang_ref_Reference::unknown_referent_no_keepalive(_current_discovered);
   assert(Universe::heap()->is_in_or_null(_referent),
          "Wrong oop found in java.lang.Reference object");
   assert(allow_null_referent ?
@@ -1058,7 +1058,7 @@ ReferenceProcessor::add_to_discovered_list_mt(DiscoveredList& refs_list,
 // cleared concurrently by mutators during (or after) discovery.
 void ReferenceProcessor::verify_referent(oop obj) {
   bool da = discovery_is_atomic();
-  oop referent = java_lang_ref_Reference::referent(obj);
+  oop referent = java_lang_ref_Reference::unknown_referent_no_keepalive(obj);
   assert(da ? oopDesc::is_oop(referent) : oopDesc::is_oop_or_null(referent),
          "Bad referent " INTPTR_FORMAT " found in Reference "
          INTPTR_FORMAT " during %satomic discovery ",
@@ -1119,7 +1119,8 @@ bool ReferenceProcessor::discover_reference(oop obj, ReferenceType rt) {
   // known to be strongly reachable.
   if (is_alive_non_header() != NULL) {
     verify_referent(obj);
-    if (is_alive_non_header()->do_object_b(java_lang_ref_Reference::referent(obj))) {
+    oop referent = java_lang_ref_Reference::unknown_referent_no_keepalive(obj);
+    if (is_alive_non_header()->do_object_b(referent)) {
       return false;  // referent is reachable
     }
   }
@@ -1169,7 +1170,7 @@ bool ReferenceProcessor::discover_reference(oop obj, ReferenceType rt) {
     // .. we are an atomic collector and referent is in our span
     if (is_subject_to_discovery(obj) ||
         (discovery_is_atomic() &&
-         is_subject_to_discovery(java_lang_ref_Reference::referent(obj)))) {
+         is_subject_to_discovery(java_lang_ref_Reference::unknown_referent_no_keepalive(obj)))) {
     } else {
       return false;
     }

src/hotspot/share/include/jvm.h

@@ -330,6 +330,15 @@ JVM_HasReferencePendingList(JNIEnv *env);
 JNIEXPORT void JNICALL
 JVM_WaitForReferencePendingList(JNIEnv *env);
 
+JNIEXPORT jboolean JNICALL
+JVM_ReferenceRefersTo(JNIEnv *env, jobject ref, jobject o);
+
+/*
+ * java.lang.ref.PhantomReference
+ */
+JNIEXPORT jboolean JNICALL
+JVM_PhantomReferenceRefersTo(JNIEnv *env, jobject ref, jobject o);
+
 /*
  * java.io.ObjectInputStream
  */

src/hotspot/share/oops/instanceRefKlass.cpp

@@ -79,7 +79,7 @@ void InstanceRefKlass::update_nonstatic_oop_maps(Klass* k) {
 void InstanceRefKlass::oop_verify_on(oop obj, outputStream* st) {
   InstanceKlass::oop_verify_on(obj, st);
   // Verify referent field
-  oop referent = java_lang_ref_Reference::referent(obj);
+  oop referent = java_lang_ref_Reference::unknown_referent_no_keepalive(obj);
   if (referent != NULL) {
     guarantee(oopDesc::is_oop(referent), "referent field heap failed");
   }

src/hotspot/share/prims/jvm.cpp

@@ -3439,6 +3439,24 @@ JVM_ENTRY(void, JVM_WaitForReferencePendingList(JNIEnv* env))
   }
 JVM_END
 
+JVM_ENTRY(jboolean, JVM_ReferenceRefersTo(JNIEnv* env, jobject ref, jobject o))
+  JVMWrapper("JVM_ReferenceRefersTo");
+  oop ref_oop = JNIHandles::resolve_non_null(ref);
+  oop referent = java_lang_ref_Reference::weak_referent_no_keepalive(ref_oop);
+  return referent == JNIHandles::resolve(o);
+JVM_END
+
+
+// java.lang.ref.PhantomReference //////////////////////////////////////////////////
+
+
+JVM_ENTRY(jboolean, JVM_PhantomReferenceRefersTo(JNIEnv* env, jobject ref, jobject o))
+  JVMWrapper("JVM_PhantomReferenceRefersTo");
+  oop ref_oop = JNIHandles::resolve_non_null(ref);
+  oop referent = java_lang_ref_Reference::phantom_referent_no_keepalive(ref_oop);
+  return referent == JNIHandles::resolve(o);
+JVM_END
+
 
 // ObjectInputStream ///////////////////////////////////////////////////////////////
 

src/java.base/share/classes/java/lang/ref/PhantomReference.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -60,6 +60,14 @@ public T get() {
         return null;
     }
 
+    /* Override the implementation of Reference.refersTo.
+     * Phantom references are weaker than finalization, so the referent
+     * access needs to be handled differently for garbage collectors that
+     * do reference processing concurrently.
+     */
+    @Override
+    native final boolean refersTo0(Object o);
+
     /**
      * Creates a new phantom reference that refers to the given object and
      * is registered with the given queue.

src/java.base/share/classes/java/lang/ref/Reference.java

@@ -325,14 +325,40 @@ public void runFinalization() {
      * been cleared, either by the program or by the garbage collector, then
      * this method returns {@code null}.
      *
+     * @apiNote
+     * This method returns a strong reference to the referent. This may cause
+     * the garbage collector to treat it as strongly reachable until some later
+     * collection cycle.  The {@link #refersTo(Object) refersTo} method can be
+     * used to avoid such strengthening when testing whether some object is
+     * the referent of a reference object; that is, use {@code ref.refersTo(obj)}
+     * rather than {@code ref.get() == obj}.
+     *
      * @return   The object to which this reference refers, or
      *           {@code null} if this reference object has been cleared
+     * @see refersTo
      */
     @IntrinsicCandidate
     public T get() {
         return this.referent;
     }
 
+    /**
+     * Tests if the referent of this reference object is {@code obj}.
+     * Using a {@code null} {@code obj} returns {@code true} if the
+     * reference object has been cleared.
+     *
+     * @param  obj the object to compare with this reference object's referent
+     * @return {@code true} if {@code obj} is the referent of this reference object
+     * @since 16
+     */
+    public final boolean refersTo(T obj) {
+        return refersTo0(obj);
+    }
+
+    /* Implementation of refersTo(), overridden for phantom references.
+     */
+    native boolean refersTo0(Object o);
+
     /**
      * Clears this reference object.  Invoking this method will not cause this
      * object to be enqueued.

src/java.base/share/native/libjava/PhantomReference.c

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "jvm.h"
+#include "java_lang_ref_PhantomReference.h"
+
+JNIEXPORT jboolean JNICALL
+Java_java_lang_ref_PhantomReference_refersTo0(JNIEnv *env, jobject ref, jobject o)
+{
+    return JVM_PhantomReferenceRefersTo(env, ref, o);
+}