jdk-sandbox: comparison hotspot/src/share/vm/runtime/sharedRuntime.cpp

equal deleted inserted replaced

-:ba888a4f352a
+:78b95467b9f1
 address stub;
 // Look up the code blob
 CodeBlob *cb = CodeCache::find_blob(pc);
 // Should be an nmethod
-assert(cb && cb->is_nmethod(), "safepoint polling: pc must refer to an nmethod");
+assert(cb && cb->is_compiled(), "safepoint polling: pc must refer to an nmethod");
 // Look up the relocation information
-assert(((nmethod*)cb)->is_at_poll_or_poll_return(pc),
+assert(((CompiledMethod*)cb)->is_at_poll_or_poll_return(pc),
 "safepoint polling: type must be poll");
 #ifdef ASSERT
 if (!((NativeInstruction*)pc)->is_safepoint_poll()) {
 tty->print_cr("bad pc: " PTR_FORMAT, p2i(pc));
 Disassembler::decode(cb);
 fatal("Only polling locations are used for safepoint");
 }
 #endif
-bool at_poll_return = ((nmethod*)cb)->is_at_poll_return(pc);
+bool at_poll_return = ((CompiledMethod*)cb)->is_at_poll_return(pc);
-bool has_wide_vectors = ((nmethod*)cb)->has_wide_vectors();
+bool has_wide_vectors = ((CompiledMethod*)cb)->has_wide_vectors();
 if (at_poll_return) {
 assert(SharedRuntime::polling_page_return_handler_blob() != NULL,
 "polling page return stub not created yet");
 stub = SharedRuntime::polling_page_return_handler_blob()->entry_point();
 } else if (has_wide_vectors) {
 return 0;
 JRT_END
 // ret_pc points into caller; we are returning caller's exception handler
 // for given exception
-address SharedRuntime::compute_compiled_exc_handler(nmethod* nm, address ret_pc, Handle& exception,
+address SharedRuntime::compute_compiled_exc_handler(CompiledMethod* cm, address ret_pc, Handle& exception,
 bool force_unwind, bool top_frame_only) {
-assert(nm != NULL, "must exist");
+assert(cm != NULL, "must exist");
 ResourceMark rm;
 #if INCLUDE_JVMCI
-if (nm->is_compiled_by_jvmci()) {
+if (cm->is_compiled_by_jvmci()) {
 // lookup exception handler for this pc
-int catch_pco = ret_pc - nm->code_begin();
+int catch_pco = ret_pc - cm->code_begin();
-ExceptionHandlerTable table(nm);
+ExceptionHandlerTable table(cm);
 HandlerTableEntry *t = table.entry_for(catch_pco, -1, 0);
 if (t != NULL) {
-return nm->code_begin() + t->pco();
+return cm->code_begin() + t->pco();
 } else {
 // there is no exception handler for this pc => deoptimize
-nm->make_not_entrant();
+cm->make_not_entrant();
 // Use Deoptimization::deoptimize for all of its side-effects:
 // revoking biases of monitors, gathering traps statistics, logging...
 // it also patches the return pc but we do not care about that
 // since we return a continuation to the deopt_blob below.
 return SharedRuntime::deopt_blob()->unpack_with_exception_in_tls();
 }
 }
 #endif // INCLUDE_JVMCI
+nmethod* nm = cm->as_nmethod();
 ScopeDesc* sd = nm->scope_desc_at(ret_pc);
 // determine handler bci, if any
 EXCEPTION_MARK;
 int handler_bci = -1;
 Atomic::inc(&Exceptions::_stack_overflow_errors);
 throw_and_post_jvmti_exception(thread, exception);
 }
 #if INCLUDE_JVMCI
-address SharedRuntime::deoptimize_for_implicit_exception(JavaThread* thread, address pc, nmethod* nm, int deopt_reason) {
+address SharedRuntime::deoptimize_for_implicit_exception(JavaThread* thread, address pc, CompiledMethod* nm, int deopt_reason) {
 assert(deopt_reason > Deoptimization::Reason_none && deopt_reason < Deoptimization::Reason_LIMIT, "invalid deopt reason");
 thread->set_jvmci_implicit_exception_pc(pc);
 thread->set_pending_deoptimization(Deoptimization::make_trap_request((Deoptimization::DeoptReason)deopt_reason, Deoptimization::Action_reinterpret));
 return (SharedRuntime::deopt_blob()->implicit_exception_uncommon_trap());
 }
 // Exception happened in CodeCache. Must be either:
 // 1. Inline-cache check in C2I handler blob,
 // 2. Inline-cache check in nmethod, or
 // 3. Implicit null exception in nmethod
-if (!cb->is_nmethod()) {
+if (!cb->is_compiled()) {
 bool is_in_blob = cb->is_adapter_blob() || cb->is_method_handles_adapter_blob();
 if (!is_in_blob) {
 // Allow normal crash reporting to handle this
 return NULL;
 }
 Events::log_exception(thread, "NullPointerException in code blob at " INTPTR_FORMAT, p2i(pc));
 // There is no handler here, so we will simply unwind.
 return StubRoutines::throw_NullPointerException_at_call_entry();
 }
-// Otherwise, it's an nmethod.  Consult its exception handlers.
+// Otherwise, it's a compiled method.  Consult its exception handlers.
-nmethod* nm = (nmethod*)cb;
+CompiledMethod* cm = (CompiledMethod*)cb;
-if (nm->inlinecache_check_contains(pc)) {
+if (cm->inlinecache_check_contains(pc)) {
 // exception happened inside inline-cache check code
 // => the nmethod is not yet active (i.e., the frame
 // is not set up yet) => use return address pushed by
 // caller => don't push another return address
 Events::log_exception(thread, "NullPointerException in IC check " INTPTR_FORMAT, p2i(pc));
 return StubRoutines::throw_NullPointerException_at_call_entry();
 }
-if (nm->method()->is_method_handle_intrinsic()) {
+if (cm->method()->is_method_handle_intrinsic()) {
 // exception happened inside MH dispatch code, similar to a vtable stub
 Events::log_exception(thread, "NullPointerException in MH adapter " INTPTR_FORMAT, p2i(pc));
 return StubRoutines::throw_NullPointerException_at_call_entry();
 }
 #ifndef PRODUCT
 _implicit_null_throws++;
 #endif
 #if INCLUDE_JVMCI
-if (nm->is_compiled_by_jvmci() && nm->pc_desc_at(pc) != NULL) {
+if (cm->is_compiled_by_jvmci() && cm->pc_desc_at(pc) != NULL) {
 // If there's no PcDesc then we'll die way down inside of
 // deopt instead of just getting normal error reporting,
 // so only go there if it will succeed.
-return deoptimize_for_implicit_exception(thread, pc, nm, Deoptimization::Reason_null_check);
+return deoptimize_for_implicit_exception(thread, pc, cm, Deoptimization::Reason_null_check);
 } else {
 #endif // INCLUDE_JVMCI
-assert (nm->is_nmethod(), "Expect nmethod");
+assert (cm->is_nmethod(), "Expect nmethod");
-target_pc = nm->continuation_for_implicit_exception(pc);
+target_pc = ((nmethod*)cm)->continuation_for_implicit_exception(pc);
 #if INCLUDE_JVMCI
 }
 #endif // INCLUDE_JVMCI
 // If there's an unexpected fault, target_pc might be NULL,
 // in which case we want to fall through into the normal
 break; // fall through
 }
 case IMPLICIT_DIVIDE_BY_ZERO: {
-nmethod* nm = CodeCache::find_nmethod(pc);
+CompiledMethod* cm = CodeCache::find_compiled(pc);
-guarantee(nm != NULL, "must have containing compiled method for implicit division-by-zero exceptions");
+guarantee(cm != NULL, "must have containing compiled method for implicit division-by-zero exceptions");
 #ifndef PRODUCT
 _implicit_div0_throws++;
 #endif
 #if INCLUDE_JVMCI
-if (nm->is_compiled_by_jvmci() && nm->pc_desc_at(pc) != NULL) {
+if (cm->is_compiled_by_jvmci() && cm->pc_desc_at(pc) != NULL) {
-return deoptimize_for_implicit_exception(thread, pc, nm, Deoptimization::Reason_div0_check);
+return deoptimize_for_implicit_exception(thread, pc, cm, Deoptimization::Reason_div0_check);
 } else {
 #endif // INCLUDE_JVMCI
-target_pc = nm->continuation_for_implicit_exception(pc);
+target_pc = cm->continuation_for_implicit_exception(pc);
 #if INCLUDE_JVMCI
 }
 #endif // INCLUDE_JVMCI
 // If there's an unexpected fault, target_pc might be NULL,
 // in which case we want to fall through into the normal
 return find_callee_info_helper(thread, vfst, bc, callinfo, THREAD);
 }
 methodHandle SharedRuntime::extract_attached_method(vframeStream& vfst) {
-nmethod* caller_nm = vfst.nm();
+CompiledMethod* caller = vfst.nm();
-nmethodLocker caller_lock(caller_nm);
+nmethodLocker caller_lock(caller);
 address pc = vfst.frame_pc();
 { // Get call instruction under lock because another thread may be busy patching it.
 MutexLockerEx ml_patch(Patching_lock, Mutex::_no_safepoint_check_flag);
-return caller_nm->attached_method_before_pc(pc);
+return caller->attached_method_before_pc(pc);
 }
 return NULL;
 }
 // Finds receiver, CallInfo (i.e. receiver method), and calling bytecode
 ResourceMark rm(thread);
 RegisterMap cbl_map(thread, false);
 frame caller_frame = thread->last_frame().sender(&cbl_map);
 CodeBlob* caller_cb = caller_frame.cb();
-guarantee(caller_cb != NULL && caller_cb->is_nmethod(), "must be called from nmethod");
+guarantee(caller_cb != NULL && caller_cb->is_compiled(), "must be called from compiled method");
-nmethod* caller_nm = caller_cb->as_nmethod_or_null();
+CompiledMethod* caller_nm = caller_cb->as_compiled_method_or_null();
 // make sure caller is not getting deoptimized
 // and removed before we are done with it.
 // CLEANUP - with lazy deopt shouldn't need this lock
 nmethodLocker caller_lock(caller_nm);
 StaticCallInfo static_call_info;
 CompiledICInfo virtual_call_info;
 // Make sure the callee nmethod does not get deoptimized and removed before
 // we are done patching the code.
-nmethod* callee_nm = callee_method->code();
+CompiledMethod* callee = callee_method->code();
-if (callee_nm != NULL && !callee_nm->is_in_use()) {
+if (callee != NULL) {
+assert(callee->is_compiled(), "must be nmethod for patching");
+}
+if (callee != NULL && !callee->is_in_use()) {
 // Patch call site to C2I adapter if callee nmethod is deoptimized or unloaded.
-callee_nm = NULL;
+callee = NULL;
 }
-nmethodLocker nl_callee(callee_nm);
+nmethodLocker nl_callee(callee);
 #ifdef ASSERT
-address dest_entry_point = callee_nm == NULL ? 0 : callee_nm->entry_point(); // used below
+address dest_entry_point = callee == NULL ? 0 : callee->entry_point(); // used below
 #endif
 if (is_virtual) {
 assert(receiver.not_null() || invoke_code == Bytecodes::_invokehandle, "sanity check");
 bool static_bound = call_info.resolved_method()->can_be_statically_bound();
 // Don't update call site if callee nmethod was unloaded or deoptimized.
 // Don't update call site if callee nmethod was replaced by an other nmethod
 // which may happen when multiply alive nmethod (tiered compilation)
 // will be supported.
 if (!callee_method->is_old() &&
-(callee_nm == NULL || callee_nm->is_in_use() && (callee_method->code() == callee_nm))) {
+(callee == NULL || callee->is_in_use() && (callee_method->code() == callee))) {
 #ifdef ASSERT
 // We must not try to patch to jump to an already unloaded method.
 if (dest_entry_point != 0) {
 CodeBlob* cb = CodeCache::find_blob(dest_entry_point);
-assert((cb != NULL) && cb->is_nmethod() && (((nmethod*)cb) == callee_nm),
+assert((cb != NULL) && cb->is_compiled() && (((CompiledMethod*)cb) == callee),
 "should not call unloaded nmethod");
 }
 #endif
 if (is_virtual) {
 CompiledIC* inline_cache = CompiledIC_before(caller_nm, caller_frame.pc());
 // Update inline cache to megamorphic. Skip update if we are called from interpreted.
 { MutexLocker ml_patch (CompiledIC_lock);
 RegisterMap reg_map(thread, false);
 frame caller_frame = thread->last_frame().sender(&reg_map);
 CodeBlob* cb = caller_frame.cb();
-if (cb->is_nmethod()) {
+CompiledMethod* caller_nm = cb->as_compiled_method_or_null();
-CompiledIC* inline_cache = CompiledIC_before(((nmethod*)cb), caller_frame.pc());
+if (cb->is_compiled()) {
+CompiledIC* inline_cache = CompiledIC_before(((CompiledMethod*)cb), caller_frame.pc());
 bool should_be_mono = false;
 if (inline_cache->is_optimized()) {
 if (TraceCallFixup) {
 ResourceMark rm(thread);
 tty->print("OPTIMIZED IC miss (%s) call to", Bytecodes::name(bc));
 address pc = caller.pc();
 // Check for static or virtual call
 bool is_static_call = false;
-nmethod* caller_nm = CodeCache::find_nmethod(pc);
+CompiledMethod* caller_nm = CodeCache::find_compiled(pc);
 // Default call_addr is the location of the "basic" call.
 // Determine the address of the call we a reresolving. With
 // Inline Caches we will always find a recognizable call.
 // With Inline Caches disabled we may or may not find a
 // we did we'd leap into space because the callsite needs to use
 // "to interpreter" stub in order to load up the Method*. Don't
 // ask me how I know this...
 CodeBlob* cb = CodeCache::find_blob(caller_pc);
-if (!cb->is_nmethod() || entry_point == moop->get_c2i_entry()) {
+if (!cb->is_compiled() || entry_point == moop->get_c2i_entry()) {
 return;
 }
 // The check above makes sure this is a nmethod.
-nmethod* nm = cb->as_nmethod_or_null();
+CompiledMethod* nm = cb->as_compiled_method_or_null();
 assert(nm, "must be");
 // Get the return PC for the passed caller PC.
 address return_pc = caller_pc + frame::pc_return_offset;

changeset 38133	78b95467b9f1
parent 37439	e8970711113b
child 38174	f611c50b8703