8285364: Remove REF_ enum for java.lang.ref.Reference

Co-authored-by: Stefan Karlsson <stefank@openjdk.org>
Reviewed-by: kbarrett, coleenp, stefank

Author: albertnetymk

src/hotspot/share/classfile/classFileParser.cpp

@@ -5577,7 +5577,6 @@ ClassFileParser::ClassFileParser(ClassFileStream* stream,
   _vtable_size(0),
   _itable_size(0),
   _num_miranda_methods(0),
-  _rt(REF_NONE),
   _protection_domain(cl_info->protection_domain()),
   _access_flags(),
   _pub_level(pub_level),
@@ -6058,10 +6057,6 @@ void ClassFileParser::post_process_parsed_stream(const ClassFileStream* const st
   FieldLayoutBuilder lb(class_name(), super_klass(), _cp, _fields,
                         _parsed_annotations->is_contended(), _field_info);
   lb.build_layout();
-
-  // Compute reference typ
-  _rt = (NULL ==_super_klass) ? REF_NONE : _super_klass->reference_type();
-
 }
 
 void ClassFileParser::set_klass(InstanceKlass* klass) {
@@ -6093,6 +6088,33 @@ const ClassFileStream* ClassFileParser::clone_stream() const {
 
   return _stream->clone();
 }
+
+ReferenceType ClassFileParser::super_reference_type() const {
+  return _super_klass == NULL ? REF_NONE : _super_klass->reference_type();
+}
+
+bool ClassFileParser::is_instance_ref_klass() const {
+  // Only the subclasses of j.l.r.Reference are InstanceRefKlass.
+  // j.l.r.Reference itself is InstanceKlass because InstanceRefKlass denotes a
+  // klass requiring special treatment in ref-processing. The abstract
+  // j.l.r.Reference cannot be instantiated so doesn't partake in
+  // ref-processing.
+  return is_java_lang_ref_Reference_subclass();
+}
+
+bool ClassFileParser::is_java_lang_ref_Reference_subclass() const {
+  if (_super_klass == NULL) {
+    return false;
+  }
+
+  if (_super_klass->name() == vmSymbols::java_lang_ref_Reference()) {
+    // Direct subclass of j.l.r.Reference: Soft|Weak|Final|Phantom
+    return true;
+  }
+
+  return _super_klass->reference_type() != REF_NONE;
+}
+
 // ----------------------------------------------------------------------------
 // debugging
 

src/hotspot/share/classfile/classFileParser.hpp

@@ -154,7 +154,6 @@ class ClassFileParser {
 
   int _num_miranda_methods;
 
-  ReferenceType _rt;
   Handle _protection_domain;
   AccessFlags _access_flags;
 
@@ -561,7 +560,10 @@ class ClassFileParser {
   const Symbol* class_name() const { return _class_name; }
   const InstanceKlass* super_klass() const { return _super_klass; }
 
-  ReferenceType reference_type() const { return _rt; }
+  ReferenceType super_reference_type() const;
+  bool is_instance_ref_klass() const;
+  bool is_java_lang_ref_Reference_subclass() const;
+
   AccessFlags access_flags() const { return _access_flags; }
 
   bool is_internal() const { return INTERNAL == _pub_level; }

src/hotspot/share/classfile/vmClasses.cpp

@@ -168,7 +168,7 @@ void vmClasses::resolve_all(TRAPS) {
 
   if (UseSharedSpaces) {
     // These should already have been initialized during CDS dump.
-    assert(vmClasses::Reference_klass()->reference_type() == REF_OTHER, "sanity");
+    assert(vmClasses::Reference_klass()->reference_type() == REF_NONE, "sanity");
     assert(vmClasses::SoftReference_klass()->reference_type() == REF_SOFT, "sanity");
     assert(vmClasses::WeakReference_klass()->reference_type() == REF_WEAK, "sanity");
     assert(vmClasses::FinalReference_klass()->reference_type() == REF_FINAL, "sanity");
@@ -186,14 +186,9 @@ void vmClasses::resolve_all(TRAPS) {
     java_lang_ref_Reference::compute_offsets();
 
     // Preload ref klasses and set reference types
-    vmClasses::Reference_klass()->set_reference_type(REF_OTHER);
     InstanceRefKlass::update_nonstatic_oop_maps(vmClasses::Reference_klass());
 
     resolve_through(VM_CLASS_ID(PhantomReference_klass), scan, CHECK);
-    vmClasses::SoftReference_klass()->set_reference_type(REF_SOFT);
-    vmClasses::WeakReference_klass()->set_reference_type(REF_WEAK);
-    vmClasses::FinalReference_klass()->set_reference_type(REF_FINAL);
-    vmClasses::PhantomReference_klass()->set_reference_type(REF_PHANTOM);
   }
 
   resolve_until(vmClassID::LIMIT, scan, CHECK);

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

@@ -437,7 +437,6 @@ size_t ReferenceProcessor::total_reference_count(ReferenceType type) const {
     case REF_PHANTOM:
       list = _discoveredPhantomRefs;
       break;
-    case REF_OTHER:
     case REF_NONE:
     default:
       ShouldNotReachHere();
@@ -840,8 +839,6 @@ inline DiscoveredList* ReferenceProcessor::get_discovered_list(ReferenceType rt)
     case REF_PHANTOM:
       list = &_discoveredPhantomRefs[id];
       break;
-    case REF_OTHER:
-      // Unknown reference type, impossible
     case REF_NONE:
       // we should not reach here if we are an InstanceRefKlass
     default:

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

@@ -293,7 +293,7 @@ class ReferenceProcessor : public ReferenceDiscoverer {
     _current_soft_ref_policy->setup();   // snapshot the policy threshold
   }
 public:
-  static int number_of_subclasses_of_ref() { return (REF_PHANTOM - REF_OTHER); }
+  static int number_of_subclasses_of_ref() { return (REF_PHANTOM - REF_NONE); }
 
   uint num_queues() const                  { return _num_queues; }
   uint max_num_queues() const              { return _max_num_queues; }

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

@@ -73,7 +73,7 @@ static const char* PhaseNames[ReferenceProcessor::RefPhaseMax] = {
        };
 
 static const char* ReferenceTypeNames[REF_PHANTOM + 1] = {
-       "None", "Other", "SoftReference", "WeakReference", "FinalReference", "PhantomReference"
+       "None", "SoftReference", "WeakReference", "FinalReference", "PhantomReference"
        };
 
 STATIC_ASSERT((REF_PHANTOM + 1) == ARRAY_SIZE(ReferenceTypeNames));

src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.hpp

@@ -37,7 +37,7 @@ class GCTimer;
 class LogStream;
 
 class ReferenceProcessorPhaseTimes : public CHeapObj<mtGC> {
-  static const int number_of_subclasses_of_ref = REF_PHANTOM - REF_OTHER; // 5 - 1 = 4
+  static const int number_of_subclasses_of_ref = REF_PHANTOM - REF_NONE; // 4 - 0 = 4
 
   // Records per thread time information of each sub phase.
   WorkerDataArray<double>* _sub_phases_worker_time_sec[ReferenceProcessor::RefSubPhaseMax];

src/hotspot/share/jfr/recorder/checkpoint/types/jfrType.cpp

@@ -219,7 +219,6 @@ void MetaspaceObjectTypeConstant::serialize(JfrCheckpointWriter& writer) {
 static const char* reference_type_to_string(ReferenceType rt) {
   switch (rt) {
     case REF_NONE: return "None reference";
-    case REF_OTHER: return "Other reference";
     case REF_SOFT: return "Soft reference";
     case REF_WEAK: return "Weak reference";
     case REF_FINAL: return "Final reference";

src/hotspot/share/memory/referenceType.hpp

@@ -31,7 +31,6 @@
 
 enum ReferenceType {
   REF_NONE,      // Regular class
-  REF_OTHER,     // Subclass of java/lang/ref/Reference, but not subclass of one of the classes below
   REF_SOFT,      // Subclass of java/lang/ref/SoftReference
   REF_WEAK,      // Subclass of java/lang/ref/WeakReference
   REF_FINAL,     // Subclass of java/lang/ref/FinalReference

src/hotspot/share/oops/instanceKlass.cpp

@@ -446,23 +446,21 @@ InstanceKlass* InstanceKlass::allocate_instance_klass(const ClassFileParser& par
   InstanceKlass* ik;
 
   // Allocation
-  if (REF_NONE == parser.reference_type()) {
-    if (class_name == vmSymbols::java_lang_Class()) {
-      // mirror - java.lang.Class
-      ik = new (loader_data, size, THREAD) InstanceMirrorKlass(parser);
-    } else if (is_stack_chunk_class(class_name, loader_data)) {
-      // stack chunk
-      ik = new (loader_data, size, THREAD) InstanceStackChunkKlass(parser);
-    } else if (is_class_loader(class_name, parser)) {
-      // class loader - java.lang.ClassLoader
-      ik = new (loader_data, size, THREAD) InstanceClassLoaderKlass(parser);
-    } else {
-      // normal
-      ik = new (loader_data, size, THREAD) InstanceKlass(parser);
-    }
-  } else {
+  if (parser.is_instance_ref_klass()) {
     // java.lang.ref.Reference
     ik = new (loader_data, size, THREAD) InstanceRefKlass(parser);
+  } else if (class_name == vmSymbols::java_lang_Class()) {
+    // mirror - java.lang.Class
+    ik = new (loader_data, size, THREAD) InstanceMirrorKlass(parser);
+  } else if (is_stack_chunk_class(class_name, loader_data)) {
+    // stack chunk
+    ik = new (loader_data, size, THREAD) InstanceStackChunkKlass(parser);
+  } else if (is_class_loader(class_name, parser)) {
+    // class loader - java.lang.ClassLoader
+    ik = new (loader_data, size, THREAD) InstanceClassLoaderKlass(parser);
+  } else {
+    // normal
+    ik = new (loader_data, size, THREAD) InstanceKlass(parser);
   }
 
   // Check for pending exception before adding to the loader data and incrementing
@@ -500,7 +498,7 @@ static Monitor* create_init_monitor(const char* name) {
   return new Monitor(Mutex::safepoint, name);
 }
 
-InstanceKlass::InstanceKlass(const ClassFileParser& parser, KlassKind kind) :
+InstanceKlass::InstanceKlass(const ClassFileParser& parser, KlassKind kind, ReferenceType reference_type) :
   Klass(kind),
   _nest_members(NULL),
   _nest_host(NULL),
@@ -511,7 +509,7 @@ InstanceKlass::InstanceKlass(const ClassFileParser& parser, KlassKind kind) :
   _itable_len(parser.itable_size()),
   _nest_host_index(0),
   _init_state(allocated),
-  _reference_type(parser.reference_type()),
+  _reference_type(reference_type),
   _init_monitor(create_init_monitor("InstanceKlassInitMonitor_lock")),
   _init_thread(NULL)
 {

src/hotspot/share/oops/instanceKlass.hpp

@@ -136,7 +136,7 @@ class InstanceKlass: public Klass {
   static const KlassKind Kind = InstanceKlassKind;
 
  protected:
-  InstanceKlass(const ClassFileParser& parser, KlassKind kind = Kind);
+  InstanceKlass(const ClassFileParser& parser, KlassKind kind = Kind, ReferenceType reference_type = REF_NONE);
 
  public:
   InstanceKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); }
@@ -592,10 +592,6 @@ class InstanceKlass: public Klass {
 
   // reference type
   ReferenceType reference_type() const     { return (ReferenceType)_reference_type; }
-  void set_reference_type(ReferenceType t) {
-    assert(t == (u1)t, "overflow");
-    _reference_type = (u1)t;
-  }
 
   // this class cp index
   u2 this_class_index() const             { return _this_class_index; }

src/hotspot/share/oops/instanceRefKlass.cpp

@@ -23,11 +23,43 @@
  */
 
 #include "precompiled.hpp"
+#include "classfile/classFileParser.hpp"
 #include "classfile/javaClasses.hpp"
 #include "classfile/vmClasses.hpp"
+#include "classfile/vmSymbols.hpp"
 #include "oops/instanceRefKlass.inline.hpp"
 #include "oops/oop.inline.hpp"
 
+static ReferenceType reference_subclass_name_to_type(const Symbol* name) {
+  if (       name == vmSymbols::java_lang_ref_SoftReference()) {
+    return REF_SOFT;
+  } else if (name == vmSymbols::java_lang_ref_WeakReference()) {
+    return REF_WEAK;
+  } else if (name == vmSymbols::java_lang_ref_FinalReference()) {
+    return REF_FINAL;
+  } else if (name == vmSymbols::java_lang_ref_PhantomReference()) {
+    return REF_PHANTOM;
+  } else {
+    ShouldNotReachHere();
+    return REF_NONE;
+  }
+}
+
+static ReferenceType determine_reference_type(const ClassFileParser& parser) {
+  const ReferenceType rt = parser.super_reference_type();
+  if (rt != REF_NONE) {
+    // Inherit type from super class
+    return rt;
+  }
+
+  // Bootstrapping: this is one of the direct subclasses of java.lang.ref.Reference
+  const Symbol* const name = parser.class_name();
+  return reference_subclass_name_to_type(name);
+}
+
+InstanceRefKlass::InstanceRefKlass(const ClassFileParser& parser)
+  : InstanceKlass(parser, Kind, determine_reference_type(parser)) {}
+
 void InstanceRefKlass::update_nonstatic_oop_maps(Klass* k) {
   // Clear the nonstatic oop-map entries corresponding to referent
   // and discovered fields.  They are treated specially by the

src/hotspot/share/oops/instanceRefKlass.hpp

@@ -53,7 +53,7 @@ class InstanceRefKlass: public InstanceKlass {
   static const KlassKind Kind = InstanceRefKlassKind;
 
  private:
-  InstanceRefKlass(const ClassFileParser& parser) : InstanceKlass(parser, Kind) {}
+  InstanceRefKlass(const ClassFileParser& parser);
 
  public:
   InstanceRefKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); }

src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/memory/ReferenceType.java

@@ -28,7 +28,6 @@
 
 public enum ReferenceType {
   REF_NONE ("None reference"),       // Regular class
-  REF_OTHER ("Other reference"),     // Subclass of java/lang/ref/Reference, but not subclass of one of the classes below
   REF_SOFT ("Soft reference"),       // Subclass of java/lang/ref/SoftReference
   REF_WEAK ("Weak reference"),       // Subclass of java/lang/ref/WeakReference
   REF_FINAL ("Final reference"),     // Subclass of java/lang/ref/FinalReference