Lines Matching refs:stack
55 // while "shadow" interpreter frames are on stack. It is also
144 // tosca based result to c++ interpreter stack based result.
150 // stack. This is relatively simple the destination is in L1_scratch
151 // i.e. L1_scratch is the first free element on the stack. If we "push" a return value we must
221 // Every stack slot is aligned on 64 bit, However is this
222 // the correct stack slot on 64bit?? QQQ
240 // A result is in the java expression stack of the interpreted method that has just
241 // returned. Place this result on the java expression stack of the caller.
245 // execution stack (which is pre-pushed) and will be return to the top of the caller
246 // stack. The top of the callers stack is the bottom of the locals of the current
249 // below both the stack top of the current activation and naturally the stack top
251 // to the frame manager on the stack and do a vanilla return.
253 // On entry: O0 - points to source (callee stack top)
254 // O1 - points to destination (caller stack top [i.e. free location])
275 // return top two words on current expression stack to caller's expression stack
276 // The caller's expression stack is adjacent to the current frame manager's intepretState
304 // A result is in the java expression stack of the interpreted method that has just
310 // and so rather than return result onto caller's java expression stack we return the
312 // On entry: O0 - source (stack top)
335 // return top two words on current expression stack to caller's expression stack
336 // The caller's expression stack is adjacent to the current frame manager's interpretState
577 // This sets up a somewhat different looking stack for calling the native method
630 // generate the code to allocate the interpreter stack frame
735 // Which is the only register we need for a stack walk.
748 // below (and fix I7 so the stack trace doesn't have a meaningless frame
792 // At this point, arguments have been copied off of stack into
794 // Oops are boxed in-place on the stack, with handles copied to arguments.
1047 // a new interpretState object and the method expression stack.
1058 // slop factor is two extra slots on the expression stack so that
1075 __ calc_mem_param_words(Gtmp, Gtmp); // space for native call parameters passed on the stack in words
1077 __ lduh(max_stack, Gtmp); // Full size expression stack
1081 __ neg(Gtmp); // negative space for stack/parameters in words
1085 // Need to do stack size check here before we fault on large frames
1095 // compute stack bottom
1133 // SP (biased) - accounts for full size java stack, BytecodeInterpreter object, register save area, and register parameter save window
1213 __ lduh(max_stack, O3); // Full size expression stack
1281 // monitor is already allocated at stack base
1358 // return to the interpreter's stack
1363 // stack is in the state that the calling convention left it.
1364 // Copy the result from native abi result and place it on java expression stack.
1368 // Get current pre-pushed top of interpreter stack
1372 __ ld_ptr(STATE(_stack), L1_scratch); // get top of java expr stack
1380 // L1_scratch points to top of stack (prepushed)
1389 // 1. compute new pointers // esp: old expression stack top
1390 __ delayed()->ld_ptr(STATE(_stack_base), L4_scratch); // current expression stack bottom
1394 __ sub(SP, entry_size, SP); // Grow stack
1401 __ ld_ptr(STATE(_stack), L1_scratch); // Get current stack top
1407 // 2. move expression stack
1431 // MORE_MONITORS - need a new monitor. Shuffle the expression stack on down and
1440 // ecx: receiver - unused (retrieved from stack as needed)
1450 // [ expression stack ]
1478 // Adjust caller's stack so that all the locals can be contiguous with
1480 // Worries about stack overflow make this a pain.
1558 // We must adjust the caller's stack pointer for any locals beyond just the
1570 // Any stack banging or limit check should already be done.
1592 // Call interpreter (stack bang complete) enter here if message is
1593 // set and we know stack size is valid
1649 // Allocate more monitor space, shuffle expression stack....
1666 __ delayed()->ld_ptr(STATE(_frame_bottom), SP); // restore to full stack frame
1671 // for the template based interpreter). Any stack space that was used by the
1673 // so all that we have to do is place any pending result on the expression stack
1729 // expression stack.
1738 // stack is in the state that the calling convention left it.
1739 // Copy the result from native abi result and place it on java expression stack.
1745 __ ld_ptr(STATE(_frame_bottom), SP); // restore to full stack frame
1751 // Process the native abi result to java expression stack
1754 __ ld_ptr(STATE(_stack), L1_scratch); // get top of java expr stack
1757 __ add(L1_scratch, L2_scratch, L1_scratch); // stack destination for result
1767 // L1_scratch points to top of stack (prepushed)
1773 // Empty the stack and resume interpreter
1777 __ ld_ptr(STATE(_frame_bottom), SP); // restore to full stack frame
1778 __ ld_ptr(STATE(_stack_base), O1); // empty java expression stack
1792 // Interpreted result is on the top of the completed activation expression stack.
1793 // We must return it to the top of the callers stack if caller was interpreted
1795 // The caller's expression stack was truncated by the call however the current activation
1796 // has enough stuff on the stack that we have usable space there no matter what. The
1797 // other thing that makes it easy is that the top of the caller's stack is stored in STATE(_locals)
1807 // Copy result to callers java stack
1812 __ ld_ptr(STATE(_locals), O1); // stack destination
1816 __ delayed()->add(O0, wordSize, O0); // get source (top of current expr stack)
1820 // Result is now on caller's stack. Just unwind current activation and resume
1829 // result converter left O1 pointing to top of the( prepushed) java stack for method we are returning
1832 // Must restore stack
1836 // Result if any is already on the caller's stack. All we must do now is remove the now dead
1840 __ mov(O1, I1); // pass back new stack top across activation
1843 __ ld_ptr(STATE(_frame_bottom), SP); // restore to full stack frame
1849 // O1 == new java stack pointer
1854 // A frame we have already used before so no need to bang stack so use call_interpreter_2 entry
1888 __ delayed()->add(O0, wordSize, O0); // get source (top of current expr stack)
1941 // Call a new method. All we do is (temporarily) trim the expression stack
1945 // of excess java expression stack entries and then recurse.
1949 // stack points to next free location and not top element on expression stack
1958 // we trim back sp by the amount of unused java expression stack
1965 // compute the unused java stack size
1968 // Round down the unused space to that stack is always 16-byte aligned
1973 // Now trim the stack
1987 __ stop("killed stack");
2015 // on the java stack.
2054 // expression stack, the callee will have callee_extra_locals (so we can account for
2059 // The big complicating thing here is that we must ensure that the stack stays properly
2060 // aligned. This would be even uglier if monitor size wasn't modulo what the stack
2065 // stack at all times to deal with the "stack long no_params()" method issue. This
2100 intptr_t* stack,
2116 to_fill->_stack = stack;
2157 // Need +1 here because stack_base points to the word just above the first expr stack entry
2158 // and stack_limit is supposed to point to the word just below the last expr stack entry.
2179 int tempcount, // Number of slots on java expression stack in use
2198 // NOTE: tempcount is the current size of the java expression stack. For top most
2199 // frames we will allocate a full sized expression stack and not the curback
2238 // stack alignment (same as ia64). The problem is that we can
2240 // for the extra locals but it also accounts for aligning the stack
2250 // stack() is prepushed.
2251 locals = prev->stack() + method->size_of_parameters();
2272 /* +1 because stack is always prepushed */
2273 intptr_t* stack = stack_base - (tempcount + 1);
2281 stack,