src/hotspot/share/classfile/systemDictionaryShared.hpp

@@ -130,11 +130,11 @@
   void*           _verifier_constraints; // FIXME - use a union here to avoid type casting??
   void*           _verifier_constraint_flags;
 
   // See "Identifying the loader_type of archived classes" comments above.
   LoaderType loader_type() const {
-    Klass* k = (Klass*)literal();
+    InstanceKlass* k = instance_klass();
 
     if ((k->shared_classpath_index() != UNREGISTERED_INDEX)) {
       return LT_BUILTIN;
     } else {
       return LT_UNREGISTERED;

@@ -169,21 +169,21 @@
   SharedDictionaryEntry* bucket(int index) const {
     return (SharedDictionaryEntry*)(Dictionary::bucket(index));
   }
 
 public:
-  SharedDictionaryEntry* find_entry_for(Klass* klass);
+  SharedDictionaryEntry* find_entry_for(InstanceKlass* klass);
   void finalize_verification_constraints();
 
   bool add_non_builtin_klass(const Symbol* class_name,
                              ClassLoaderData* loader_data,
                              InstanceKlass* obj);
 
-  void update_entry(Klass* klass, int id);
+  void update_entry(InstanceKlass* klass, int id);
 
-  Klass* find_class_for_builtin_loader(const Symbol* name) const;
-  Klass* find_class_for_unregistered_loader(const Symbol* name,
+  InstanceKlass* find_class_for_builtin_loader(const Symbol* name) const;
+  InstanceKlass* find_class_for_unregistered_loader(const Symbol* name,
                                             int clsfile_size,
                                             int clsfile_crc32) const;
   bool class_exists_for_unregistered_loader(const Symbol* name) {
     return (get_entry_for_unregistered_loader(name, -1, -1) != NULL);
   }

@@ -315,21 +315,21 @@
     return NULL;
   }
 
   static bool add_non_builtin_klass(Symbol* class_name, ClassLoaderData* loader_data,
                                     InstanceKlass* k, TRAPS);
-  static Klass* dump_time_resolve_super_or_fail(Symbol* child_name,
+  static InstanceKlass* dump_time_resolve_super_or_fail(Symbol* child_name,
                                                 Symbol* class_name,
                                                 Handle class_loader,
                                                 Handle protection_domain,
                                                 bool is_superclass,
                                                 TRAPS);
 
   static size_t dictionary_entry_size() {
     return (DumpSharedSpaces) ? sizeof(SharedDictionaryEntry) : sizeof(DictionaryEntry);
   }
-  static void init_shared_dictionary_entry(Klass* k, DictionaryEntry* entry) NOT_CDS_RETURN;
+  static void init_shared_dictionary_entry(InstanceKlass* k, DictionaryEntry* entry) NOT_CDS_RETURN;
   static bool is_builtin(DictionaryEntry* ent) {
     // Can't use virtual function is_builtin because DictionaryEntry doesn't initialize
     // vtable because it's not constructed properly.
     SharedDictionaryEntry* entry = (SharedDictionaryEntry*)ent;
     return entry->is_builtin();

@@ -343,17 +343,17 @@
 
   static SharedDictionary* boot_loader_dictionary() {
     return (SharedDictionary*)ClassLoaderData::the_null_class_loader_data()->dictionary();
   }
 
-  static void update_shared_entry(Klass* klass, int id) {
+  static void update_shared_entry(InstanceKlass* klass, int id) {
     assert(DumpSharedSpaces, "sanity");
     assert((SharedDictionary*)(klass->class_loader_data()->dictionary()) != NULL, "sanity");
     ((SharedDictionary*)(klass->class_loader_data()->dictionary()))->update_entry(klass, id);
   }
 
-  static void set_shared_class_misc_info(Klass* k, ClassFileStream* cfs);
+  static void set_shared_class_misc_info(InstanceKlass* k, ClassFileStream* cfs);
 
   static InstanceKlass* lookup_from_stream(const Symbol* class_name,
                                            Handle class_loader,
                                            Handle protection_domain,
                                            const ClassFileStream* st,

@@ -365,11 +365,11 @@
   // With AppCDS, it is possible to override archived classes by calling
   // ClassLoader.defineClass() directly. SystemDictionary::load_shared_class() already
   // ensures that you cannot load a shared class if its super type(s) are changed. However,
   // we need an additional check to ensure that the verification_constraints did not change
   // between dump time and runtime.
-  static bool add_verification_constraint(Klass* k, Symbol* name,
+  static bool add_verification_constraint(InstanceKlass* k, Symbol* name,
                   Symbol* from_name, bool from_field_is_protected,
                   bool from_is_array, bool from_is_object) NOT_CDS_RETURN_(false);
   static void finalize_verification_constraints() NOT_CDS_RETURN;
   static void check_verification_constraints(InstanceKlass* klass,
                                               TRAPS) NOT_CDS_RETURN;