Lines Matching refs:stack

139         // mode, results are returned in xmm0 and the FPU stack must
145 // Store as float and empty fpu stack
173 // tosca based result to c++ interpreter stack based result.
174 // Result goes to top of native stack.
179 // code. Place this result on the java expression stack so C++ interpreter can use it.
246 // A result is in the java expression stack of the interpreted method that has just
247 // returned. Place this result on the java expression stack of the caller.
251 // execution stack (which is pre-pushed) and will be return to the top of the caller
252 // stack. The top of the callers stack is the bottom of the locals of the current
255 // below both the stack top of the current activation and naturally the stack top
257 // to the frame manager on the stack and do a vanilla return.
261 // rax - new stack top for caller activation (i.e. activation in _prev_link)
270 __ movptr(rax, STATE(_locals)); // pop parameters get new stack value
287 // return top two words on current expression stack to caller's expression stack
288 // The caller's expression stack is adjacent to the current frame manager's intepretState
314 // A result is in the java expression stack of the interpreted method that has just
319 // and so rather than return result onto caller's java expression stack we return the
334 __ movptr(rdx, STATE(_stack)); // get top of stack
338 __ movptr(rdx, STATE(_stack)); // get top of stack
343 __ movptr(rdx, STATE(_stack)); // get top of stack
351 __ movptr(rdx, STATE(_stack)); // get top of stack
359 __ movptr(rdx, STATE(_stack)); // get top of stack
405 // expression stack. Because the returned result (if any) of the method will be placed on the caller's
406 // expression stack and this will overlap with locals[0] (and locals[1] if double/long) we must
407 // be sure to leave space on the caller's stack so that this result will not overwrite values when
422 // rsp == bottom of method's expression stack.
429 // caller returns a long then we need two words on the sender's stack which
430 // are not present (although when we return a restore full size stack the
432 // we "push" the result of the caller's stack we would overwrite the return
437 // register and the stack is expanded in the caller before we store
438 // the results on the stack.
449 // Now that we are assure of space for stack result, setup typical linkage
462 // recursive. Simpler to recurse but we can't trim expression stack as we call
499 // initial frame. However we allocate a free monitor so we don't have to shuffle the expression stack
531 __ movptr(STATE(_stack_base), rsp); // set expression stack base ( == &monitors[-count])
533 __ movptr(STATE(_stack), rsp); // set current expression stack tos
536 __ subptr(rsp, wordSize); // pre-push stack
537 __ movptr(STATE(_stack), rsp); // set current expression stack tos
539 // compute full expression stack limit
543 __ load_unsigned_short(rdx, size_of_stack); // get size of expression stack in words
545 // Allocate expression stack
551 // Make sure stack is properly aligned and sized for the abi
608 // top of stack return address of interpreter caller
633 // see if we've got enough room on the stack for locals plus overhead.
634 // the expression stack grows down incrementally, so the normal guard
657 // monitor entry size: see picture of stack set (generate_method_entry) and frame_i486.hpp
660 // total overhead size: entry_size + (saved rbp, thru expr stack bottom).
669 // the stack before the red zone
687 // Any additional monitors need a check when moving the expression stack
690 __ load_unsigned_short(rax, size_of_stack); // get size of expression stack in words
696 // verify that thread stack base is non-zero
699 __ stop("stack base is zero");
701 // verify that thread stack size is non-zero
704 __ stop("stack size is zero");
708 // Add stack base to locals and subtract stack size
720 // Only need this if we are stack banging which is temporary while
724 // check against the current stack bottom
964 // This sets up a somewhat different looking stack for calling the native method
1003 // allocate and initialize new interpreterState and method expression stack
1008 // OUT(rsp) -> bottom of methods expression stack
1026 __ stop("broken stack frame setup in interpreter");
1253 // be pushed on the stack when we do a a stack traversal). It is enough that the pc()
1368 // keep stack depth as expected by pushing oop which will eventually be discarded
1402 // There are potential results on the stack (rax/rdx, ST(0)) we ignore these and simply
1542 // return to the interpreter's stack
1545 // activation the stack is pushed too deep to share the tosca to
1546 // stack converters directly. We shrink the stack to the desired
1547 // amount and then push result and then re-extend the stack.
1558 __ movptr(rsp, STATE(_stack)); // trim stack (is prepushed)
1568 __ lea(rsp, Address(rsp, -wordSize)); // prepush stack (result if any already present)
1569 __ movptr(STATE(_stack), rsp); // inform interpreter of new stack depth (parameters removed,
1570 // result if any on stack already )
1571 __ movptr(rsp, STATE(_stack_limit)); // restore expression stack to full depth
1580 // 1. compute new pointers // rsp: old expression stack top
1581 __ movptr(rdx, STATE(_stack_base)); // rdx: old expression stack bottom
1582 __ subptr(rsp, entry_size); // move expression stack top limit
1583 __ subptr(STATE(_stack), entry_size); // update interpreter stack top
1585 __ subptr(rdx, entry_size); // move expression stack bottom
1589 // 2. move expression stack contents
1591 __ movptr(rbx, Address(rcx, entry_size)); // load expression stack word from old location
1612 // MORE_MONITORS - need a new monitor. Shuffle the expression stack on down and
1621 // rcx: receiver - unused (retrieved from stack as needed)
1631 // [ expression stack ]
1703 // see if we've got enough room on the stack for locals plus overhead.
1706 // c++ interpreter does not use stack banging or any implicit exceptions
1741 // allocate and initialize new interpreterState and method expression stack
1746 // OUT(rsp) -> bottom of methods expression stack
1755 // c++ interpreter does not use stack banging or any implicit exceptions
1761 // set and we know stack size is valid
1822 // Allocate more monitor space, shuffle expression stack....
1833 __ movptr(rsp, STATE(_stack_limit)); // restore expression stack to full depth
1841 // for the template based interpreter). Any stack space that was used by the
1843 // so all that we have to do is place any pending result on the expression stack
1889 // unwind rbp, return stack to unextended value and re-push return address
1900 // expression stack.
1909 // The FPU stack is clean if UseSSE >= 2 but must be cleaned in other cases
1948 // Result if any is in tosca. The java expression stack is in the state that the
1950 // Copy the result from tosca and place it on java expression stack.
1956 // restore stack to what we had when we left (in case i2c extended it)
1974 // callee left args on top of expression stack, remove them
1987 // Empty the stack and resume interpreter
1991 // Exception present, empty stack
2008 // Copy result to callers java stack
2020 // result converter left rax pointing to top of the java stack for method we are returning
2025 __ mov(rsp, rax); // unwind stack to remove args
2036 __ lea(rsp, Address(rsp, -wordSize)); // prepush stack (result if any already present)
2037 __ movptr(STATE(_stack), rsp); // inform interpreter of new stack depth (parameters removed,
2038 // result if any on stack already )
2039 __ movptr(rsp, STATE(_stack_limit)); // restore expression stack to full depth
2058 /* Current stack picture
2065 expression stack
2070 // return restoring the stack to the original sender_sp value
2075 // set stack to sender's sp
2099 __ mov(rsp, sender_sp_on_entry); // trim any stack expansion
2105 // on the java stack.
2117 // set stack to sender's sp
2127 // Call a new method. All we do is (temporarily) trim the expression stack
2132 // stack points to next free location and not top element on expression stack
2135 __ movptr(rsp, STATE(_stack)); // pop args to c++ interpreter, set sp to java stack top
2164 // on the java stack.
2182 __ movptr(rax, STATE(_locals)); // pop parameters get new stack value
2238 // How much stack a method activation needs in words.
2273 intptr_t* stack,
2289 to_fill->_stack = stack;
2316 // Need +1 here because stack_base points to the word just above the first expr stack entry
2317 // and stack_limit is supposed to point to the word just below the last expr stack entry.
2324 assert(stack >= to_fill->_stack_limit && stack < to_fill->_stack_base,
2348 // NOTE: tempcount is the current size of the java expression stack. For top most
2349 // frames we will allocate a full sized expression stack and not the curback
2363 // First calculate the frame size without any java expression stack
2367 // Now with full size expression stack
2371 // and now with only live portion of the expression stack
2401 // argument that the caller passed and not in an area where the stack might have been extended.
2402 // because the stack to stack to converter needs a proper locals value in order to remove the
2405 // adjust the stack?? HMMM QQQ
2411 // stack() is prepushed.
2412 locals = prev->stack() + method->size_of_parameters();
2424 /* +1 because stack is always prepushed */
2425 intptr_t* stack = (intptr_t*) ((intptr_t) stack_base - (tempcount + 1) * BytesPerWord);
2433 stack,