Lines Matching refs:stack
71 flags_off = xmm7_off + 16/BytesPerInt + 1, // 16-byte stack alignment fill word
133 assert(FPUStateSizeInWords == 27, "update stack layout");
136 // We assume caller has already has return address slot on the stack
163 // since fstp_d can cause FPU stack underflow exceptions. Write it
164 // into the on stack copy and then reload that to make sure that the
357 // Pop all of the register save are off the stack except the return address
368 // The java_calling_convention describes stack locations as ideal slots on
386 // refer to 4-byte stack slots. All stack slots are based off of the stack pointer
413 uint stack = 0; // Starting stack position for args on stack
425 // call sites by storing to the stack in any case.
434 // Pass doubles & longs aligned on the stack. First count stack slots for doubles
441 else // Else double is passed low on the stack to be aligned.
442 stack += 2;
444 stack += 2;
468 regs[i].set1(VMRegImpl::stack2reg(stack++));
479 regs[i].set1(VMRegImpl::stack2reg(stack++));
506 // return value can be odd number of VMRegImpl stack slots make multiple of 2
507 return round_to(stack, 2);
534 // C2 may leave the stack dirty if not in SSE2+ mode
536 __ verify_FPU(0, "c2i transition should have clean FPU stack");
588 // C2 may leave the stack dirty if not in SSE2+ mode
590 __ verify_FPU(0, "c2i transition should have clean FPU stack");
596 // Since all args are passed on the stack, total_args_passed * interpreter_
616 // st_off points to lowest address on stack.
634 // memory to memory use fpu stack top
727 // to perform additional cleanup work, such as correcting the stack pointer.
729 // routinely repairs its own stack pointer (from interpreter_frame_last_sp),
730 // even if a callee has modified the stack pointer.
732 // routinely repairs its caller's stack pointer (from sender_sp, which is set
735 // get the stack pointer repaired after a call.
739 // clean up the stack pointer changes performed by the two adapters.
741 // caller, but with an uncorrected stack, causing delayed havoc.
777 // Cut-out for having no stack args. Since up to 2 int/oop args are passed
778 // in registers, we will occasionally have no stack args.
781 // Sig words on the stack are greater-than VMRegImpl::stack0. Those in
783 // number (all values in registers) or the maximum stack slot accessed.
785 // Convert 4-byte stack slots to words.
787 // Round up to miminum stack alignment, in wordSize
795 // push the return address on the stack (note that pushing, rather
809 // rest through the floating point stack top.
836 // Convert stack slot to an SP offset (+ wordSize to account for return address )
911 // invisible to the stack walking code. Unfortunately if
943 // require some stack space. We grow the current (compiled) stack, then repack
987 // We return the amount of VMRegImpl stack slots we need to reserve for all
990 uint stack = 0; // All arguments on stack
1004 regs[i].set1(VMRegImpl::stack2reg(stack++));
1007 case T_DOUBLE: // The stack numbering is reversed from Java
1009 // doubles on the stack must be opposite the Java convention
1011 regs[i].set2(VMRegImpl::stack2reg(stack));
1012 stack += 2;
1020 return stack;
1027 // stack to stack
1033 // stack to reg
1037 // reg to stack
1058 // register or a stack location. dst can only be a stack location.
1060 assert(dst.first()->is_stack(), "must be stack");
1064 // Oop is already on the stack as an argument
1081 // on the stack for oop_handles
1106 // Because of the calling convention we know that src is either a stack location
1107 // or an xmm register. dst can only be a stack location.
1115 // reg to stack
1124 // 1: two stack slots (possibly unaligned)
1129 assert(src.second()->is_stack() && dst.second()->is_stack(), "must be all stack");
1147 // 2: two stack slots (possibly unaligned)
1148 // dst can only be a pair of stack slots.
1153 // source is all stack
1159 // reg to stack
1160 // No worries about stack alignment
1260 // Value is in an input register pass we must flush it to the stack
1389 // Load the arg up from the stack
1476 // platform, pick a temp and load the receiver from stack.
1629 // Now figure out where the args must be stored and how much stack space
1637 // Calculate the total number of stack slots we will need.
1730 // arguments off of the stack after the jni call. Before the call we can use
1732 // relative instructions instead of re-adjusting the stack on windows.
1736 // Now compute actual number of stack words we need rounding to make
1737 // stack properly aligned.
1803 // because it can be patched on the fly by make_non_entrant. The stack bang
1806 // Generate stack overflow check
1832 // C2 may leave the stack dirty if not in SSE2+ mode
1834 __ verify_FPU(0, "c2i transition should have clean FPU stack");
1874 // All of our moved are reg->stack or stack->stack.
1882 // Record rsp-based slot for receiver on stack for non-static methods
1885 // This is a trick. We double the stack slots so we can claim
1897 // Are free to temporaries if we have to do stack to steck moves.
1957 // be pushed on the stack when we do a a stack traversal). It is enough that the pc()
2034 // Test if the oopMark is an obvious stack pointer, i.e.,
2039 // assuming both stack pointer and pagesize have their
2077 // arguments off of the stack. We could just re-adjust the stack pointer here
2214 // get address of the stack lock
2217 // Atomic swap old header if oop still contains the stack lock
2274 // check that only result value is on FPU stack
2368 // SLOW PATH Reguard the stack if needed
2385 // remove possible return value from FPU register stack
2499 // Now figure out where the args must be stored and how much stack space
2505 // Calculate the total number of stack slots we will need.
2545 // Now compute actual number of stack words we need rounding to make
2546 // stack properly aligned.
2582 // because it can be patched on the fly by make_non_entrant. The stack bang
2585 // Generate stack overflow check
2616 // Since the C calling convention is stack based that ensures that
2630 "stack based abi assumed");
2663 "value(s) must go into stack slots");
2809 // Account for the extra args we place on the stack
2817 // address has been pushed on the the stack, and return values are in
2821 // address on the stack is wrong by NativeCall::instruction_size
2823 // address on the stack (like when we eagerly deoptimized).
2825 // with a return address on the stack that points after the call we patched
2831 // the stack looks just like we want.
2887 // tos: stack at point of call to method that threw the exception (i.e. only
2888 // args are on the stack, no return address)
2890 // make room on stack for the return address
2928 // Compiled code leaves the floating point stack dirty, empty it.
2979 // Stack is back to only having register save data on the stack.
2990 // All of the register save area has been popped of the stack. Only the
3000 // Note: by leaving the return address of self-frame on the stack
3001 // and using the size of frame 2 to adjust the stack
3002 // when we are done the return to frame 3 will still be on the stack.
3031 // Now adjust the caller's stack to make up for the extra locals
3033 // frame and the stack walking of interpreter_sender will get the unextended sp
3087 __ fstp_d(Address(rsp, RegisterSaver::fpResultOffset()*wordSize)); // Pop float stack and store in local
3102 // restore return values to their stack-slots with the new SP.
3117 // Clear floating point stack before returning to interpreter
3183 // Clear the floating point exception stack
3251 // Now adjust the caller's stack to make up for the extra locals
3253 // frame and the stack walking of interpreter_sender will get the unextended sp
3307 // restore return values to their stack-slots with the new SP.
3360 // the return address on the stack to the caller on the nmethod
3361 // that is safepoint. We can leave this return on the stack and
3364 // handler will install later to make the stack walking sensible.