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

equal deleted inserted replaced

-:5f3b9b633731
+:7e268f863ff0
 assert(nm->contains(ic_call), "must be in compiled method");
 initialize_from_iter(iter);
 }
-bool CompiledIC::set_to_megamorphic(CallInfo* call_info, Bytecodes::Code bytecode, TRAPS) {
+// This function may fail for two reasons: either due to running out of vtable
+// stubs, or due to running out of IC stubs in an attempted transition to a
+// transitional state. The needs_ic_stub_refill value will be set if the failure
+// was due to running out of IC stubs, in which case the caller will refill IC
+// stubs and retry.
+bool CompiledIC::set_to_megamorphic(CallInfo* call_info, Bytecodes::Code bytecode,
+bool& needs_ic_stub_refill, TRAPS) {
 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;
 assert(k->verify_itable_index(itable_index), "sanity check");
 #endif //ASSERT
 CompiledICHolder* holder = new CompiledICHolder(call_info->resolved_method()->method_holder(),
 call_info->resolved_klass(), false);
 holder->claim();
-InlineCacheBuffer::create_transition_stub(this, holder, entry);
+if (!InlineCacheBuffer::create_transition_stub(this, holder, entry)) {
+delete holder;
+needs_ic_stub_refill = true;
+return false;
+}
 } else {
 assert(call_info->call_kind() == CallInfo::vtable_call, "either itable or vtable");
 // Can be different than selected_method->vtable_index(), due to package-private etc.
 int vtable_index = call_info->vtable_index();
 assert(call_info->resolved_klass()->verify_vtable_index(vtable_index), "sanity check");
 entry = VtableStubs::find_vtable_stub(vtable_index);
 if (entry == NULL) {
 return false;
 }
-InlineCacheBuffer::create_transition_stub(this, NULL, entry);
+if (!InlineCacheBuffer::create_transition_stub(this, NULL, entry)) {
+needs_ic_stub_refill = true;
+return false;
+}
 }
 if (TraceICs) {
 ResourceMark rm;
 assert(!call_info->selected_method().is_null(), "Unexpected null selected method");
 is_call_to_interpreted = _call->is_call_to_interpreted(dest);
 }
 return is_call_to_interpreted;
 }
-void CompiledIC::set_to_clean(bool in_use) {
+bool CompiledIC::set_to_clean(bool in_use) {
 assert(CompiledICLocker::is_safe(_method), "mt unsafe call");
 if (TraceInlineCacheClearing || TraceICs) {
 tty->print_cr("IC@" INTPTR_FORMAT ": set to clean", p2i(instruction_address()));
 print();
 }
 } else {
 set_ic_destination_and_value(entry, (void*)NULL);
 }
 } else {
 // Unsafe transition - create stub.
-InlineCacheBuffer::create_transition_stub(this, NULL, entry);
+if (!InlineCacheBuffer::create_transition_stub(this, NULL, entry)) {
+return false;
+}
 }
 // 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");
+return true;
 }
 bool CompiledIC::is_clean() const {
 assert(CompiledICLocker::is_safe(_method), "mt unsafe call");
 bool is_clean = false;
 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) {
+bool CompiledIC::set_to_monomorphic(CompiledICInfo& info) {
 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
 (info.to_aot() ? "aot" : "interpreter"),
 method->print_value_string());
 }
 } else {
 // Call via method-klass-holder
-InlineCacheBuffer::create_transition_stub(this, info.claim_cached_icholder(), info.entry());
+CompiledICHolder* holder = info.claim_cached_icholder();
+if (!InlineCacheBuffer::create_transition_stub(this, holder, info.entry())) {
+delete holder;
+return false;
+}
 if (TraceICs) {
 ResourceMark rm(thread);
 tty->print_cr ("IC@" INTPTR_FORMAT ": monomorphic to interpreter via icholder ", p2i(instruction_address()));
 }
 }
 // non-verified entry point
 bool safe = SafepointSynchronize::is_at_safepoint() ||
 (!is_in_transition_state() && (info.is_optimized() || static_bound || is_clean()));
 if (!safe) {
-InlineCacheBuffer::create_transition_stub(this, info.cached_metadata(), info.entry());
+if (!InlineCacheBuffer::create_transition_stub(this, info.cached_metadata(), info.entry())) {
+return false;
+}
 } else {
 if (is_optimized()) {
 set_ic_destination(info.entry());
 } else {
 set_ic_destination_and_value(info.entry(), info.cached_metadata());
 // 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_call_to_compiled() || is_call_to_interpreted(), "sanity check");
+return true;
 }
 // is_optimized: Compiler has generated an optimized call (i.e. fixed, no inline cache)
 // static_bound: The call can be static bound. If it isn't also optimized, the property
 }
 }
 // ----------------------------------------------------------------------------
-void CompiledStaticCall::set_to_clean(bool in_use) {
+bool CompiledStaticCall::set_to_clean(bool in_use) {
 // in_use is unused but needed to match template function in CompiledMethod
 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);
 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.
+return true;
 }
 bool CompiledStaticCall::is_clean() const {
 return destination() == resolve_call_stub();
 }

changeset 52857	7e268f863ff0
parent 52384	d6dc479bcdd3
child 52858	dad45affbdaa