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

equal deleted inserted replaced

-:4de5ca97feee
+:29b94ed63a09
 if (mdo == NULL)  return;
 // There is a benign race here.  See comments in methodData.hpp.
 mdo->inc_decompile_count();
 }
-void nmethod::make_unloaded(BoolObjectClosure* is_alive, oop cause) {
+void nmethod::make_unloaded(oop cause) {
 post_compiled_method_unload();
-// Since this nmethod is being unloaded, make sure that dependencies
+// This nmethod is being unloaded, make sure that dependencies
-// recorded in instanceKlasses get flushed and pass non-NULL closure to
+// recorded in instanceKlasses get flushed.
-// indicate that this work is being done during a GC.
+// Since this work is being done during a GC, defer deleting dependencies from the
+// InstanceKlass.
 assert(Universe::heap()->is_gc_active(), "should only be called during gc");
-assert(is_alive != NULL, "Should be non-NULL");
+flush_dependencies(/*delete_immediately*/false);
-// A non-NULL is_alive closure indicates that this is being called during GC.
-flush_dependencies(is_alive);
 // Break cycle between nmethod & method
 LogTarget(Trace, class, unload) lt;
 if (lt.is_enabled()) {
 LogStream ls(lt);
 // dependency logic could have become stale.
 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
 if (nmethod_needs_unregister) {
 Universe::heap()->unregister_nmethod(this);
 }
-flush_dependencies(NULL);
+flush_dependencies(/*delete_immediately*/true);
 }
 // zombie only - if a JVMTI agent has enabled the CompiledMethodUnload
 // event and it hasn't already been reported for this nmethod then
 // report it now. The event may have been reported earlier if the GC
 // During phase 1 of mark sweep class unloading may happen and as a
 // result some nmethods may get unloaded.  In this case the flushing
 // of dependencies must happen during phase 1 since after GC any
 // dependencies in the unloaded nmethod won't be updated, so
 // traversing the dependency information in unsafe.  In that case this
-// function is called with a non-NULL argument and this function only
+// function is called with a boolean argument and this function only
 // notifies instanceKlasses that are reachable
-void nmethod::flush_dependencies(BoolObjectClosure* is_alive) {
+void nmethod::flush_dependencies(bool delete_immediately) {
 assert_locked_or_safepoint(CodeCache_lock);
-assert(Universe::heap()->is_gc_active() == (is_alive != NULL),
+assert(Universe::heap()->is_gc_active() != delete_immediately,
-"is_alive is non-NULL if and only if we are called during GC");
+"delete_immediately is false if and only if we are called during GC");
 if (!has_flushed_dependencies()) {
 set_has_flushed_dependencies();
 for (Dependencies::DepStream deps(this); deps.next(); ) {
 if (deps.type() == Dependencies::call_site_target_value) {
 // CallSite dependencies are managed on per-CallSite instance basis.
 } else {
 Klass* klass = deps.context_type();
 if (klass == NULL) {
 continue;  // ignore things like evol_method
 }
-// During GC the is_alive closure is non-NULL, and is used to
+// During GC delete_immediately is false, and liveness
-// determine liveness of dependees that need to be updated.
+// of dependee determines class that needs to be updated.
-if (is_alive == NULL || klass->is_loader_alive()) {
+if (delete_immediately || klass->is_loader_alive()) {
 // The GC defers deletion of this entry, since there might be multiple threads
 // iterating over the _dependencies graph. Other call paths are single-threaded
 // and may delete it immediately.
-bool delete_immediately = is_alive == NULL;
 InstanceKlass::cast(klass)->remove_dependent_nmethod(this, delete_immediately);
 }
 }
 }
 }
 // If ScavengeRootsInCode is true, an nmethod might be unloaded
 // simply because one of its constant oops has gone dead.
 // No actual classes need to be unloaded in order for this to occur.
 assert(unloading_occurred || ScavengeRootsInCode, "Inconsistency in unloading");
-make_unloaded(is_alive, obj);
+make_unloaded(obj);
 return true;
 }
 // ------------------------------------------------------------------
 // post_compiled_method_load_event
 return do_unloading_scopes(is_alive, unloading_occurred);
 }
 #if INCLUDE_JVMCI
-bool nmethod::do_unloading_jvmci(BoolObjectClosure* is_alive, bool unloading_occurred) {
+bool nmethod::do_unloading_jvmci(bool unloading_occurred) {
 if (_jvmci_installed_code != NULL) {
 if (JNIHandles::is_global_weak_cleared(_jvmci_installed_code)) {
 if (_jvmci_installed_code_triggers_unloading) {
 // jweak reference processing has already cleared the referent
-make_unloaded(is_alive, NULL);
+make_unloaded(NULL);
 return true;
 } else {
 clear_jvmci_installed_code();
 }
 }

changeset 49890	29b94ed63a09
parent 49860	ca5216a2a2cc
child 49902	3661f31c6df4