void CompiledIC::set_to_clean() { assert(SafepointSynchronize::is_at_safepoint() || CompiledIC_lock->is_locked() , "MT-unsafe call"); if (TraceInlineCacheClearing || TraceICs) { tty->print_cr("IC@" INTPTR_FORMAT ": set to clean", instruction_address()); print(); } address entry; #ifdef COMPILER1 entry = is_optimized() ? Runtime1::entry_for(Runtime1::resolve_invoke_opt_virtual_id) : Runtime1::entry_for(Runtime1::resolve_invokevirtual_id); #else entry = is_optimized() ? OptoRuntime::resolve_opt_virtual_call_Java() : OptoRuntime::resolve_virtual_call_Java(); #endif // A zombie transition will always be safe, since the oop has already been set to NULL, so // we only need to patch the destination bool safe_transition = is_optimized() || SafepointSynchronize::is_at_safepoint(); if (safe_transition) { if (!is_optimized()) set_cached_oop(NULL); // Kill any leftover stub we might have too if (is_in_transition_state()) { ICStub* old_stub = ICStub_from_destination_address(stub_address()); old_stub->clear(); } set_ic_destination(entry); } else { // Unsafe transition - create stub. InlineCacheBuffer::create_transition_stub(this, NULL, entry); } // We can't check this anymore. With lazy deopt we could have already // cleaned this IC entry before we even return. This is possible if // we ran out of space in the inline cache buffer trying to do the // set_next and we safepointed to free up space. This is a benign // race because the IC entry was complete when we safepointed so // cleaning it immediately is harmless. // assert(is_clean(), "sanity check"); }
// Clears the IC stub if the compiled IC is in transition state void CompiledIC::clear_ic_stub() { if (is_in_transition_state()) { ICStub* stub = ICStub_from_destination_address(stub_address()); stub->clear(); } }