src/hotspot/share/oops/klassVtable.hpp

@@ -90,11 +90,11 @@
                                                    Array<Method*>* methods,
                                                    AccessFlags class_flags,
                                                    u2 major_version,
                                                    Handle classloader,
                                                    Symbol* classname,
-                                                   Array<Klass*>* local_interfaces,
+                                                   Array<InstanceKlass*>* local_interfaces,
                                                    TRAPS);
 
 #if INCLUDE_JVMTI
   // RedefineClasses() API support:
   // If any entry of this vtable points to any of old_methods,

@@ -157,11 +157,11 @@
       GrowableArray<Method*>* new_mirandas,
       GrowableArray<Method*>* all_mirandas,
       const Klass* super,
       Array<Method*>* class_methods,
       Array<Method*>* default_methods,
-      Array<Klass*>* local_interfaces,
+      Array<InstanceKlass*>* local_interfaces,
       bool is_interface);
   void verify_against(outputStream* st, klassVtable* vt, int index);
   inline InstanceKlass* ik() const;
   // When loading a class from CDS archive at run time, and no class redefintion
   // has happened, it is expected that the class's itable/vtables are

@@ -233,21 +233,21 @@
 class klassItable;
 class itableMethodEntry;
 
 class itableOffsetEntry {
  private:
-  Klass* _interface;
+  InstanceKlass* _interface;
   int      _offset;
  public:
-  Klass* interface_klass() const { return _interface; }
-  Klass**interface_klass_addr()  { return &_interface; }
+  InstanceKlass* interface_klass() const { return _interface; }
+  InstanceKlass**interface_klass_addr()  { return &_interface; }
   int      offset() const          { return _offset; }
 
   static itableMethodEntry* method_entry(Klass* k, int offset) { return (itableMethodEntry*)(((address)k) + offset); }
   itableMethodEntry* first_method_entry(Klass* k)              { return method_entry(k, _offset); }
 
-  void initialize(Klass* interf, int offset) { _interface = interf; _offset = offset; }
+  void initialize(InstanceKlass* interf, int offset) { _interface = interf; _offset = offset; }
 
   // Static size and offset accessors
   static int size()                       { return sizeof(itableOffsetEntry) / wordSize; }    // size in words
   static int interface_offset_in_bytes()  { return offset_of(itableOffsetEntry, _interface); }
   static int offset_offset_in_bytes()     { return offset_of(itableOffsetEntry, _offset); }

@@ -298,11 +298,11 @@
   InstanceKlass*       _klass;             // my klass
   int                  _table_offset;      // offset of start of itable data within klass (in words)
   int                  _size_offset_table; // size of offset table (in itableOffset entries)
   int                  _size_method_table; // size of methodtable (in itableMethodEntry entries)
 
-  void initialize_itable_for_interface(int method_table_offset, Klass* interf_h, bool checkconstraints, TRAPS);
+  void initialize_itable_for_interface(int method_table_offset, InstanceKlass* interf_h, bool checkconstraints, TRAPS);
  public:
   klassItable(InstanceKlass* klass);
 
   itableOffsetEntry* offset_entry(int i) { assert(0 <= i && i <= _size_offset_table, "index out of bounds");
                                            return &((itableOffsetEntry*)vtable_start())[i]; }

@@ -326,17 +326,17 @@
   bool check_no_old_or_obsolete_entries();
   void dump_itable();
 #endif // INCLUDE_JVMTI
 
   // Setup of itable
-  static int assign_itable_indices_for_interface(Klass* klass, TRAPS);
-  static int method_count_for_interface(Klass* klass);
-  static int compute_itable_size(Array<Klass*>* transitive_interfaces);
+  static int assign_itable_indices_for_interface(InstanceKlass* klass, TRAPS);
+  static int method_count_for_interface(InstanceKlass* klass);
+  static int compute_itable_size(Array<InstanceKlass*>* transitive_interfaces);
   static void setup_itable_offset_table(InstanceKlass* klass);
 
   // Resolving of method to index
-  static Method* method_for_itable_index(Klass* klass, int itable_index);
+  static Method* method_for_itable_index(InstanceKlass* klass, int itable_index);
 
   // Debugging/Statistics
   static void print_statistics() PRODUCT_RETURN;
  private:
   intptr_t* vtable_start() const { return ((intptr_t*)_klass) + _table_offset; }