truffle: src/share/vm/runtime/deoptimization.cpp comparison

comparison src/share/vm/runtime/deoptimization.cpp @ 3464:be4ca325525a

Merge.

author	Thomas Wuerthinger <thomas@wuerthinger.net>
date	Wed, 27 Jul 2011 17:32:44 -0700
parents	132aa6f2bbc0 3d2ab563047a
children	bc95d122df79

comparison

equal deleted inserted replaced

-:7c4b4daac19b
+:be4ca325525a
 bool DeoptimizationMarker::_is_active = false;
 Deoptimization::UnrollBlock::UnrollBlock(int  size_of_deoptimized_frame,
 int  caller_adjustment,
+int  caller_actual_parameters,
 int  number_of_frames,
 intptr_t* frame_sizes,
 address* frame_pcs,
 BasicType return_type) {
 _size_of_deoptimized_frame = size_of_deoptimized_frame;
 _caller_adjustment         = caller_adjustment;
+_caller_actual_parameters  = caller_actual_parameters;
 _number_of_frames          = number_of_frames;
 _frame_sizes               = frame_sizes;
 _frame_pcs                 = frame_pcs;
 _register_block            = NEW_C_HEAP_ARRAY(intptr_t, RegisterMap::reg_count * 2);
 _return_type               = return_type;
 // Now get the deoptee with a valid map
 frame deoptee = stub_frame.sender(&map);
 // Set the deoptee nmethod
 assert(thread->deopt_nmethod() == NULL, "Pending deopt!");
 thread->set_deopt_nmethod(deoptee.cb()->as_nmethod_or_null());
+if (VerifyStack) {
+thread->validate_frame_layout();
+}
 // Create a growable array of VFrames where each VFrame represents an inlined
 // Java frame.  This storage is allocated with the usual system arena.
 assert(deoptee.is_compiled_frame(), "Wrong frame type");
 GrowableArray<compiledVFrame*>* chunk = new GrowableArray<compiledVFrame*>(10);
 // activation be put back on the expression stack of the caller for reexecution
 if (JvmtiExport::can_pop_frame() && thread->popframe_forcing_deopt_reexecution()) {
 popframe_extra_args = in_words(thread->popframe_preserved_args_size_in_words());
 }
+// Find the current pc for sender of the deoptee. Since the sender may have been deoptimized
+// itself since the deoptee vframeArray was created we must get a fresh value of the pc rather
+// than simply use array->sender.pc(). This requires us to walk the current set of frames
+//
+frame deopt_sender = stub_frame.sender(&dummy_map); // First is the deoptee frame
+deopt_sender = deopt_sender.sender(&dummy_map);     // Now deoptee caller
+// It's possible that the number of paramters at the call site is
+// different than number of arguments in the callee when method
+// handles are used.  If the caller is interpreted get the real
+// value so that the proper amount of space can be added to it's
+// frame.
+int caller_actual_parameters = callee_parameters;
+if (deopt_sender.is_interpreted_frame()) {
+methodHandle method = deopt_sender.interpreter_frame_method();
+Bytecode_invoke cur = Bytecode_invoke_check(method,
+deopt_sender.interpreter_frame_bci());
+Symbol* signature = method->constants()->signature_ref_at(cur.index());
+ArgumentSizeComputer asc(signature);
+caller_actual_parameters = asc.size() + (cur.has_receiver() ? 1 : 0);
+}
 //
 // frame_sizes/frame_pcs[0] oldest frame (int or c2i)
 // frame_sizes/frame_pcs[1] next oldest frame (int)
 // frame_sizes/frame_pcs[n] youngest frame (int)
 //
 //
 for (int index = 0; index < array->frames(); index++ ) {
 // frame[number_of_frames - 1 ] = on_stack_size(youngest)
 // frame[number_of_frames - 2 ] = on_stack_size(sender(youngest))
 // frame[number_of_frames - 3 ] = on_stack_size(sender(sender(youngest)))
-frame_sizes[number_of_frames - 1 - index] = BytesPerWord * array->element(index)->on_stack_size(callee_parameters,
+int caller_parms = callee_parameters;
+if (index == array->frames() - 1) {
+// Use the value from the interpreted caller
+caller_parms = caller_actual_parameters;
+}
+frame_sizes[number_of_frames - 1 - index] = BytesPerWord * array->element(index)->on_stack_size(caller_parms,
+callee_parameters,
 callee_locals,
 index == 0,
 popframe_extra_args);
 // This pc doesn't have to be perfect just good enough to identify the frame
 // as interpreted so the skeleton frame will be walkable
 }
 // Compute information for handling adapters and adjusting the frame size of the caller.
 int caller_adjustment = 0;
-// Find the current pc for sender of the deoptee. Since the sender may have been deoptimized
-// itself since the deoptee vframeArray was created we must get a fresh value of the pc rather
-// than simply use array->sender.pc(). This requires us to walk the current set of frames
-//
-frame deopt_sender = stub_frame.sender(&dummy_map); // First is the deoptee frame
-deopt_sender = deopt_sender.sender(&dummy_map);     // Now deoptee caller
 // Compute the amount the oldest interpreter frame will have to adjust
 // its caller's stack by. If the caller is a compiled frame then
 // we pretend that the callee has no parameters so that the
 // extension counts for the full amount of locals and not just
 // locals-parms. This is because without a c2i adapter the parm
 // QQQ I'd rather see this pushed down into last_frame_adjust
 // and have it take the sender (aka caller).
 if (deopt_sender.is_compiled_frame()) {
 caller_adjustment = last_frame_adjust(0, callee_locals);
-} else if (callee_locals > callee_parameters) {
+} else if (callee_locals > caller_actual_parameters) {
 // The caller frame may need extending to accommodate
 // non-parameter locals of the first unpacked interpreted frame.
 // Compute that adjustment.
-caller_adjustment = last_frame_adjust(callee_parameters, callee_locals);
+caller_adjustment = last_frame_adjust(caller_actual_parameters, callee_locals);
 }
 // If the sender is deoptimized the we must retrieve the address of the handler
 // since the frame will "magically" show the original pc before the deopt
 // and we'd undo the deopt.
 assert(CodeCache::find_blob_unsafe(frame_pcs[0]) != NULL, "bad pc");
 #endif // SHARK
 UnrollBlock* info = new UnrollBlock(array->frame_size() * BytesPerWord,
 caller_adjustment * BytesPerWord,
+caller_actual_parameters,
 number_of_frames,
 frame_sizes,
 frame_pcs,
 return_type);
 // On some platforms, we need a way to pass fp to the unpacking code
 #endif
 UnrollBlock* info = array->unroll_block();
 // Unpack the interpreter frames and any adapter frame (c2 only) we might create.
-array->unpack_to_stack(stub_frame, exec_mode);
+array->unpack_to_stack(stub_frame, exec_mode, info->caller_actual_parameters());
 BasicType bt = info->return_type();
 // If we have an exception pending, claim that the return type is an oop
 // so the deopt_blob does not overwrite the exception_oop.
 cleanup_deopt_info(thread, array);
 #ifndef PRODUCT
 if (VerifyStack) {
 ResourceMark res_mark;
+thread->validate_frame_layout();
 // Verify that the just-unpacked frames match the interpreter's
 // notions of expression stack and locals
 vframeArray* cur_array = thread->vframe_array_last();
 RegisterMap rm(thread, false);
 "unreached",
 "unhandled",
 "constraint",
 "div0_check",
 "age",
-"predicate"
+"predicate",
+"loop_limit_check"
 };
 const char* Deoptimization::_trap_action_name[Action_LIMIT] = {
 // Note:  Keep this in sync. with enum DeoptAction.
 "none",
 "maybe_recompile",

Mercurial > hg > truffle

comparison src/share/vm/runtime/deoptimization.cpp @ 3464:be4ca325525a