Lines Matching refs:to
16 * 2 along with this work; if not, write to the Free Software Foundation,
54 // Routine exists to make tracebacks look decent in debugger
68 Label fast_accessor_slow_entry_path; // fast accessor methods need to be able to jmp to unsynchronized
113 // This only works for pc that might possibly be exposed to frame
131 case T_INT : /* nothing to do */ break;
173 // tosca based result to c++ interpreter stack based result.
174 // Result goes to top of native stack.
251 // execution stack (which is pre-pushed) and will be return to the top of the caller
256 // of the calling activation. This enable this routine to leave the return address
257 // to the frame manager on the stack and do a vanilla return.
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
317 // Similar to generate_stack_to_stack_converter above. Called at a similar time from the
401 // On entry the "locals" argument points to locals[0] (or where it would be in case no locals in
403 // to in the newly generated state object. On return "state" is a pointer to the newly allocated
407 // be sure to leave space on the caller's stack so that this result will not overwrite values when
434 // just to be safe. This is the "static long no_params() method" issue.
462 // recursive. Simpler to recurse but we can't trim expression stack as we call
465 __ movptr(STATE(_self_link), state); // point to self
494 __ movptr(STATE(_monitor_base), rsp); // set monitor block bottom (grows down) this would point to entry [0]
498 // Must not attempt to lock method until we enter interpreter as gc won't be able to find the
499 // initial frame. However we allocate a free monitor so we don't have to shuffle the expression stack
605 // On return (i.e. jump to entry_point) [ back to invocation of interpreter ]
661 // be sure to change this if you add/subtract anything to/from the overhead area
668 // compute rsp as if this were going to be the last frame on
686 // Always give one monitor to allow us to start interp if sync method.
708 // Add stack base to locals and subtract stack size
744 // assumes state == rsi/r13 == pointer to current interpreterState
755 __ subptr(monitor, entry_size); // point to initial monitor
770 __ movptr(rdi, STATE(_locals)); // prepare to get receiver (assume common case)
798 // rsi/r13: senderSP must preserved for slow path, set SP to it on fast path
831 // Shift codes right to get the index on the right.
871 // Need to differentiate between igetfield, agetfield, bgetfield etc.
875 // Make sure we don't need to mask rdx after the above shift
923 __ mov(rsp, sender_sp_on_entry); // set sp to sender sp
929 // called by the call_stub this will cause it to return
930 // a tosca result to the invoker which might have been
945 // We need to generate have a routine that generates code to:
947 // * passes that value to the pre-barrier.
951 // This will cause concurrent marking to mark the referent
957 // If G1 is not enabled then attempt to go through the accessor entry point
965 // than the typical interpreter frame setup but still has the pointer to
976 // in any case. If called via c1/c2/call_stub rsi/r13 is junk (to use) but harmless
977 // to save/restore.
1036 // would try to exit the monitor of synchronized methods which hasn't
1038 // _do_not_unlock_if_synchronized to true. The remove_activation will
1052 __ stop("tried to execute non-native method as native");
1058 __ stop("tried to execute abstract method in interpreter");
1123 __ andptr(rsp, -(StackAlignmentInBytes)); // gcc needs 16 byte aligned stacks to do XMM intrinsics
1156 assert(InterpreterRuntime::SignatureHandlerGenerator::to () == rsp, "adjust this code");
1197 // pass handle to mirror
1252 // Change state to native (we save the return address in the thread, since it might not
1254 // points into the right code segment. It does not have to be the correct return pc.
1271 // It is safe to do these pushes because state is _thread_in_native and return address will be found
1274 // Must save the value of ST(0)/xmm0 since it could be destroyed before we get to result handler
1305 // We use the current thread pointer to calculate a thread specific
1306 // offset to write to within the page. This minimizes bus traffic
1307 // due to cache line collision.
1317 // threads running native code and they are expected to self-suspend
1318 // when leaving the _thread_in_native state. We need to check for
1328 // Also can't use call_VM_leaf either as it will check to see if rsi & rdi are
1329 // preserved and correspond to the bcp/locals pointers.
1392 // Seems that the answer to above is no this is wrong. The old code would see the exception
1394 // This seems wrong need to investigate the spec.
1404 // seems wrong but seems to be what asm interpreter did. Can't find this in the spec.
1414 __ mov(rsp, t); // set sp to sender sp
1416 // The skips unlocking!! This seems to be what asm interpreter does but seems
1431 // to check that the object has not been unlocked by an explicit monitorexit bytecode.
1439 // Entry already unlocked, need to throw exception
1458 // restore potential result in rdx:rax, call result handler to restore potential result in ST0 & handle result
1464 __ call(t); // call result handler to convert to tosca form
1473 __ mov(rsp, t); // set sp to sender sp
1492 // deopt needs to jump to here to enter the interpreter (return a result)
1500 // deopt needs to jump to here to enter the interpreter (return a result)
1507 // deopt needs to jump to here to enter the interpreter (return a result)
1514 // deopt needs to jump to here to enter the interpreter (return a result)
1521 // deopt needs to jump to here to enter the interpreter (return a result)
1528 // deopt needs to jump to here to enter the interpreter (return a result)
1535 // deopt needs to jump to here to enter the interpreter (return a result)
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
1571 __ movptr(rsp, STATE(_stack_limit)); // restore expression stack to full depth
1574 // Generate the code to handle a more_monitors message from the c++ interpreter
1593 __ addptr(rcx, wordSize); // advance to next word
1603 // Initial entry to C++ interpreter from the call_stub.
1608 // from the interpreter and examining the message the interpreter has returned to
1614 // CALL_METHOD - setup a new activation to call a new method. Very similar to what
1616 // RETURN_FROM_METHOD - remove an activation. Return to interpreter or call stub.
1634 // We are free to blow any registers we like because the call_stub which brought us here
1654 // the code is pretty much ready. Would need to change the test below and for good measure
1655 // modify generate_interpreter_state to only do the (pre) sync stuff stuff for synchronized
1707 // leave for now to verify that check is proper.
1756 // leave for now to verify that check is proper.
1773 __ push(state); // push arg to interpreter
1778 // as we are thread_in_Java and no safepoints can occur until we go to
1779 // vm mode. We do have to clear flags on return from vm but that is it
1790 NOT_LP64(__ pop(rax);) // discard parameter to run
1801 // examine msg from interpreter to determine next action
1828 // uncommon trap needs to jump to here to enter the interpreter (re-execute current bytecode)
1833 __ movptr(rsp, STATE(_stack_limit)); // restore expression stack to full depth
1843 // so all that we have to do is place any pending result on the expression stack
1851 // Current frame has caught an exception we need to dispatch to the
1883 // We drop thru to unwind a native interpreted frame with a pending exception
1885 // We unwind the current acivation and forward it to our caller.
1889 // unwind rbp, return stack to unextended value and re-push return address
1942 // Return point to interpreter from compiled/native method
1956 // restore stack to what we had when we left (in case i2c extended it)
1961 // If there is a pending exception then we don't really have a result to process
1986 // An exception is being caught on return to a vanilla interpreter frame.
1995 // Return from interpreted method we return result appropriate to the caller (i.e. "recursive"
2006 __ jcc(Assembler::equal, return_to_initial_caller); // back to native code (call_stub/c1/c2)
2008 // Copy result to callers java stack
2019 // returning to interpreter method from "recursive" interpreter call
2020 // result converter left rax pointing to top of the java stack for method we are returning
2021 // to. Now all we must do is unwind the state from the completed call
2025 __ mov(rsp, rax); // unwind stack to remove args
2039 __ movptr(rsp, STATE(_stack_limit)); // restore expression stack to full depth
2040 __ jmp(call_interpreter_2); // No need to bang
2042 // interpreter returning to native code (call_stub/c1/c2)
2062 [ return address to CALL_STUB/C1/C2]
2070 // return restoring the stack to the original sender_sp value
2075 // set stack to sender's sp
2077 __ jmp(rdi); // return to call_stub
2079 // OSR request, adjust return address to make current frame into adapter frame
2086 // We are going to pop this frame. Is there another interpreter frame underneath
2089 // Move buffer to the expected parameter location
2095 __ jcc(Assembler::equal, remove_initial_frame); // back to native code (call_stub/c1/c2)
2117 // set stack to sender's sp
2128 // push a return address to bring us back to here and leap to the new entry.
2132 // stack points to next free location and not top element on expression stack
2133 // method expects sp to be pointing to topmost element
2135 __ movptr(rsp, STATE(_stack)); // pop args to c++ interpreter, set sp to java stack top
2138 __ movptr(rbx, STATE(_result._to_call._callee)); // get method to execute
2151 __ cmpptr(STATE(_result._to_call._callee_entry_point), entry.addr()); // returning to interpreter?
2174 // Pass result, unwind activation and continue/return to interpreter/call_stub
2175 // We handle result (if any) differently based on return to interpreter or call_stub
2181 __ jcc(Assembler::equal, unwind_initial_with_pending_exception); // no, back to native code (call_stub/c1/c2)
2189 // the exception to the caller. We must put the exception in the
2242 // Save space for one monitor to get into the interpreted method in case
2296 to_fill->_result._to_call._callee_entry_point = NULL; // doesn't matter to anyone
2297 to_fill->_result._to_call._callee = NULL; // doesn't matter to anyone
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.
2344 // The frame interpreter_frame, if not NULL, is guaranteed to be the right size,
2345 // as determined by a previous call to this method.
2346 // It is also guaranteed to be walkable even though it is in a skeletal state
2355 // NOTE: ia64 seems to do this wrong (or at least backwards) in that it
2357 // to it. So it ignores last_frame_adjust value. Seems suspicious as far
2394 // confusing rounding at the callee to account for. We can trivially locate
2400 // If the caller is interpreted we need to make sure that locals points to the first
2402 // because the stack to stack to converter needs a proper locals value in order to remove the
2408 // locals must agree with the caller because it will be used to set the