# HG changeset patch # User Gilles Duboscq # Date 1446131505 -3600 # Node ID 3c1edc9c60d8f4ecea01794eb0acccea400a89b1 # Parent 316e768645c07309a10dc9c150b4b968d06b66cc Let fetch_unroll_info override the exec_mode and handle rethrowing scopes Scopes with rethrow_exception set to true need to be handled for all types of deoptimization, not just for uncommon traps. This change moves their handling from uncommon_trap_inner to fetch_unroll_info_helper and uses exception_oop and exec_mode Unpack_exception rather than setting a pending execption. fetch_unroll_info_helper can now override the exec_mode by passing it through the UnrollBlock. diff -r 316e768645c0 -r 3c1edc9c60d8 src/cpu/sparc/vm/sharedRuntime_sparc.cpp --- a/src/cpu/sparc/vm/sharedRuntime_sparc.cpp Thu Oct 29 15:21:55 2015 +0100 +++ b/src/cpu/sparc/vm/sharedRuntime_sparc.cpp Thu Oct 29 16:11:45 2015 +0100 @@ -3557,6 +3557,7 @@ __ mov((int32_t)Deoptimization::Unpack_reexecute, L0deopt_mode); __ mov(G2_thread, O0); + __ mov(L0deopt_mode, O2); __ call(CAST_FROM_FN_PTR(address, Deoptimization::uncommon_trap)); __ delayed()->nop(); oop_maps->add_gc_map( __ offset()-start, map->deep_copy()); @@ -3640,6 +3641,7 @@ // do the call by hand so we can get the oopmap __ mov(G2_thread, L7_thread_cache); + __ mov(L0deopt_mode, O1); __ call(CAST_FROM_FN_PTR(address, Deoptimization::fetch_unroll_info), relocInfo::runtime_call_type); __ delayed()->mov(G2_thread, O0); @@ -3663,6 +3665,7 @@ RegisterSaver::restore_result_registers(masm); + __ ld(O2UnrollBlock, Deoptimization::UnrollBlock::exec_mode_offset_in_bytes(), G4deopt_mode); Label noException; __ cmp_and_br_short(G4deopt_mode, Deoptimization::Unpack_exception, Assembler::notEqual, Assembler::pt, noException); @@ -3784,7 +3787,8 @@ __ save_frame(0); __ set_last_Java_frame(SP, noreg); __ mov(I0, O2klass_index); - __ call_VM_leaf(L7_thread_cache, CAST_FROM_FN_PTR(address, Deoptimization::uncommon_trap), G2_thread, O2klass_index); + __ mov(Deoptimization::Unpack_uncommon_trap, O3); // exec mode + __ call_VM_leaf(L7_thread_cache, CAST_FROM_FN_PTR(address, Deoptimization::uncommon_trap), G2_thread, O2klass_index, O3); __ reset_last_Java_frame(); __ mov(O0, O2UnrollBlock->after_save()); __ restore(); @@ -3793,6 +3797,15 @@ __ mov(O2UnrollBlock, O2UnrollBlock->after_save()); __ restore(); +#ifdef ASSERT + { Label L; + __ ld(O2UnrollBlock, Deoptimization::UnrollBlock::exec_mode_offset_in_bytes(), O1); + __ cmp_and_br_short(O1, Deoptimization::Unpack_uncommon_trap, Assembler::equal, Assembler::pt, L); + __ stop("SharedRuntime::generate_deopt_blob: expected Unpack_uncommon_trap"); + __ bind(L); + } +#endif + // Allocate new interpreter frame(s) and possible c2i adapter frame make_new_frames(masm, false); diff -r 316e768645c0 -r 3c1edc9c60d8 src/cpu/x86/vm/sharedRuntime_x86_64.cpp --- a/src/cpu/x86/vm/sharedRuntime_x86_64.cpp Thu Oct 29 15:21:55 2015 +0100 +++ b/src/cpu/x86/vm/sharedRuntime_x86_64.cpp Thu Oct 29 16:11:45 2015 +0100 @@ -3411,6 +3411,7 @@ __ movl(r14, (int32_t)Deoptimization::Unpack_reexecute); __ mov(c_rarg0, r15_thread); + __ movl(c_rarg2, r14); // exec mode __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, Deoptimization::uncommon_trap))); oop_maps->add_gc_map( __ pc()-start, map->deep_copy()); @@ -3497,6 +3498,7 @@ } #endif // ASSERT __ mov(c_rarg0, r15_thread); + __ movl(c_rarg1, r14); // exec_mode __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, Deoptimization::fetch_unroll_info))); // Need to have an oopmap that tells fetch_unroll_info where to @@ -3512,6 +3514,7 @@ // Load UnrollBlock* into rdi __ mov(rdi, rax); + __ movl(r14, Address(rdi, Deoptimization::UnrollBlock::exec_mode_offset_in_bytes())); Label noException; __ cmpl(r14, Deoptimization::Unpack_exception); // Was exception pending? __ jcc(Assembler::notEqual, noException); @@ -3728,6 +3731,7 @@ // UnrollBlock* uncommon_trap(JavaThread* thread, jint unloaded_class_index); __ mov(c_rarg0, r15_thread); + __ movl(c_rarg2, Deoptimization::Unpack_uncommon_trap); __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, Deoptimization::uncommon_trap))); // Set an oopmap for the call site @@ -3743,6 +3747,16 @@ // Load UnrollBlock* into rdi __ mov(rdi, rax); +#ifdef ASSERT + { Label L; + __ cmpptr(Address(rdi, Deoptimization::UnrollBlock::exec_mode_offset_in_bytes()), + (int32_t)Deoptimization::Unpack_uncommon_trap); + __ jcc(Assembler::equal, L); + __ stop("SharedRuntime::generate_deopt_blob: expected Unpack_uncommon_trap"); + __ bind(L); + } +#endif + // Pop all the frames we must move/replace. // // Frame picture (youngest to oldest) diff -r 316e768645c0 -r 3c1edc9c60d8 src/share/vm/runtime/deoptimization.cpp --- a/src/share/vm/runtime/deoptimization.cpp Thu Oct 29 15:21:55 2015 +0100 +++ b/src/share/vm/runtime/deoptimization.cpp Thu Oct 29 16:11:45 2015 +0100 @@ -106,7 +106,8 @@ int number_of_frames, intptr_t* frame_sizes, address* frame_pcs, - BasicType return_type) { + BasicType return_type, + int exec_mode) { _size_of_deoptimized_frame = size_of_deoptimized_frame; _caller_adjustment = caller_adjustment; _caller_actual_parameters = caller_actual_parameters; @@ -122,6 +123,8 @@ _sender_sp_temp = 0; _total_frame_sizes = size_of_frames(); + assert(exec_mode >= 0 && exec_mode < Unpack_LIMIT, "Unexpected exec_mode"); + _exec_mode = exec_mode; } @@ -166,7 +169,7 @@ // ResetNoHandleMark and HandleMark were removed from it. The actual reallocation // of previously eliminated objects occurs in realloc_objects, which is // called from the method fetch_unroll_info_helper below. -JRT_BLOCK_ENTRY(Deoptimization::UnrollBlock*, Deoptimization::fetch_unroll_info(JavaThread* thread)) +JRT_BLOCK_ENTRY(Deoptimization::UnrollBlock*, Deoptimization::fetch_unroll_info(JavaThread* thread, int exec_mode)) // It is actually ok to allocate handles in a leaf method. It causes no safepoints, // but makes the entry a little slower. There is however a little dance we have to // do in debug mode to get around the NoHandleMark code in the JRT_LEAF macro @@ -180,12 +183,12 @@ } thread->inc_in_deopt_handler(); - return fetch_unroll_info_helper(thread); + return fetch_unroll_info_helper(thread, exec_mode); JRT_END // This is factored, since it is both called from a JRT_LEAF (deoptimization) and a JRT_ENTRY (uncommon_trap) -Deoptimization::UnrollBlock* Deoptimization::fetch_unroll_info_helper(JavaThread* thread) { +Deoptimization::UnrollBlock* Deoptimization::fetch_unroll_info_helper(JavaThread* thread, int exec_mode) { // Note: there is a safepoint safety issue here. No matter whether we enter // via vanilla deopt or uncommon trap we MUST NOT stop at a safepoint once @@ -224,6 +227,21 @@ assert(vf->is_compiled_frame(), "Wrong frame type"); chunk->push(compiledVFrame::cast(vf)); +#ifdef INCLUDE_JVMCI + ScopeDesc* trap_scope = chunk->at(0)->scope(); + Handle exceptionObject; + if (trap_scope->rethrow_exception()) { + if (PrintDeoptimizationDetails) { + tty->print_cr("Exception to be rethrown in the interpreter for method %s::%s at bci %d", trap_scope->method()->method_holder()->name()->as_C_string(), trap_scope->method()->name()->as_C_string(), trap_scope->bci()); + } + GrowableArray* expressions = trap_scope->expressions(); + guarantee(expressions != NULL && expressions->length() > 0, "must have exception to throw"); + ScopeValue* topOfStack = expressions->top(); + exceptionObject = StackValue::create_stack_value(&deoptee, &map, topOfStack)->get_obj(); + assert(exceptionObject() != NULL, "exception oop can not be null"); + } +#endif + bool realloc_failures = false; #if defined(COMPILER2) || INCLUDE_JVMCI @@ -512,13 +530,21 @@ assert(CodeCache::find_blob_unsafe(frame_pcs[0]) != NULL, "bad pc"); #endif // SHARK +#ifdef INCLUDE_JVMCI + if (exceptionObject() != NULL) { + thread->set_exception_oop(exceptionObject()); + exec_mode = Unpack_exception; + } +#endif + UnrollBlock* info = new UnrollBlock(array->frame_size() * BytesPerWord, caller_adjustment * BytesPerWord, caller_was_method_handle ? 0 : callee_parameters, number_of_frames, frame_sizes, frame_pcs, - return_type); + return_type, + exec_mode); // On some platforms, we need a way to pass some platform dependent // information to the unpacking code so the skeletal frames come out // correct (initial fp value, unextended sp, ...) @@ -1514,17 +1540,6 @@ Bytecodes::Code trap_bc = trap_method->java_code_at(trap_bci); - if (trap_scope->rethrow_exception()) { - if (PrintDeoptimizationDetails) { - tty->print_cr("Exception to be rethrown in the interpreter for method %s::%s at bci %d", trap_method->method_holder()->name()->as_C_string(), trap_method->name()->as_C_string(), trap_bci); - } - GrowableArray* expressions = trap_scope->expressions(); - guarantee(expressions != NULL, "must have exception to throw"); - ScopeValue* topOfStack = expressions->top(); - Handle topOfStackObj = StackValue::create_stack_value(&fr, ®_map, topOfStack)->get_obj(); - THREAD->set_pending_exception(topOfStackObj(), NULL, 0); - } - // Record this event in the histogram. gather_statistics(reason, action, trap_bc); @@ -2013,7 +2028,7 @@ ignore_maybe_prior_recompile); } -Deoptimization::UnrollBlock* Deoptimization::uncommon_trap(JavaThread* thread, jint trap_request) { +Deoptimization::UnrollBlock* Deoptimization::uncommon_trap(JavaThread* thread, jint trap_request, jint exec_mode) { if (TraceDeoptimization) { tty->print("Uncommon trap "); } @@ -2022,7 +2037,7 @@ // This enters VM and may safepoint uncommon_trap_inner(thread, trap_request); } - return fetch_unroll_info_helper(thread); + return fetch_unroll_info_helper(thread, exec_mode); } // Local derived constants. diff -r 316e768645c0 -r 3c1edc9c60d8 src/share/vm/runtime/deoptimization.hpp --- a/src/share/vm/runtime/deoptimization.hpp Thu Oct 29 15:21:55 2015 +0100 +++ b/src/share/vm/runtime/deoptimization.hpp Thu Oct 29 16:11:45 2015 +0100 @@ -116,7 +116,8 @@ Unpack_deopt = 0, // normal deoptimization, use pc computed in unpack_vframe_on_stack Unpack_exception = 1, // exception is pending Unpack_uncommon_trap = 2, // redo last byte code (C2 only) - Unpack_reexecute = 3 // reexecute bytecode (C1 only) + Unpack_reexecute = 3, // reexecute bytecode (C1 only) + Unpack_LIMIT = 4 }; // Checks all compiled methods. Invalid methods are deleted and @@ -172,6 +173,7 @@ intptr_t _initial_info; // Platform dependent data for the sender frame (was FP on x86) int _caller_actual_parameters; // The number of actual arguments at the // interpreted caller of the deoptimized frame + int _exec_mode; // exec_mode that can be changed during fetch_unroll_info // The following fields are used as temps during the unpacking phase // (which is tight on registers, especially on x86). They really ought @@ -188,7 +190,8 @@ int number_of_frames, intptr_t* frame_sizes, address* frames_pcs, - BasicType return_type); + BasicType return_type, + int exec_mode); ~UnrollBlock(); // Returns where a register is located. @@ -198,6 +201,7 @@ intptr_t* frame_sizes() const { return _frame_sizes; } int number_of_frames() const { return _number_of_frames; } address* frame_pcs() const { return _frame_pcs ; } + int exec_mode() const { return _exec_mode ; } // Returns the total size of frames int size_of_frames() const; @@ -219,6 +223,7 @@ static int initial_info_offset_in_bytes() { return offset_of(UnrollBlock, _initial_info); } static int unpack_kind_offset_in_bytes() { return offset_of(UnrollBlock, _unpack_kind); } static int sender_sp_temp_offset_in_bytes() { return offset_of(UnrollBlock, _sender_sp_temp); } + static int exec_mode_offset_in_bytes() { return offset_of(UnrollBlock, _exec_mode); } BasicType return_type() const { return _return_type; } void print(); @@ -230,7 +235,7 @@ // deoptimized frame. // @argument thread. Thread where stub_frame resides. // @see OptoRuntime::deoptimization_fetch_unroll_info_C - static UnrollBlock* fetch_unroll_info(JavaThread* thread); + static UnrollBlock* fetch_unroll_info(JavaThread* thread, int exec_mode); //** Unpacks vframeArray onto execution stack // Called by assembly stub after execution has returned to @@ -255,7 +260,7 @@ //** Performs an uncommon trap for compiled code. // The top most compiler frame is converted into interpreter frames - static UnrollBlock* uncommon_trap(JavaThread* thread, jint unloaded_class_index); + static UnrollBlock* uncommon_trap(JavaThread* thread, jint unloaded_class_index, jint exec_mode); // Helper routine that enters the VM and may block static void uncommon_trap_inner(JavaThread* thread, jint unloaded_class_index); @@ -407,7 +412,7 @@ static void load_class_by_index(constantPoolHandle constant_pool, int index, TRAPS); static void load_class_by_index(constantPoolHandle constant_pool, int index); - static UnrollBlock* fetch_unroll_info_helper(JavaThread* thread); + static UnrollBlock* fetch_unroll_info_helper(JavaThread* thread, int exec_mode); static DeoptAction _unloaded_action; // == Action_reinterpret; static const char* _trap_reason_name[]; diff -r 316e768645c0 -r 3c1edc9c60d8 src/share/vm/shark/sharkRuntime.cpp --- a/src/share/vm/shark/sharkRuntime.cpp Thu Oct 29 15:21:55 2015 +0100 +++ b/src/share/vm/shark/sharkRuntime.cpp Thu Oct 29 16:11:45 2015 +0100 @@ -212,8 +212,9 @@ // Initiate the trap thread->set_last_Java_frame(); Deoptimization::UnrollBlock *urb = - Deoptimization::uncommon_trap(thread, trap_request); + Deoptimization::uncommon_trap(thread, trap_request, Deoptimization::Unpack_uncommon_trap); thread->reset_last_Java_frame(); + assert(urb->exec_mode() == Deoptimization::Unpack_uncommon_trap, "expected Unpack_uncommon_trap"); // Pop our dummy frame and the frame being deoptimized thread->pop_zero_frame();