Lines Matching refs:frame
40 #include "runtime/frame.inline.hpp"
64 ( pc == (CAST_FROM_FN_PTR(address, RecursiveInterpreterActivation) + frame::pc_return_offset)));
109 // a java interpreter/compiler result. The current frame is an
110 // interpreter frame. The activation frame unwind code must be
139 __ delayed()->restore(I5_savedSP, G0, SP); // remove interpreter frame
248 // Because of the way activation are managed by the frame manager the value of esp is
251 // to the frame manager on the stack and do a vanilla return.
276 // The caller's expression stack is adjacent to the current frame manager's intepretState
306 // We are in a new frame registers we set must be in caller (i.e. callstub) frame.
309 // frame manager execept in this situation the caller is native code (c1/c2/call_stub)
336 // The caller's expression stack is adjacent to the current frame manager's interpretState
369 return CAST_FROM_FN_PTR(address, RecursiveInterpreterActivation) + frame::pc_return_offset;
468 // frame if so.
578 // than the typical interpreter frame setup.
584 // the following temporary registers are used during frame creation
630 // generate the code to allocate the interpreter stack frame
649 // interpreter frame and not perform an unlock while doing so.
728 // Push a new frame so that the args will really be stored in
729 // Copy a few locals across so the new frame has the variables
732 // frame (Lstate in particular)
738 __ mov(Lstate, O1); // Need to pass the state pointer across the frame
740 // Calculate current frame size
741 __ sub(SP, FP, O3); // Calculate negative of current frame size
742 __ save(SP, O3, SP); // Allocate an identical sized frame
748 // below (and fix I7 so the stack trace doesn't have a meaningless frame
808 // setup the java frame anchor
810 // The scavenge function only needs to know that the PC of this frame is
816 // we have pushed the extra frame in order to protect the volatile register(s)
817 // in that frame when we return from the jni call
822 __ mov(O7, I7); // make dummy interpreter frame look like one above,
825 // flush the windows now. We don't care about the current (protection) frame
908 // Clear the frame anchor now
914 // return possible result to the outer frame
974 __ delayed()->restore(I5_savedSP, G0, SP); // remove interpreter frame
986 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
1043 // "prev_state" - contains any previous frame manager state which we must save a link
1066 frame::memory_parameter_word_sp_offset + // register save area + param window
1067 (native ? frame::interpreter_frame_extra_outgoing_argument_words : 0); // JNI, class
1071 // Now compute new frame size
1083 __ sll(Gtmp, LogBytesPerWord, Gtmp); // negative space for frame in bytes
1099 // Also a fudge for frame size of BytecodeInterpreter::run
1118 __ save(SP, Gtmp, SP); // setup new frame and register window
1197 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
1204 // Remember initial frame bottom
1241 // NOTE: If you change the frame layout, this code will need to
1388 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
1423 // This entry point is called the frame manager since it handles the generation
1428 // the frame manager. The frame manager can take the following requests:
1441 // esi: previous frame manager state (NULL from the call_stub/c1/c2)
1504 // frame::memory_parameter_word_sp_offset. This is mostly not noticable for either asm
1512 const int c2i_adjust_words = frame::memory_parameter_word_sp_offset - frame::callee_register_argument_save_area_sp_offset;
1518 __ sub(SP, Gtmp, SP); // just caller's frame for the additional space we need.
1528 // A single frame manager is plenty as we don't specialize for synchronized. We could and
1539 // the following temporary registers are used during frame creation
1568 // At this point a new interpreter frame and state object are created and initialized
1606 __ stop("SP not restored to frame bottom");
1666 __ delayed()->ld_ptr(STATE(_frame_bottom), SP); // restore to full stack frame
1684 // Current frame has caught an exception we need to dispatch to the
1685 // handler. We can get here because a native interpreter frame caught
1687 // If it is a vanilla interpreted frame the we simply drop into the
1698 // We want exception in the thread no matter what we ultimately decide about frame type.
1707 // if this current frame vanilla or native?
1711 __ br(Assembler::zero, false, Assembler::pt, return_with_exception); // vanilla interpreted frame handle directly
1714 // We drop thru to unwind a native interpreted frame with a pending exception
1715 // We jump here for the initial interpreter frame with exception pending
1720 // Unwind frame and jump to forward exception. unwinding will place throwing pc in O7
1723 __ restore(FP, G0, SP); // unwind interpreter state frame
1745 __ ld_ptr(STATE(_frame_bottom), SP); // restore to full stack frame
1772 // An exception is being caught on return to a vanilla interpreter frame.
1777 __ ld_ptr(STATE(_frame_bottom), SP); // restore to full stack frame
1837 // frame and tell interpreter to resume.
1842 __ restore(FP, G0, SP); // unwind interpreter state frame
1843 __ ld_ptr(STATE(_frame_bottom), SP); // restore to full stack frame
1846 // Resume the interpreter. The current frame contains the current interpreter
1854 // A frame we have already used before so no need to bang stack so use call_interpreter_2 entry
1863 // This works because frame manager is in the same codelet
1905 // OSR request, unwind the current frame and transfer to the OSR entry
1913 // We are going to pop this frame. Is there another interpreter frame underneath
1920 // Frame underneath is an interpreter frame simply unwind
1922 __ restore(FP, G0, SP); // unwind interpreter state frame
1943 // At this point we have a topmost frame that was allocated by the frame manager
1944 // which contains the current method interpreted state. We trim this frame
1992 // Create a new frame where we can store values that make it look like the interpreter
2053 // Figure out the size of an interpreter frame (in words) given that we have a fully allocated
2055 // frame extension) and monitor_size for monitors. Basically we need to calculate
2070 frame::memory_parameter_word_sp_offset; // register save area + param window
2084 int call_stub_size = round_to(7 + frame::memory_parameter_word_sp_offset,
2090 1*frame::interpreter_frame_monitor_size() : 0;
2096 frame* caller,
2097 frame* current,
2127 // Fill in the registers for the frame
2132 // skeletal frame constructed (because there is only a single
2185 frame* caller,
2186 frame* interpreter_frame,
2192 // does as far as allocating an interpreter frame.
2194 // The frame interpreter_frame, if not NULL, is guaranteed to be the right size,
2202 // Calculate the amount our frame will be adjust by the callee. For top frame
2218 if we actually have a frame to layout we must now fill in all the pieces. This means both
2262 locals = fp + frame::register_save_words + local_words - 1;
2264 locals = fp + frame::memory_parameter_word_sp_offset + local_words - 1;