< prev index next >

src/share/vm/classfile/systemDictionary.hpp

Print this page

        

@@ -76,10 +76,12 @@
 class PlaceholderTable;
 class LoaderConstraintTable;
 template <MEMFLAGS F> class HashtableBucket;
 class ResolutionErrorTable;
 class SymbolPropertyTable;
+class ProtectionDomainCacheTable;
+class ProtectionDomainCacheEntry;
 class GCTimer;
 
 // Certain classes are preloaded, such as java.lang.Object and java.lang.String.
 // They are all "well-known", in the sense that no class loader is allowed
 // to provide a different definition.

@@ -346,18 +348,10 @@
   // to local linkage and access checks.
   static Klass* find_constrained_instance_or_array_klass(Symbol* class_name,
                                                            Handle class_loader,
                                                            TRAPS);
 
-  // Iterate over all klasses in dictionary
-  // Just the classes from defining class loaders
-  static void classes_do(void f(Klass*));
-  // Added for initialize_itable_for_klass to handle exceptions
-  static void classes_do(void f(Klass*, TRAPS), TRAPS);
-  // All classes, and their class loaders, including initiating class loaders
-  static void classes_do(void f(Klass*, ClassLoaderData*));
-
   // Iterate over all methods in all klasses
   static void methods_do(void f(Method*));
 
   // Garbage collection support
 

@@ -392,15 +386,10 @@
                                     int number_of_entries);
   // Printing
   static void print(bool details = true);
   static void print_shared(bool details = true);
 
-  // Number of contained klasses
-  // This is both fully loaded classes and classes in the process
-  // of being loaded
-  static int number_of_classes();
-
   // Monotonically increasing counter which grows as classes are
   // loaded or modifications such as hot-swapping or setting/removing
   // of breakpoints are performed
   static inline int number_of_modifications()     { assert_locked_or_safepoint(Compile_lock); return _number_of_modifications; }
   // Needed by evolution and breakpoint code

@@ -556,10 +545,13 @@
                                    Symbol* message);
   static void delete_resolution_error(ConstantPool* pool);
   static Symbol* find_resolution_error(const constantPoolHandle& pool, int which,
                                        Symbol** message);
 
+
+  static ProtectionDomainCacheEntry* cache_get(Handle protection_domain);
+
  protected:
 
   enum Constants {
     _loader_constraint_size = 107,                     // number of entries in constraint table
     _resolution_error_size  = 107,                     // number of entries in resolution error table

@@ -569,28 +561,20 @@
     _prime_array_size       = 8,                       // array of primes for system dictionary size
     _average_depth_goal     = 3                        // goal for lookup length
   };
 
 
-  // Static variables
-
-  // hashtable sizes for system dictionary to allow growth
-  // prime numbers for system dictionary size
-  static int                     _sdgeneration;
-  static const int               _primelist[_prime_array_size];
-
-  // Hashtable holding loaded classes.
-  static Dictionary*            _dictionary;
+  // Static tables owned by the SystemDictionary
 
   // Hashtable holding placeholders for classes being loaded.
   static PlaceholderTable*       _placeholders;
 
   // Hashtable holding classes from the shared archive.
   static Dictionary*             _shared_dictionary;
 
   // Monotonically increasing counter which grows with
-  // _number_of_classes as well as hot-swapping and breakpoint setting
+  // loading classes as well as hot-swapping and breakpoint setting
   // and removal.
   static int                     _number_of_modifications;
 
   // Lock object for system class loader
   static oop                     _system_loader_lock_obj;

@@ -602,23 +586,20 @@
   static ResolutionErrorTable*   _resolution_errors;
 
   // Invoke methods (JSR 292)
   static SymbolPropertyTable*    _invoke_method_table;
 
-public:
-  // for VM_CounterDecay iteration support
-  friend class CounterDecay;
-  static Klass* try_get_next_class();
+  // ProtectionDomain cache
+  static ProtectionDomainCacheTable*   _pd_cache_table;
 
 protected:
   static void validate_protection_domain(InstanceKlass* klass,
                                          Handle class_loader,
                                          Handle protection_domain, TRAPS);
 
   friend class VM_PopulateDumpSharedSpace;
   friend class TraversePlaceholdersClosure;
-  static Dictionary*         dictionary() { return _dictionary; }
   static Dictionary*         shared_dictionary() { return _shared_dictionary; }
   static PlaceholderTable*   placeholders() { return _placeholders; }
   static LoaderConstraintTable* constraints() { return _loader_constraints; }
   static ResolutionErrorTable* resolution_errors() { return _resolution_errors; }
   static SymbolPropertyTable* invoke_method_table() { return _invoke_method_table; }

@@ -664,11 +645,11 @@
   // We pass in the hashtable index so we can calculate it outside of
   // the SystemDictionary_lock.
 
   // Basic find on loaded classes
   static InstanceKlass* find_class(int index, unsigned int hash,
-                                   Symbol* name, ClassLoaderData* loader_data);
+                                   Symbol* name, Dictionary* dictionary);
   static InstanceKlass* find_class(Symbol* class_name, ClassLoaderData* loader_data);
 
   // Basic find on classes in the midst of being loaded
   static Symbol* find_placeholder(Symbol* name, ClassLoaderData* loader_data);
 
< prev index next >