jdk-sandbox: comparison src/hotspot/share/code/compiledMethod.cpp

equal deleted inserted replaced

-:663f5d90f0e8
+:02c08e20d66c
 new_entry->set_next(ec);
 }
 release_set_exception_cache(new_entry);
 }
-void CompiledMethod::clean_exception_cache(BoolObjectClosure* is_alive) {
+void CompiledMethod::clean_exception_cache() {
 ExceptionCache* prev = NULL;
 ExceptionCache* curr = exception_cache();
 while (curr != NULL) {
 ExceptionCache* next = curr->next();
 Klass* ex_klass = curr->exception_type();
-if (ex_klass != NULL && !ex_klass->is_loader_alive(is_alive)) {
+if (ex_klass != NULL && !ex_klass->is_loader_alive()) {
 if (prev == NULL) {
 set_exception_cache(next);
 } else {
 prev->set_next(next);
 }
 }
 }
 }
 #ifdef ASSERT
+// Check class_loader is alive for this bit of metadata.
-class CheckClass : AllStatic {
+static void check_class(Metadata* md) {
-static BoolObjectClosure* _is_alive;
+Klass* klass = NULL;
+if (md->is_klass()) {
-// Check class_loader is alive for this bit of metadata.
+klass = ((Klass*)md);
-static void check_class(Metadata* md) {
+} else if (md->is_method()) {
-Klass* klass = NULL;
+klass = ((Method*)md)->method_holder();
-if (md->is_klass()) {
+} else if (md->is_methodData()) {
-klass = ((Klass*)md);
+klass = ((MethodData*)md)->method()->method_holder();
-} else if (md->is_method()) {
+} else {
-klass = ((Method*)md)->method_holder();
+md->print();
-} else if (md->is_methodData()) {
+ShouldNotReachHere();
-klass = ((MethodData*)md)->method()->method_holder();
+}
-} else {
+assert(klass->is_loader_alive(), "must be alive");
-md->print();
+}
-ShouldNotReachHere();
-}
-assert(klass->is_loader_alive(_is_alive), "must be alive");
-}
-public:
-static void do_check_class(BoolObjectClosure* is_alive, CompiledMethod* nm) {
-assert(SafepointSynchronize::is_at_safepoint(), "this is only ok at safepoint");
-_is_alive = is_alive;
-nm->metadata_do(check_class);
-}
-};
-// This is called during a safepoint so can use static data
-BoolObjectClosure* CheckClass::_is_alive = NULL;
 #endif // ASSERT
-void CompiledMethod::clean_ic_if_metadata_is_dead(CompiledIC *ic, BoolObjectClosure *is_alive) {
+void CompiledMethod::clean_ic_if_metadata_is_dead(CompiledIC *ic) {
 if (ic->is_icholder_call()) {
 // The only exception is compiledICHolder oops which may
 // yet be marked below. (We check this further below).
 CompiledICHolder* cichk_oop = ic->cached_icholder();
-if (cichk_oop->is_loader_alive(is_alive)) {
+if (cichk_oop->is_loader_alive()) {
 return;
 }
 } else {
 Metadata* ic_oop = ic->cached_metadata();
 if (ic_oop != NULL) {
 if (ic_oop->is_klass()) {
-if (((Klass*)ic_oop)->is_loader_alive(is_alive)) {
+if (((Klass*)ic_oop)->is_loader_alive()) {
 return;
 }
 } else if (ic_oop->is_method()) {
-if (((Method*)ic_oop)->method_holder()->is_loader_alive(is_alive)) {
+if (((Method*)ic_oop)->method_holder()->is_loader_alive()) {
 return;
 }
 } else {
 ShouldNotReachHere();
 }
 // Processing of oop references should have been sufficient to keep
 // all strong references alive.  Any weak references should have been
 // cleared as well.  Visit all the metadata and ensure that it's
 // really alive.
-void CompiledMethod::verify_metadata_loaders(address low_boundary, BoolObjectClosure* is_alive) {
+void CompiledMethod::verify_metadata_loaders(address low_boundary) {
 #ifdef ASSERT
 RelocIterator iter(this, low_boundary);
 while (iter.next()) {
 // static_stub_Relocations may have dangling references to
 // Method*s so trim them out here.  Otherwise it looks like
 }
 }
 }
 }
 // Check that the metadata embedded in the nmethod is alive
-CheckClass::do_check_class(is_alive, this);
+metadata_do(check_class);
 #endif
 }
 // This is called at the end of the strong tracing/marking phase of a
 // GC to unload an nmethod if it contains otherwise unreachable
 // of this nmethod is reported.
 unloading_occurred = true;
 }
 // Exception cache
-clean_exception_cache(is_alive);
+clean_exception_cache();
 // If class unloading occurred we first iterate over all inline caches and
 // clear ICs where the cached oop is referring to an unloaded klass or method.
 // The remaining live cached oops will be traversed in the relocInfo::oop_type
 // iteration below.
 if (unloading_occurred) {
 RelocIterator iter(this, low_boundary);
 while(iter.next()) {
 if (iter.type() == relocInfo::virtual_call_type) {
 CompiledIC *ic = CompiledIC_at(&iter);
-clean_ic_if_metadata_is_dead(ic, is_alive);
+clean_ic_if_metadata_is_dead(ic);
 }
 }
 }
 if (do_unloading_oops(low_boundary, is_alive, unloading_occurred)) {
 return;
 }
 #endif
 // Ensure that all metadata is still alive
-verify_metadata_loaders(low_boundary, is_alive);
+verify_metadata_loaders(low_boundary);
 }
 template <class CompiledICorStaticCall>
 static bool clean_if_nmethod_is_unloaded(CompiledICorStaticCall *ic, address addr, BoolObjectClosure *is_alive, CompiledMethod* from) {
 // Ok, to lookup references to zombies here
 // of this nmethod is reported.
 unloading_occurred = true;
 }
 // Exception cache
-clean_exception_cache(is_alive);
+clean_exception_cache();
 bool postponed = false;
 RelocIterator iter(this, low_boundary);
 while(iter.next()) {
 case relocInfo::virtual_call_type:
 if (unloading_occurred) {
 // If class unloading occurred we first iterate over all inline caches and
 // clear ICs where the cached oop is referring to an unloaded klass or method.
-clean_ic_if_metadata_is_dead(CompiledIC_at(&iter), is_alive);
+clean_ic_if_metadata_is_dead(CompiledIC_at(&iter));
 }
 postponed |= clean_if_nmethod_is_unloaded(CompiledIC_at(&iter), is_alive, this);
 break;
 return postponed;
 }
 #endif
 // Ensure that all metadata is still alive
-verify_metadata_loaders(low_boundary, is_alive);
+verify_metadata_loaders(low_boundary);
 return postponed;
 }
 void CompiledMethod::do_unloading_parallel_postponed(BoolObjectClosure* is_alive, bool unloading_occurred) {

changeset 49821	02c08e20d66c
parent 49480	d7df2dd501ce
child 49890	29b94ed63a09