jdk-sandbox: comparison hotspot/src/cpu/x86/vm/cppInterpreter

equal deleted inserted replaced

-:2927072ed5fb
+:77b156916bab
 to_fill->_self_link = to_fill;
 assert(stack >= to_fill->_stack_limit && stack < to_fill->_stack_base,
 "Stack top out of range");
 }
-int AbstractInterpreter::layout_activation(Method* method,
-int tempcount,  //
+static int frame_size_helper(int max_stack,
-int popframe_extra_args,
+int tempcount,
 int moncount,
-int caller_actual_parameters,
+int callee_param_count,
-int callee_param_count,
+int callee_locals,
-int callee_locals,
+bool is_top_frame,
-frame* caller,
+int& monitor_size,
-frame* interpreter_frame,
+int& full_frame_size) {
-bool is_top_frame,
+int extra_locals_size = (callee_locals - callee_param_count) * BytesPerWord;
-bool is_bottom_frame) {
+monitor_size = sizeof(BasicObjectLock) * moncount;
-assert(popframe_extra_args == 0, "FIX ME");
+// First calculate the frame size without any java expression stack
-// NOTE this code must exactly mimic what InterpreterGenerator::generate_compute_interpreter_state()
+int short_frame_size = size_activation_helper(extra_locals_size,
-// does as far as allocating an interpreter frame.
+monitor_size);
-// If interpreter_frame!=NULL, set up the method, locals, and monitors.
-// The frame interpreter_frame, if not NULL, is guaranteed to be the right size,
+// Now with full size expression stack
-// as determined by a previous call to this method.
+full_frame_size = short_frame_size + max_stack * BytesPerWord;
-// It is also guaranteed to be walkable even though it is in a skeletal state
+// and now with only live portion of the expression stack
+short_frame_size = short_frame_size + tempcount * BytesPerWord;
+// the size the activation is right now. Only top frame is full size
+int frame_size = (is_top_frame ? full_frame_size : short_frame_size);
+return frame_size;
+}
+int AbstractInterpreter::size_activation(int max_stack,
+int tempcount,
+int extra_args,
+int moncount,
+int callee_param_count,
+int callee_locals,
+bool is_top_frame) {
+assert(extra_args == 0, "FIX ME");
 // NOTE: return size is in words not bytes
-// NOTE: tempcount is the current size of the java expression stack. For top most
-//       frames we will allocate a full sized expression stack and not the curback
-//       version that non-top frames have.
 // Calculate the amount our frame will be adjust by the callee. For top frame
 // this is zero.
 // NOTE: ia64 seems to do this wrong (or at least backwards) in that it
 // calculates the extra locals based on itself. Not what the callee does
 // to it. So it ignores last_frame_adjust value. Seems suspicious as far
 // as getting sender_sp correct.
-int extra_locals_size = (callee_locals - callee_param_count) * BytesPerWord;
+int unused_monitor_size = 0;
-int monitor_size = sizeof(BasicObjectLock) * moncount;
+int unused_full_frame_size = 0;
+return frame_size_helper(max_stack, tempcount, moncount, callee_param_count, callee_locals,
-// First calculate the frame size without any java expression stack
+is_top_frame, unused_monitor_size, unused_full_frame_size)/BytesPerWord;
-int short_frame_size = size_activation_helper(extra_locals_size,
+}
-monitor_size);
+void AbstractInterpreter::layout_activation(Method* method,
-// Now with full size expression stack
+int tempcount,  //
-int full_frame_size = short_frame_size + method->max_stack() * BytesPerWord;
+int popframe_extra_args,
+int moncount,
-// and now with only live portion of the expression stack
+int caller_actual_parameters,
-short_frame_size = short_frame_size + tempcount * BytesPerWord;
+int callee_param_count,
+int callee_locals,
-// the size the activation is right now. Only top frame is full size
+frame* caller,
-int frame_size = (is_top_frame ? full_frame_size : short_frame_size);
+frame* interpreter_frame,
+bool is_top_frame,
-if (interpreter_frame != NULL) {
+bool is_bottom_frame) {
+assert(popframe_extra_args == 0, "FIX ME");
+// NOTE this code must exactly mimic what InterpreterGenerator::generate_compute_interpreter_state()
+// does as far as allocating an interpreter frame.
+// Set up the method, locals, and monitors.
+// The frame interpreter_frame is guaranteed to be the right size,
+// as determined by a previous call to the size_activation() method.
+// It is also guaranteed to be walkable even though it is in a skeletal state
+// NOTE: tempcount is the current size of the java expression stack. For top most
+//       frames we will allocate a full sized expression stack and not the curback
+//       version that non-top frames have.
+int monitor_size = 0;
+int full_frame_size = 0;
+int frame_size = frame_size_helper(method->max_stack(), tempcount, moncount, callee_param_count, callee_locals,
+is_top_frame, monitor_size, full_frame_size);
 #ifdef ASSERT
 assert(caller->unextended_sp() == interpreter_frame->interpreter_frame_sender_sp(), "Frame not properly walkable");
 #endif
 // MUCHO HACK
 intptr_t* frame_bottom = (intptr_t*) ((intptr_t)interpreter_frame->sp() - (full_frame_size - frame_size));
 /* Now fillin the interpreterState object */
 // The state object is the first thing on the frame and easily located
 interpreterState cur_state = (interpreterState) ((intptr_t)interpreter_frame->fp() - sizeof(BytecodeInterpreter));
 // Find the locals pointer. This is rather simple on x86 because there is no
 // confusing rounding at the callee to account for. We can trivially locate
 // our locals based on the current fp().
 // Note: the + 2 is for handling the "static long no_params() method" issue.
 // (too bad I don't really remember that issue well...)
 intptr_t* locals;
 // If the caller is interpreted we need to make sure that locals points to the first
 // argument that the caller passed and not in an area where the stack might have been extended.
 // because the stack to stack to converter needs a proper locals value in order to remove the
 // arguments from the caller and place the result in the proper location. Hmm maybe it'd be
 // simpler if we simply stored the result in the BytecodeInterpreter object and let the c++ code
 // adjust the stack?? HMMM QQQ
 //
 if (caller->is_interpreted_frame()) {
 // locals must agree with the caller because it will be used to set the
 // caller's tos when we return.
 interpreterState prev  = caller->get_interpreterState();
 // stack() is prepushed.
 locals = prev->stack() + method->size_of_parameters();
 // locals = caller->unextended_sp() + (method->size_of_parameters() - 1);
 if (locals != interpreter_frame->fp() + frame::sender_sp_offset + (method->max_locals() - 1) + 2) {
 // os::breakpoint();
-}
-} else {
-// this is where a c2i would have placed locals (except for the +2)
-locals = interpreter_frame->fp() + frame::sender_sp_offset + (method->max_locals() - 1) + 2;
 }
+} else {
-intptr_t* monitor_base = (intptr_t*) cur_state;
+// this is where a c2i would have placed locals (except for the +2)
-intptr_t* stack_base = (intptr_t*) ((intptr_t) monitor_base - monitor_size);
+locals = interpreter_frame->fp() + frame::sender_sp_offset + (method->max_locals() - 1) + 2;
-/* +1 because stack is always prepushed */
+}
-intptr_t* stack = (intptr_t*) ((intptr_t) stack_base - (tempcount + 1) * BytesPerWord);
+intptr_t* monitor_base = (intptr_t*) cur_state;
+intptr_t* stack_base = (intptr_t*) ((intptr_t) monitor_base - monitor_size);
-BytecodeInterpreter::layout_interpreterState(cur_state,
+/* +1 because stack is always prepushed */
-caller,
+intptr_t* stack = (intptr_t*) ((intptr_t) stack_base - (tempcount + 1) * BytesPerWord);
-interpreter_frame,
-method,
-locals,
+BytecodeInterpreter::layout_interpreterState(cur_state,
-stack,
+caller,
-stack_base,
+interpreter_frame,
-monitor_base,
+method,
-frame_bottom,
+locals,
-is_top_frame);
+stack,
+stack_base,
-// BytecodeInterpreter::pd_layout_interpreterState(cur_state, interpreter_return_address, interpreter_frame->fp());
+monitor_base,
-}
+frame_bottom,
-return frame_size/BytesPerWord;
+is_top_frame);
+// BytecodeInterpreter::pd_layout_interpreterState(cur_state, interpreter_return_address, interpreter_frame->fp());
 }
 bool AbstractInterpreter::can_be_compiled(methodHandle m) {
 switch (method_kind(m)) {
 case Interpreter::java_lang_math_sin     : // fall thru

changeset 24018	77b156916bab
parent 23844	0c29a324ae14
child 25950	b5c40ed1d349