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

equal deleted inserted replaced

-:71564a544d4c
+:d6dc479bcdd3
 *
 */
 #include "precompiled.hpp"
 #include "classfile/systemDictionary.hpp"
+#include "code/codeBehaviours.hpp"
 #include "code/codeCache.hpp"
 #include "code/compiledIC.hpp"
 #include "code/icBuffer.hpp"
 #include "code/nmethod.hpp"
 #include "code/vtableStubs.hpp"
 // Every time a compiled IC is changed or its type is being accessed,
 // either the CompiledIC_lock must be set or we must be at a safe point.
+CompiledICLocker::CompiledICLocker(CompiledMethod* method)
+: _method(method),
+_behaviour(CompiledICProtectionBehaviour::current()),
+_locked(_behaviour->lock(_method)){
+}
+CompiledICLocker::~CompiledICLocker() {
+if (_locked) {
+_behaviour->unlock(_method);
+}
+}
+bool CompiledICLocker::is_safe(CompiledMethod* method) {
+return CompiledICProtectionBehaviour::current()->is_safe(method);
+}
+bool CompiledICLocker::is_safe(address code) {
+CodeBlob* cb = CodeCache::find_blob_unsafe(code);
+assert(cb != NULL && cb->is_compiled(), "must be compiled");
+CompiledMethod* cm = cb->as_compiled_method();
+return CompiledICProtectionBehaviour::current()->is_safe(cm);
+}
 //-----------------------------------------------------------------------------
 // Low-level access to an inline cache. Private, since they might not be
 // MT-safe to use.
 void* CompiledIC::cached_value() const {
-assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "");
+assert(CompiledICLocker::is_safe(_method), "mt unsafe call");
 assert (!is_optimized(), "an optimized virtual call does not have a cached metadata");
 if (!is_in_transition_state()) {
 void* data = get_data();
 // If we let the metadata value here be initialized to zero...
 }
 void CompiledIC::internal_set_ic_destination(address entry_point, bool is_icstub, void* cache, bool is_icholder) {
 assert(entry_point != NULL, "must set legal entry point");
-assert(CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "");
+assert(CompiledICLocker::is_safe(_method), "mt unsafe call");
 assert (!is_optimized() || cache == NULL, "an optimized virtual call does not have a cached metadata");
 assert (cache == NULL || cache != (Metadata*)badOopVal, "invalid metadata");
 assert(!is_icholder || is_icholder_entry(entry_point), "must be");
 }
 tty->cr();
 }
 {
-MutexLockerEx pl(SafepointSynchronize::is_at_safepoint() ? NULL : Patching_lock, Mutex::_no_safepoint_check_flag);
-#ifdef ASSERT
 CodeBlob* cb = CodeCache::find_blob_unsafe(_call->instruction_address());
+MutexLockerEx pl(CompiledICLocker::is_safe(cb->as_compiled_method()) ? NULL : Patching_lock, Mutex::_no_safepoint_check_flag);
 assert(cb != NULL && cb->is_compiled(), "must be compiled");
-#endif
 _call->set_destination_mt_safe(entry_point);
 }
 if (is_optimized() || is_icstub) {
 // Optimized call sites don't have a cache value and ICStub call
 }
 address CompiledIC::ic_destination() const {
-assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "");
+assert(CompiledICLocker::is_safe(_method), "mt unsafe call");
 if (!is_in_transition_state()) {
 return _call->destination();
 } else {
 return InlineCacheBuffer::ic_destination_for((CompiledIC *)this);
 }
 }
 bool CompiledIC::is_in_transition_state() const {
-assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "");
+assert(CompiledICLocker::is_safe(_method), "mt unsafe call");
 return InlineCacheBuffer::contains(_call->destination());;
 }
 bool CompiledIC::is_icholder_call() const {
-assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "");
+assert(CompiledICLocker::is_safe(_method), "mt unsafe call");
 return !_is_optimized && is_icholder_entry(ic_destination());
 }
 // Returns native address of 'call' instruction in inline-cache. Used by
 // the InlineCacheBuffer when it needs to find the stub.
 initialize_from_iter(iter);
 }
 bool CompiledIC::set_to_megamorphic(CallInfo* call_info, Bytecodes::Code bytecode, TRAPS) {
-assert(CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "");
+assert(CompiledICLocker::is_safe(_method), "mt unsafe call");
 assert(!is_optimized(), "cannot set an optimized virtual call to megamorphic");
 assert(is_call_to_compiled() || is_call_to_interpreted(), "going directly to megamorphic?");
 address entry;
 if (call_info->call_kind() == CallInfo::itable_call) {
 }
 // true if destination is megamorphic stub
 bool CompiledIC::is_megamorphic() const {
-assert(CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "");
+assert(CompiledICLocker::is_safe(_method), "mt unsafe call");
 assert(!is_optimized(), "an optimized call cannot be megamorphic");
 // Cannot rely on cached_value. It is either an interface or a method.
 return VtableStubs::entry_point(ic_destination()) != NULL;
 }
 bool CompiledIC::is_call_to_compiled() const {
-assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "");
+assert(CompiledICLocker::is_safe(_method), "mt unsafe call");
 // Use unsafe, since an inline cache might point to a zombie method. However, the zombie
 // method is guaranteed to still exist, since we only remove methods after all inline caches
 // has been cleaned up
 CodeBlob* cb = CodeCache::find_blob_unsafe(ic_destination());
 return is_monomorphic;
 }
 bool CompiledIC::is_call_to_interpreted() const {
-assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "");
+assert(CompiledICLocker::is_safe(_method), "mt unsafe call");
 // Call to interpreter if destination is either calling to a stub (if it
 // is optimized), or calling to an I2C blob
 bool is_call_to_interpreted = false;
 if (!is_optimized()) {
 // must use unsafe because the destination can be a zombie (and we're cleaning)
 }
 return is_call_to_interpreted;
 }
 void CompiledIC::set_to_clean(bool in_use) {
-assert(SafepointSynchronize::is_at_safepoint() || CompiledIC_lock->is_locked() , "MT-unsafe call");
+assert(CompiledICLocker::is_safe(_method), "mt unsafe call");
 if (TraceInlineCacheClearing || TraceICs) {
 tty->print_cr("IC@" INTPTR_FORMAT ": set to clean", p2i(instruction_address()));
 print();
 }
 address entry = _call->get_resolve_call_stub(is_optimized());
 // A zombie transition will always be safe, since the metadata has already been set to NULL, so
 // we only need to patch the destination
-bool safe_transition = _call->is_safe_for_patching() || !in_use || is_optimized() || SafepointSynchronize::is_at_safepoint();
+bool safe_transition = _call->is_safe_for_patching() || !in_use || is_optimized() || CompiledICLocker::is_safe(_method);
 if (safe_transition) {
 // Kill any leftover stub we might have too
 clear_ic_stub();
 if (is_optimized()) {
 // cleaning it immediately is harmless.
 // assert(is_clean(), "sanity check");
 }
 bool CompiledIC::is_clean() const {
-assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "");
+assert(CompiledICLocker::is_safe(_method), "mt unsafe call");
 bool is_clean = false;
 address dest = ic_destination();
 is_clean = dest == _call->get_resolve_call_stub(is_optimized());
 assert(!is_clean || is_optimized() || cached_value() == NULL, "sanity check");
 return is_clean;
 }
 void CompiledIC::set_to_monomorphic(CompiledICInfo& info) {
-assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "");
+assert(CompiledICLocker::is_safe(_method), "mt unsafe call");
 // Updating a cache to the wrong entry can cause bugs that are very hard
 // to track down - if cache entry gets invalid - we just clean it. In
 // this way it is always the same code path that is responsible for
 // updating and resolving an inline cache
 //
 // ----------------------------------------------------------------------------
 void CompiledStaticCall::set_to_clean(bool in_use) {
 // in_use is unused but needed to match template function in CompiledMethod
-assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "mt unsafe call");
+assert(CompiledICLocker::is_safe(instruction_address()), "mt unsafe call");
 // Reset call site
 MutexLockerEx pl(SafepointSynchronize::is_at_safepoint() ? NULL : Patching_lock, Mutex::_no_safepoint_check_flag);
-#ifdef ASSERT
-CodeBlob* cb = CodeCache::find_blob_unsafe(instruction_address());
-assert(cb != NULL && cb->is_compiled(), "must be compiled");
-#endif
 set_destination_mt_safe(resolve_call_stub());
 // Do not reset stub here:  It is too expensive to call find_stub.
 // Instead, rely on caller (nmethod::clear_inline_caches) to clear
 // both the call and its stub.
 assert(CodeCache::contains(entry), "wrong entry point");
 set_destination_mt_safe(entry);
 }
 void CompiledStaticCall::set(const StaticCallInfo& info) {
-assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "mt unsafe call");
+assert(CompiledICLocker::is_safe(instruction_address()), "mt unsafe call");
 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
 // Updating a cache to the wrong entry can cause bugs that are very hard
 // to track down - if cache entry gets invalid - we just clean it. In
 // this way it is always the same code path that is responsible for
 // updating and resolving an inline cache

changeset 52384	d6dc479bcdd3
parent 51314	82adcc8ad853
child 52857	7e268f863ff0