Cross Reference: /openjdk7/hotspot/src/cpu/x86/vm/templateInterpreter_x86

Lines Matching refs:frame
40 #include "runtime/frame.inline.hpp"
52 const int method_offset = frame::interpreter_frame_method_offset * wordSize;
53 const int bci_offset    = frame::interpreter_frame_bcx_offset    * wordSize;
54 const int locals_offset = frame::interpreter_frame_locals_offset * wordSize;
61   // Note: There should be a minimal interpreter frame set up when stack
67                 frame::interpreter_frame_monitor_block_top_offset * wordSize));
70     __ jcc(Assembler::aboveEqual, L); // check if frame is complete
71     __ stop ("interpreter frame not set up");
75   // Restore bcp under the assumption that the current frame is still
146   __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);
189   __ movptr(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize));
191   __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);
241   __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);
314       // retrieve result from frame
315       __ movptr(rax, Address(rbp, frame::interpreter_frame_oop_temp_offset*wordSize));
411   // rbp, - interpreter frame
415   // rbp - interpreter frame pointer
438   // Preserve invariant that rsi/rdi contain bcp/locals of sender frame
452   // rdx: number of additional locals this frame needs (what we must check)
463   const int entry_size    = frame::interpreter_frame_monitor_size() * wordSize;
467   const int overhead_size = -(frame::interpreter_frame_initial_sp_offset*wordSize) + entry_size;
473   // see if the frame is greater than one page in size. If so,
479   // compute rsp as if this were going to be the last frame on
526   // frame is an extended compiled frame (see gen_c2i_adapter())
533   // Note: the restored frame is not necessarily interpreted.
537   // all done with frame size check
550   const Address monitor_block_top (rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
551   const int entry_size            = frame::interpreter_frame_monitor_size() * wordSize;
584 // Generate a fixed interpreter frame. This is identical setup for interpreted methods
588   // initialize fixed part of activation frame
859 // than the typical interpreter frame setup.
901   // initialize fixed part of activation frame
972                  frame::interpreter_frame_monitor_block_top_offset * wordSize);
976     __ stop("broken stack frame setup in interpreter");
1022   __ movptr(Address(rbp, frame::interpreter_frame_result_handler_offset*wordSize), rax);
1035     // copy mirror into activation frame
1036     __ movptr(Address(rbp, frame::interpreter_frame_oop_temp_offset * wordSize), t);
1038     __ lea(t, Address(rbp, frame::interpreter_frame_oop_temp_offset * wordSize));
1092   // NOTE: the order of theses push(es) is known to frame::interpreter_frame_result.
1100     __ cmpptr(Address(rbp, (frame::interpreter_frame_oop_temp_offset + 1)*wordSize),
1103     __ cmpptr(Address(rbp, (frame::interpreter_frame_oop_temp_offset + 1)*wordSize),
1171   // If result was an oop then unbox and save it in the frame
1175     __ cmpptr(Address(rbp, frame::interpreter_frame_result_handler_offset*wordSize),
1185     __ movptr(Address(rbp, (frame::interpreter_frame_oop_temp_offset)*wordSize), rax);
1203   // restore rsi to have legal interpreter frame,
1232       const Address monitor(rbp, frame::interpreter_frame_initial_sp_offset * wordSize - (int)sizeof(BasicObjectLock));
1259   __ movptr(t, Address(rbp, frame::interpreter_frame_result_handler_offset*wordSize));
1263   __ movptr(t, Address(rbp, frame::interpreter_frame_sender_sp_offset * wordSize)); // get sender sp
1264   __ leave();                                // remove frame anchor
1330   // initialize fixed part of activation frame
1405                  frame::interpreter_frame_monitor_block_top_offset * wordSize);
1409     __ stop("broken stack frame setup in interpreter");
1443 // frame layout they create is very similar. The other method entry
1551                                 1*frame::interpreter_frame_monitor_size() : 0;
1555   const int overhead_size = -frame::interpreter_frame_initial_sp_offset;
1572                                            frame* caller,
1573                                            frame* interpreter_frame,
1576   // Note: This calculation must exactly parallel the frame setup
1579   // The frame interpreter_frame, if not NULL, is guaranteed to be the right size,
1584   // fixed size of an interpreter frame:
1589   int overhead = frame::sender_sp_offset - frame::interpreter_frame_initial_sp_offset;
1598          (moncount*frame::interpreter_frame_monitor_size()) +
1618       assert(locals < caller->fp() + frame::interpreter_frame_initial_sp_offset, "bad placement");
1633     // All frames but the initial (oldest) interpreter frame we fill in have a
1658   __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);
1682   // If the exception is not handled in the current frame the frame is removed and
1709     // Check to see whether we are returning to a deoptimized frame.
1710     // (The PopFrame call ensures that the caller of the popped frame is
1712     // In this case, we can't call dispatch_next() after the frame is
1720     __ movptr(rdx, Address(rbp, frame::return_addr_offset * wordSize));
1761   // constraints basically require this frame to look exactly as
1769   __ movptr(rbx, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize));
1777   __ movptr(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize));
1778   __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);