8329750: Change Universe functions to return more specific Klass* types

stefank · stefank · commit 492b954f81f7 · 2024-04-09T12:31:13.000Z
Reviewed-by: coleenp
diff --git a/src/hotspot/share/classfile/systemDictionary.cpp b/src/hotspot/share/classfile/systemDictionary.cpp
@@ -368,7 +368,7 @@ Klass* SystemDictionary::resolve_array_class_or_null(Symbol* class_name,
     }
   } else {
     k = Universe::typeArrayKlass(t);
-    k = TypeArrayKlass::cast(k)->array_klass(ndims, CHECK_NULL);
+    k = k->array_klass(ndims, CHECK_NULL);
   }
   return k;
 }
diff --git a/src/hotspot/share/jvmci/jvmciCompilerToVM.cpp b/src/hotspot/share/jvmci/jvmciCompilerToVM.cpp
@@ -636,7 +636,7 @@ C2V_VMENTRY_NULL(jobject, lookupType, (JNIEnv* env, jobject, jstring jname, ARGU
           resolved_klass = resolved_klass->array_klass(ndim, CHECK_NULL);
         }
       } else {
-        resolved_klass = TypeArrayKlass::cast(Universe::typeArrayKlass(ss.type()))->array_klass(ndim, CHECK_NULL);
+        resolved_klass = Universe::typeArrayKlass(ss.type())->array_klass(ndim, CHECK_NULL);
       }
     } else {
       resolved_klass = SystemDictionary::find_instance_klass(THREAD, class_name,
diff --git a/src/hotspot/share/memory/oopFactory.cpp b/src/hotspot/share/memory/oopFactory.cpp
@@ -41,41 +41,41 @@
 #include "utilities/utf8.hpp"
 
 typeArrayOop oopFactory::new_boolArray(int length, TRAPS) {
-  return TypeArrayKlass::cast(Universe::boolArrayKlass())->allocate(length, THREAD);
+  return Universe::boolArrayKlass()->allocate(length, THREAD);
 }
 
 typeArrayOop oopFactory::new_charArray(int length, TRAPS) {
-  return TypeArrayKlass::cast(Universe::charArrayKlass())->allocate(length, THREAD);
+  return Universe::charArrayKlass()->allocate(length, THREAD);
 }
 
 typeArrayOop oopFactory::new_floatArray(int length, TRAPS) {
-  return TypeArrayKlass::cast(Universe::floatArrayKlass())->allocate(length, THREAD);
+  return Universe::floatArrayKlass()->allocate(length, THREAD);
 }
 
 typeArrayOop oopFactory::new_doubleArray(int length, TRAPS) {
-  return TypeArrayKlass::cast(Universe::doubleArrayKlass())->allocate(length, THREAD);
+  return Universe::doubleArrayKlass()->allocate(length, THREAD);
 }
 
 typeArrayOop oopFactory::new_byteArray(int length, TRAPS) {
-  return TypeArrayKlass::cast(Universe::byteArrayKlass())->allocate(length, THREAD);
+  return Universe::byteArrayKlass()->allocate(length, THREAD);
 }
 
 typeArrayOop oopFactory::new_shortArray(int length, TRAPS) {
-  return TypeArrayKlass::cast(Universe::shortArrayKlass())->allocate(length, THREAD);
+  return Universe::shortArrayKlass()->allocate(length, THREAD);
 }
 
 typeArrayOop oopFactory::new_intArray(int length, TRAPS) {
-  return TypeArrayKlass::cast(Universe::intArrayKlass())->allocate(length, THREAD);
+  return Universe::intArrayKlass()->allocate(length, THREAD);
 }
 
 typeArrayOop oopFactory::new_longArray(int length, TRAPS) {
-  return TypeArrayKlass::cast(Universe::longArrayKlass())->allocate(length, THREAD);
+  return Universe::longArrayKlass()->allocate(length, THREAD);
 }
 
 // create java.lang.Object[]
 objArrayOop oopFactory::new_objectArray(int length, TRAPS)  {
   assert(Universe::objectArrayKlass() != nullptr, "Too early?");
-  return ObjArrayKlass::cast(Universe::objectArrayKlass())->allocate(length, THREAD);
+  return Universe::objectArrayKlass()->allocate(length, THREAD);
 }
 
 typeArrayOop oopFactory::new_charArray(const char* utf8_str, TRAPS) {
@@ -88,10 +88,8 @@ typeArrayOop oopFactory::new_charArray(const char* utf8_str, TRAPS) {
 }
 
 typeArrayOop oopFactory::new_typeArray(BasicType type, int length, TRAPS) {
-  Klass* klass = Universe::typeArrayKlass(type);
-  TypeArrayKlass* typeArrayKlass = TypeArrayKlass::cast(klass);
-  typeArrayOop result = typeArrayKlass->allocate(length, THREAD);
-  return result;
+  TypeArrayKlass* klass = Universe::typeArrayKlass(type);
+  return klass->allocate(length, THREAD);
 }
 
 // Create a Java array that points to Symbol.
@@ -100,17 +98,12 @@ typeArrayOop oopFactory::new_typeArray(BasicType type, int length, TRAPS) {
 // this.  They cast Symbol* into this type.
 typeArrayOop oopFactory::new_symbolArray(int length, TRAPS) {
   BasicType type = LP64_ONLY(T_LONG) NOT_LP64(T_INT);
-  Klass* klass = Universe::typeArrayKlass(type);
-  TypeArrayKlass* typeArrayKlass = TypeArrayKlass::cast(klass);
-  typeArrayOop result = typeArrayKlass->allocate(length, THREAD);
-  return result;
+  return new_typeArray(type, length, THREAD);
 }
 
 typeArrayOop oopFactory::new_typeArray_nozero(BasicType type, int length, TRAPS) {
-  Klass* klass = Universe::typeArrayKlass(type);
-  TypeArrayKlass* typeArrayKlass = TypeArrayKlass::cast(klass);
-  typeArrayOop result = typeArrayKlass->allocate_common(length, false, THREAD);
-  return result;
+  TypeArrayKlass* klass = Universe::typeArrayKlass(type);
+  return klass->allocate_common(length, false, THREAD);
 }
 
 
diff --git a/src/hotspot/share/memory/universe.cpp b/src/hotspot/share/memory/universe.cpp
@@ -111,9 +111,9 @@ static LatestMethodCache _throw_no_such_method_error_cache; // Unsafe.throwNoSuc
 static LatestMethodCache _do_stack_walk_cache;              // AbstractStackWalker.doStackWalk()
 
 // Known objects
-Klass* Universe::_typeArrayKlasses[T_LONG+1]        = { nullptr /*, nullptr...*/ };
-Klass* Universe::_objectArrayKlass                  = nullptr;
-Klass* Universe::_fillerArrayKlass                  = nullptr;
+TypeArrayKlass* Universe::_typeArrayKlasses[T_LONG+1] = { nullptr /*, nullptr...*/ };
+ObjArrayKlass* Universe::_objectArrayKlass            = nullptr;
+Klass* Universe::_fillerArrayKlass                    = nullptr;
 OopHandle Universe::_basic_type_mirrors[T_VOID+1];
 #if INCLUDE_CDS_JAVA_HEAP
 int Universe::_archived_basic_type_mirror_indices[T_VOID+1];
@@ -472,8 +472,10 @@ void Universe::genesis(TRAPS) {
   // ordinary object arrays, _objectArrayKlass will be loaded when
   // SystemDictionary::initialize(CHECK); is run. See the extra check
   // for Object_klass_loaded in objArrayKlassKlass::allocate_objArray_klass_impl.
-  _objectArrayKlass = InstanceKlass::
-    cast(vmClasses::Object_klass())->array_klass(1, CHECK);
+  {
+    Klass* oak = vmClasses::Object_klass()->array_klass(CHECK);
+    _objectArrayKlass = ObjArrayKlass::cast(oak);
+  }
   // OLD
   // Add the class to the class hierarchy manually to make sure that
   // its vtable is initialized after core bootstrapping is completed.
diff --git a/src/hotspot/share/memory/universe.hpp b/src/hotspot/share/memory/universe.hpp
@@ -65,8 +65,8 @@ class Universe: AllStatic {
 
  private:
   // Known classes in the VM
-  static Klass* _typeArrayKlasses[T_LONG+1];
-  static Klass* _objectArrayKlass;
+  static TypeArrayKlass* _typeArrayKlasses[T_LONG+1];
+  static ObjArrayKlass* _objectArrayKlass;
   // Special int-Array that represents filler objects that are used by GC to overwrite
   // dead objects. References to them are generally an error.
   static Klass* _fillerArrayKlass;
@@ -174,20 +174,20 @@ class Universe: AllStatic {
   static void set_verify_data(uintptr_t mask, uintptr_t bits) PRODUCT_RETURN;
 
   // Known classes in the VM
-  static Klass* boolArrayKlass()                 { return typeArrayKlass(T_BOOLEAN); }
-  static Klass* byteArrayKlass()                 { return typeArrayKlass(T_BYTE); }
-  static Klass* charArrayKlass()                 { return typeArrayKlass(T_CHAR); }
-  static Klass* intArrayKlass()                  { return typeArrayKlass(T_INT); }
-  static Klass* shortArrayKlass()                { return typeArrayKlass(T_SHORT); }
-  static Klass* longArrayKlass()                 { return typeArrayKlass(T_LONG); }
-  static Klass* floatArrayKlass()                { return typeArrayKlass(T_FLOAT); }
-  static Klass* doubleArrayKlass()               { return typeArrayKlass(T_DOUBLE); }
+  static TypeArrayKlass* boolArrayKlass()        { return typeArrayKlass(T_BOOLEAN); }
+  static TypeArrayKlass* byteArrayKlass()        { return typeArrayKlass(T_BYTE); }
+  static TypeArrayKlass* charArrayKlass()        { return typeArrayKlass(T_CHAR); }
+  static TypeArrayKlass* intArrayKlass()         { return typeArrayKlass(T_INT); }
+  static TypeArrayKlass* shortArrayKlass()       { return typeArrayKlass(T_SHORT); }
+  static TypeArrayKlass* longArrayKlass()        { return typeArrayKlass(T_LONG); }
+  static TypeArrayKlass* floatArrayKlass()       { return typeArrayKlass(T_FLOAT); }
+  static TypeArrayKlass* doubleArrayKlass()      { return typeArrayKlass(T_DOUBLE); }
 
-  static Klass* objectArrayKlass()               { return _objectArrayKlass; }
+  static ObjArrayKlass* objectArrayKlass()       { return _objectArrayKlass; }
 
   static Klass* fillerArrayKlass()               { return _fillerArrayKlass; }
 
-  static Klass* typeArrayKlass(BasicType t) {
+  static TypeArrayKlass* typeArrayKlass(BasicType t) {
     assert((uint)t >= T_BOOLEAN, "range check for type: %s", type2name(t));
     assert((uint)t < T_LONG+1,   "range check for type: %s", type2name(t));
     assert(_typeArrayKlasses[t] != nullptr, "domain check");
diff --git a/src/hotspot/share/prims/vectorSupport.cpp b/src/hotspot/share/prims/vectorSupport.cpp
@@ -138,7 +138,7 @@ Handle VectorSupport::allocate_vector_payload_helper(InstanceKlass* ik, frame* f
   int elem_size = type2aelembytes(elem_bt);
 
   // On-heap vector values are represented as primitive arrays.
-  TypeArrayKlass* tak = TypeArrayKlass::cast(Universe::typeArrayKlass(elem_bt));
+  TypeArrayKlass* tak = Universe::typeArrayKlass(elem_bt);
 
   typeArrayOop arr = tak->allocate(num_elem, CHECK_NH); // safepoint
 

Original file line number	Diff line number	Diff line change
`@@ -368,7 +368,7 @@ Klass* SystemDictionary::resolve_array_class_or_null(Symbol* class_name,`
`368`	`368`	`}`
`369`	`369`	`} else {`
`370`	`370`	`k = Universe::typeArrayKlass(t);`
`371`		`- k = TypeArrayKlass::cast(k)->array_klass(ndims, CHECK_NULL);`
	`371`	`+ k = k->array_klass(ndims, CHECK_NULL);`
`372`	`372`	`}`
`373`	`373`	`return k;`
`374`	`374`	`}`
Original file line number	Diff line number	Diff line change
`@@ -636,7 +636,7 @@ C2V_VMENTRY_NULL(jobject, lookupType, (JNIEnv* env, jobject, jstring jname, ARGU`
`636`	`636`	`resolved_klass = resolved_klass->array_klass(ndim, CHECK_NULL);`
`637`	`637`	`}`
`638`	`638`	`} else {`
`639`		`- resolved_klass = TypeArrayKlass::cast(Universe::typeArrayKlass(ss.type()))->array_klass(ndim, CHECK_NULL);`
	`639`	`+ resolved_klass = Universe::typeArrayKlass(ss.type())->array_klass(ndim, CHECK_NULL);`
`640`	`640`	`}`
`641`	`641`	`} else {`
`642`	`642`	`resolved_klass = SystemDictionary::find_instance_klass(THREAD, class_name,`
Original file line number	Diff line number	Diff line change
`@@ -41,41 +41,41 @@`
`41`	`41`	`#include "utilities/utf8.hpp"`
`42`	`42`
`43`	`43`	`typeArrayOop oopFactory::new_boolArray(int length, TRAPS) {`
`44`		`- return TypeArrayKlass::cast(Universe::boolArrayKlass())->allocate(length, THREAD);`
	`44`	`+ return Universe::boolArrayKlass()->allocate(length, THREAD);`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`typeArrayOop oopFactory::new_charArray(int length, TRAPS) {`
`48`		`- return TypeArrayKlass::cast(Universe::charArrayKlass())->allocate(length, THREAD);`
	`48`	`+ return Universe::charArrayKlass()->allocate(length, THREAD);`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`typeArrayOop oopFactory::new_floatArray(int length, TRAPS) {`
`52`		`- return TypeArrayKlass::cast(Universe::floatArrayKlass())->allocate(length, THREAD);`
	`52`	`+ return Universe::floatArrayKlass()->allocate(length, THREAD);`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`typeArrayOop oopFactory::new_doubleArray(int length, TRAPS) {`
`56`		`- return TypeArrayKlass::cast(Universe::doubleArrayKlass())->allocate(length, THREAD);`
	`56`	`+ return Universe::doubleArrayKlass()->allocate(length, THREAD);`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`typeArrayOop oopFactory::new_byteArray(int length, TRAPS) {`
`60`		`- return TypeArrayKlass::cast(Universe::byteArrayKlass())->allocate(length, THREAD);`
	`60`	`+ return Universe::byteArrayKlass()->allocate(length, THREAD);`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`typeArrayOop oopFactory::new_shortArray(int length, TRAPS) {`
`64`		`- return TypeArrayKlass::cast(Universe::shortArrayKlass())->allocate(length, THREAD);`
	`64`	`+ return Universe::shortArrayKlass()->allocate(length, THREAD);`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`typeArrayOop oopFactory::new_intArray(int length, TRAPS) {`
`68`		`- return TypeArrayKlass::cast(Universe::intArrayKlass())->allocate(length, THREAD);`
	`68`	`+ return Universe::intArrayKlass()->allocate(length, THREAD);`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`typeArrayOop oopFactory::new_longArray(int length, TRAPS) {`
`72`		`- return TypeArrayKlass::cast(Universe::longArrayKlass())->allocate(length, THREAD);`
	`72`	`+ return Universe::longArrayKlass()->allocate(length, THREAD);`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`// create java.lang.Object[]`
`76`	`76`	`objArrayOop oopFactory::new_objectArray(int length, TRAPS) {`
`77`	`77`	`assert(Universe::objectArrayKlass() != nullptr, "Too early?");`
`78`		`- return ObjArrayKlass::cast(Universe::objectArrayKlass())->allocate(length, THREAD);`
	`78`	`+ return Universe::objectArrayKlass()->allocate(length, THREAD);`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`typeArrayOop oopFactory::new_charArray(const char* utf8_str, TRAPS) {`
`@@ -88,10 +88,8 @@ typeArrayOop oopFactory::new_charArray(const char* utf8_str, TRAPS) {`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`typeArrayOop oopFactory::new_typeArray(BasicType type, int length, TRAPS) {`
`91`		`- Klass* klass = Universe::typeArrayKlass(type);`
`92`		`- TypeArrayKlass* typeArrayKlass = TypeArrayKlass::cast(klass);`
`93`		`- typeArrayOop result = typeArrayKlass->allocate(length, THREAD);`
`94`		`- return result;`
	`91`	`+ TypeArrayKlass* klass = Universe::typeArrayKlass(type);`
	`92`	`+ return klass->allocate(length, THREAD);`
`95`	`93`	`}`
`96`	`94`
`97`	`95`	`// Create a Java array that points to Symbol.`
`@@ -100,17 +98,12 @@ typeArrayOop oopFactory::new_typeArray(BasicType type, int length, TRAPS) {`
`100`	`98`	`// this. They cast Symbol* into this type.`
`101`	`99`	`typeArrayOop oopFactory::new_symbolArray(int length, TRAPS) {`
`102`	`100`	`BasicType type = LP64_ONLY(T_LONG) NOT_LP64(T_INT);`
`103`		`- Klass* klass = Universe::typeArrayKlass(type);`
`104`		`- TypeArrayKlass* typeArrayKlass = TypeArrayKlass::cast(klass);`
`105`		`- typeArrayOop result = typeArrayKlass->allocate(length, THREAD);`
`106`		`- return result;`
	`101`	`+ return new_typeArray(type, length, THREAD);`
`107`	`102`	`}`
`108`	`103`
`109`	`104`	`typeArrayOop oopFactory::new_typeArray_nozero(BasicType type, int length, TRAPS) {`
`110`		`- Klass* klass = Universe::typeArrayKlass(type);`
`111`		`- TypeArrayKlass* typeArrayKlass = TypeArrayKlass::cast(klass);`
`112`		`- typeArrayOop result = typeArrayKlass->allocate_common(length, false, THREAD);`
`113`		`- return result;`
	`105`	`+ TypeArrayKlass* klass = Universe::typeArrayKlass(type);`
	`106`	`+ return klass->allocate_common(length, false, THREAD);`
`114`	`107`	`}`
`115`	`108`
`116`	`109`