< prev index next >

src/share/vm/classfile/loaderConstraints.hpp

Print this page

        

@@ -30,11 +30,11 @@
 #include "utilities/hashtable.hpp"
 
 class LoaderConstraintEntry;
 class Symbol;
 
-class LoaderConstraintTable : public Hashtable<Klass*, mtClass> {
+class LoaderConstraintTable : public Hashtable<InstanceKlass*, mtClass> {
   friend class VMStructs;
 private:
 
   enum Constants {
     _loader_constraint_size = 107,                     // number of entries in constraint table

@@ -47,57 +47,55 @@
 public:
 
   LoaderConstraintTable(int nof_buckets);
 
   LoaderConstraintEntry* new_entry(unsigned int hash, Symbol* name,
-                                   Klass* klass, int num_loaders,
+                                   InstanceKlass* klass, int num_loaders,
                                    int max_loaders);
   void free_entry(LoaderConstraintEntry *entry);
 
   LoaderConstraintEntry* bucket(int i) {
-    return (LoaderConstraintEntry*)Hashtable<Klass*, mtClass>::bucket(i);
+    return (LoaderConstraintEntry*)Hashtable<InstanceKlass*, mtClass>::bucket(i);
   }
 
   LoaderConstraintEntry** bucket_addr(int i) {
-    return (LoaderConstraintEntry**)Hashtable<Klass*, mtClass>::bucket_addr(i);
+    return (LoaderConstraintEntry**)Hashtable<InstanceKlass*, mtClass>::bucket_addr(i);
   }
 
   // Enhanced Class Redefinition support
   void classes_do(KlassClosure* f);
 
   // Check class loader constraints
-  bool add_entry(Symbol* name, Klass* klass1, Handle loader1,
-                                    Klass* klass2, Handle loader2);
+  bool add_entry(Symbol* name, InstanceKlass* klass1, Handle loader1,
+                                    InstanceKlass* klass2, Handle loader2);
 
   // Note:  The main entry point for this module is via SystemDictionary.
   // SystemDictionary::check_signature_loaders(Symbol* signature,
   //                                           Handle loader1, Handle loader2,
   //                                           bool is_method, TRAPS)
 
-  Klass* find_constrained_klass(Symbol* name, Handle loader);
+  InstanceKlass* find_constrained_klass(Symbol* name, Handle loader);
 
   // Class loader constraints
 
   void ensure_loader_constraint_capacity(LoaderConstraintEntry *p, int nfree);
   void extend_loader_constraint(LoaderConstraintEntry* p, Handle loader,
-                                Klass* klass);
+                                InstanceKlass* klass);
   void merge_loader_constraints(LoaderConstraintEntry** pp1,
-                                LoaderConstraintEntry** pp2, Klass* klass);
-
-  bool check_or_update(instanceKlassHandle k, Handle loader,
-                              Symbol* name);
+                                LoaderConstraintEntry** pp2, InstanceKlass* klass);
 
+  bool check_or_update(InstanceKlass* k, Handle loader, Symbol* name);
 
   void purge_loader_constraints();
 
   void verify(Dictionary* dictionary, PlaceholderTable* placeholders);
 #ifndef PRODUCT
   void print();
 #endif
 };
 
-class LoaderConstraintEntry : public HashtableEntry<Klass*, mtClass> {
+class LoaderConstraintEntry : public HashtableEntry<InstanceKlass*, mtClass> {
   friend class VMStructs;
 private:
   Symbol*                _name;                   // class name
   int                    _num_loaders;
   int                    _max_loaders;

@@ -106,23 +104,23 @@
   // not class loaders.
   ClassLoaderData**              _loaders;                // initiating loaders
 
 public:
 
-  Klass* klass() { return literal(); }
-  Klass** klass_addr() { return literal_addr(); }
-  void set_klass(Klass* k) { set_literal(k); }
+  InstanceKlass* klass() { return literal(); }
+  InstanceKlass** klass_addr() { return literal_addr(); }
+  void set_klass(InstanceKlass* k) { set_literal(k); }
 
   LoaderConstraintEntry* next() {
-    return (LoaderConstraintEntry*)HashtableEntry<Klass*, mtClass>::next();
+    return (LoaderConstraintEntry*)HashtableEntry<InstanceKlass*, mtClass>::next();
   }
 
   LoaderConstraintEntry** next_addr() {
-    return (LoaderConstraintEntry**)HashtableEntry<Klass*, mtClass>::next_addr();
+    return (LoaderConstraintEntry**)HashtableEntry<InstanceKlass*, mtClass>::next_addr();
   }
   void set_next(LoaderConstraintEntry* next) {
-    HashtableEntry<Klass*, mtClass>::set_next(next);
+    HashtableEntry<InstanceKlass*, mtClass>::set_next(next);
   }
 
   Symbol* name() { return _name; }
   void set_name(Symbol* name) {
     _name = name;
< prev index next >