83 84 Klass* find_class(int index, unsigned int hash, 85 Symbol* name, ClassLoaderData* loader_data); 86 87 Klass* find_shared_class(int index, unsigned int hash, Symbol* name); 88 89 // Compiler support 90 Klass* try_get_next_class(); 91 92 // GC support 93 void oops_do(OopClosure* f); 94 void always_strong_oops_do(OopClosure* blk); 95 void roots_oops_do(OopClosure* strong, OopClosure* weak); 96 97 void always_strong_classes_do(KlassClosure* closure); 98 99 void classes_do(void f(Klass*)); 100 void classes_do(void f(Klass*, TRAPS), TRAPS); 101 void classes_do(void f(Klass*, ClassLoaderData*)); 102 103 void methods_do(void f(Method*)); 104 105 void unlink(BoolObjectClosure* is_alive); 106 void remove_classes_in_error_state(); 107 108 // Classes loaded by the bootstrap loader are always strongly reachable. 109 // If we're not doing class unloading, all classes are strongly reachable. 110 static bool is_strongly_reachable(ClassLoaderData* loader_data, Klass* klass) { 111 assert (klass != NULL, "should have non-null klass"); 112 return (loader_data->is_the_null_class_loader_data() || !ClassUnloading); 113 } 114 115 // Unload (that is, break root links to) all unmarked classes and loaders. 116 void do_unloading(); 117 118 // Protection domains 119 Klass* find(int index, unsigned int hash, Symbol* name, 120 ClassLoaderData* loader_data, Handle protection_domain, TRAPS); 121 bool is_valid_protection_domain(int index, unsigned int hash, 122 Symbol* name, ClassLoaderData* loader_data, 123 Handle protection_domain); 124 void add_protection_domain(int index, unsigned int hash, | 83 84 Klass* find_class(int index, unsigned int hash, 85 Symbol* name, ClassLoaderData* loader_data); 86 87 Klass* find_shared_class(int index, unsigned int hash, Symbol* name); 88 89 // Compiler support 90 Klass* try_get_next_class(); 91 92 // GC support 93 void oops_do(OopClosure* f); 94 void always_strong_oops_do(OopClosure* blk); 95 void roots_oops_do(OopClosure* strong, OopClosure* weak); 96 97 void always_strong_classes_do(KlassClosure* closure); 98 99 void classes_do(void f(Klass*)); 100 void classes_do(void f(Klass*, TRAPS), TRAPS); 101 void classes_do(void f(Klass*, ClassLoaderData*)); 102 103 void unlink(BoolObjectClosure* is_alive); 104 void remove_classes_in_error_state(); 105 106 // Classes loaded by the bootstrap loader are always strongly reachable. 107 // If we're not doing class unloading, all classes are strongly reachable. 108 static bool is_strongly_reachable(ClassLoaderData* loader_data, Klass* klass) { 109 assert (klass != NULL, "should have non-null klass"); 110 return (loader_data->is_the_null_class_loader_data() || !ClassUnloading); 111 } 112 113 // Unload (that is, break root links to) all unmarked classes and loaders. 114 void do_unloading(); 115 116 // Protection domains 117 Klass* find(int index, unsigned int hash, Symbol* name, 118 ClassLoaderData* loader_data, Handle protection_domain, TRAPS); 119 bool is_valid_protection_domain(int index, unsigned int hash, 120 Symbol* name, ClassLoaderData* loader_data, 121 Handle protection_domain); 122 void add_protection_domain(int index, unsigned int hash, |