Lines Matching defs:to
16 * 2 along with this work; if not, write to the Free Software Foundation,
56 // cut the heads off of the registers. We have to do a very extensive
57 // stack dance to save and restore these properly.
63 // Lots of registers to save. For all builds, a window save will preserve
66 // we need to save the 64-bit %o registers which requires we save them
68 // heads chopped off on interrupt). We have to save some %g registers here
105 // During deoptimization only the result register need to be restored
113 // propagated to the caller frame's RegisterMap during StackFrameStream construction (needed for
142 // to Oregs here to avoid interrupts cutting off their heads
212 // Save all the FP registers: 32 doubles (32 floats correspond to the 2 halves of the first 16 doubles)
299 // and save to TLS
344 // arguments should go. Values in the VMRegPair regs array refer to 4-byte (VMRegImpl::stack_slot_size)
346 // refer to 4-byte stack slots. All stack slots are based off of the window
347 // top. VMRegImpl::stack0 refers to the first slot past the 16-word window,
348 // and VMRegImpl::stack0+1 refers to the memory word 4-byes higher. Register
349 // values 0-63 (up to RegisterImpl::number_of_registers) are the 64-bit
356 // convert to incoming arguments, convert all O's to I's. The regs array
357 // refer to the low and hi 32-bit words of 64-bit registers or stack slots.
358 // If the regs[].second() field is set to VMRegImpl::Bad(), it means it's unused (a
432 // On 32-bit SPARC put longs always on the stack to keep the pressure off
477 // Helper class mostly to avoid passing masm everywhere, and handle
486 // base+st_off points to top of argument
497 // Stores long into offset pointed to by base
526 // Patch the callers callsite with entry to compiled code if it exists.
532 // Call into the VM to patch the caller, then jump to compiled callee
537 // G2: global allocated to TLS
542 // The longs must go to the stack by hand since in the 32 bit build they can be trashed by window ops.
592 // Stores long into offset pointed to by base
629 // Stores into offset pointed to by base
637 // Need to marshal 64-bit value from misaligned Lesp loads
657 // at all. We've come from compiled code and are attempting to jump to the
658 // interpreter, which means the caller made a static call to get here
660 // compiled target. If there is one, we need to patch the caller's call.
665 // we can have at most one and don't need to play any tricks to keep
669 // ought to be able to reset the world back to the state of the interpreted
679 // to stack alignment.
735 // Pass O5_savedSP as an argument to the interpreter.
736 // The interpreter will restore SP to this value before returning.
741 // Jump to the interpreter just as if interpreter was doing it.
771 // Generate an I2C adapter: adjust the I-frame to make space for the C-frame
775 // hoist register arguments and repack other args according to the compiled
776 // code convention. Finally, end in a jump to the compiled code. The entry
787 // to perform additional cleanup work, such as correcting the stack pointer.
797 // In particular, if a c2i adapter were to somehow call an i2c adapter,
800 // If this happens, control eventually transfers back to the compiled
808 // "i2c adapter must return to an interpreter frame");
823 const char* msg = "i2c adapter must return to an interpreter frame";
831 // of temp registers to work with: mostly G1, G3 & G4.
836 // G4 (Gargs) - Pointer to interpreter's args
838 // O5_savedSP - Caller's saved SP, to be restored if needed
878 // temps to do the shuffle. We hope for (and optimize for) the case where
879 // temps are not needed. We may have to resize the stack slightly, in case
903 // Cut-out for having no stack args. Since up to 6 args are passed
906 // Convert VMReg stack slots to words.
908 // Round up to miminum stack alignment, in wordSize
910 // Now compute the distance from Lesp to SP. This calculation does not
967 // are passed on the stack, but need a stack-to-stack move through a
973 // Need to marshal 64-bit value from misaligned Lesp loads
979 // Was the argument really intended to be on the stack, but was loaded
983 // Convert stack slot to an SP offset
992 // Jump to the compiled code just as if compiled code was doing it.
997 // happens we don't want to take a safepoint because the
999 // "compiled" so it is much better to make this transition
1000 // invisible to the stack walking code. Unfortunately if
1039 // args start out packed in the compiled layout. They need to be unpacked
1042 // finally end in a jump to the generic interpreter entry point. On exit
1069 // Method might have been compiled since the call site was patched to
1096 // the calling convention to return an VMReg for a stack slot
1099 // the area allocated by the C abi to store down integer arguments
1102 // to bias the optoregs (which impacts VMRegs) when actually referencing any actual stack
1104 // to make up for the fact that the out_preserve_stack_slots is
1109 // to take a parameter to say whether it was C or java calling conventions.
1134 // We return the amount of VMReg stack slots we need to reserve for all
1136 // have space for storing at least 6 registers to memory we start with that.
1142 // Hoist any int/ptr/long's in the first 6 to int regs.
1267 // frame and then jump to forward_exception_entry; O7 will contain the
1279 // stack to stack
1283 // stack to reg
1287 // reg to stack
1294 // On 64 bit we will store integer like items to the stack as
1301 // stack to stack
1305 // stack to reg
1309 // reg to stack
1320 // stack to stack
1324 // stack to reg
1328 // reg to stack
1368 // Oop is in an input register pass we must flush it to the stack
1395 // A float arg may have to do float reg int reg conversion
1401 // stack to stack the easiest of the bunch
1405 // stack to reg
1413 // reg to stack
1420 // reg to reg
1463 // Move msw to lsw
1494 // msw is stack move to L5
1495 // lsw is stack move to dst.lo (real reg)
1532 // stack to stack the easiest of the bunch
1533 // ought to be a way to do this where if alignment is ok we use ldd/std when possible
1539 // stack to reg
1563 // reg to stack
1574 // fpr to stack
1589 // reg to reg
1597 // ought to be able to do a single store
1600 // ought to be able to do a single load
1606 // ought to be able to do a single store
1608 // ought to be able to do a single load
1633 // Don't use save_thread because it smashes G2 and we merely want to save a
1729 // runtime to halt for a GC
1775 // Unpack an array argument into a pointer to the body and the length
1839 member_reg = G5_method; // known to be free at this point
1872 receiver_reg = G3_scratch; // known to be free at this point
1882 // Figure out which address we are really jumping to:
1889 // in the Java compiled code convention, marshals them to the native
1890 // convention (handlizes oops, etc), transitions to native, makes the call,
1891 // returns to java state (possibly blocking), unhandlizes any result and
1896 // functions. The wrapper is expected to unpack the arguments before
1897 // passing them to the callee and perform checks before and after the
1898 // native call to ensure that they GC_locker
1902 // to be thrown.
1907 // tranistion to thread_in_native
1913 // transition back to thread_in_Java
1914 // return to caller
1959 // First thing make an ic check to see if we should even be here
1987 Register mask = G1; // to get hash field from header
1989 // Read the header and build a mask to get its hash field. Give up if the object is not unlocked.
1998 // Check if biased and fall through to runtime if so
2024 // on entry to the wrapper. We need to convert these args to where
2026 // we convert the java signature to a C signature by inserting
2040 // These have to be saved and restored across the safepoint
2104 // Critical natives may have to call out so they need a save area
2117 case T_INT: assert(reg->is_in(), "don't need to save these"); break;
2132 // Compute framesize for the wrapper. We need to handlize all oops in
2139 // us to simply record the base and use the Ireg number to decide which
2140 // slot to use. (Note that the reg number is the inbound number not the
2142 // We must shuffle args to match the native convention, and include var-args space.
2175 // Now a place to save return value or as a temporary for any gpr -> fpr moves
2203 // Now compute actual number of stack words we need rounding to make
2225 // We immediately shuffle the arguments so that any vm call we have to
2238 // vectors we have in our possession. We simply walk the java vector to
2239 // get the source locations and the c vector to get the destinations.
2241 // disjoint ( I0 -> O1, I1 -> O2, ...) we have nothing to worry about
2245 // the oops in the caller's frame. Since we are sure to have
2246 // more args than the caller doubling is enough to make
2255 // destination will always be to a register with a greater or equal register
2360 // O7 now has the pc loaded that we will use when we finally call to native.
2364 // want to save a copy
2402 // If we ever need to go to the VM (for locking, jvmti) then
2420 // making the box point to itself will make it clear it went unused
2433 // None of the above fast optimizations worked so we have to get into the
2462 // Finally just about ready to make the JNI call
2475 // get JNIEnv* which is first argument to native
2487 // Transition from _thread_in_Java to _thread_in_native.
2506 case T_VOID: break; // Nothing to do!
2533 // In order for GC to work, don't clear the last_Java_sp until after blocking.
2537 // Switch thread to "native transition" state before reading the synchronization state.
2541 // VM thread changes sync state to synchronizing and suspends threads for GC.
2542 // Thread A is resumed to finish this native method, but doesn't block here since it
2552 // We use the current thread pointer to calculate a thread specific
2553 // offset to write to within the page. This minimizes bus traffic
2554 // due to cache line collision.
2569 // use a leaf call to leave the last_Java_frame setup undisturbed. Doing this
2588 // The call above performed the transition to thread_in_Java so
2598 // happened so we can now change state to _thread_in_Java.
2625 // Get locked oop from the handle we passed to jni
2663 // check_forward_pending_exception jump to forward_exception if any pending
2664 // exception is set. The forward_exception routine expects to see the
2666 // since all folks who branch to forward_exception must have tested
2746 // in the Java compiled code convention, marshals them to the native
2747 // abi and then leaves nops at the position you would expect to call a native
2750 // to dtrace.
2752 // The probes are only able to take primitive types and java/lang/String as
2753 // arguments. No other java types are allowed. Strings are converted to utf8
2754 // strings so that from dtrace point of view java strings are converted to C
2766 // generate_dtrace_nmethod is guarded by a mutex so we are sure to
2776 // The signature we are going to use for the trap that dtrace will see
2778 // is converted to NULL. (A one-slot java/lang/Long object reference
2779 // is converted to a two-slot long, which is why we double the allocation).
2788 // Skip the receiver as dtrace doesn't want to see it
2820 // We convert double to long
2824 // We convert float to int
2837 // on entry to the wrapper. We need to convert these args to where
2839 // where they go we convert the java signature to a C signature and remove
2892 // Now compute actual number of stack words we need rounding to make
2900 // First thing make an ic check to see if we should even be here
2983 // need to unbox a one-slot value
3022 // If tmp wasn't final destination copy to final destination
3033 ++c_arg; // move over the T_VOID to keep the loop indices in sync
3066 // Convert the arg to NULL
3082 // Stack to stack/reg is simple
3126 // Stack to stack/reg is simple
3132 // we can't load direct to the destination.
3196 // If we have any strings we must store any register based arg to the stack
3216 // It's a string the oop and it was already copied to the out arg
3253 // Ok now we are done. Need to place the nop that dtrace wants in order to
3277 // this function returns the adjust size (in number of words) to a c2i adapter
3322 // Deopt needs to pass some extra live values from frame to frame
3333 __ add(G3pcs, wordSize, G3pcs); // point to next pc value
3336 // trash registers to show a clear pattern in backtraces
3350 // trash the return value as there is nothing to return yet
3370 // Before we make new frames, check to see if stack is available.
3382 // Adjust old interpreter frame to make space for new frame's extra java locals
3385 // order to properly calculate interpreter_sp_adjustment. Even though in real life
3387 // (fortunately). If we had to have it correct everywhere then we would need to
3389 // were to have twice the frame count entries then we could have pairs [sp_adjustment, frame_size]
3417 // Ought to generate an ideal graph & compile, but here's some SPARC ASM
3452 // This is the entry point for code which is returning to a de-optimized
3460 // which are equivalent to the frame which is being deoptimized)
3465 // push new interpreter frames (take care to propagate the return
3472 // a return to the interpreter entry point
3474 // Refer to the following methods for more information:
3498 // On entry we have been jumped to by the exception handler (or exception_blob
3500 // exception pc. So if we push a frame here it will look to the
3514 // No need to update oop_map as each call to save_live_registers will produce identical oopmap
3543 // Reexecute entry, similar to c2 uncommon trap
3547 // No need to update oop_map as each call to save_live_registers will produce identical oopmap
3582 // Move the pending exception from exception_oop to Oexception so
3588 // deallocate the deoptimization frame taking care to preserve the return values
3599 // call Deoptimization::unpack_frames to have the unpacker layout
3601 // to the interpreter entry point
3639 // Ought to generate an ideal graph & compile, but here's some SPARC ASM
3670 // are equivalent to the frame which is being deoptimized)
3679 // - return to the interpreter entry point
3681 // Refer to the following methods for more information:
3685 // the unloaded class index is in O0 (first parameter to this blob)
3688 // and call Deoptimization::uncommon_trap to pack the compiled frame into
3698 // deallocate the deoptimized frame taking care to preserve the return values
3707 // call Deoptimization::unpack_frames to have the unpacker layout
3709 // to the interpreter entry point
3729 // This blob is jumped to (via a breakpoint and the signal handler) from a
3730 // safepoint in compiled code. On entry to this blob, O7 contains the
3734 // so it is guaranteed to be free here.
3737 // The hardest part of what this blob must do is to save the 64-bit %o
3738 // registers in the 32-bit build. A simple 'save' turn the %o's to %i's and
3741 // the adjusted FP off to the GC stack-crawler: this will modify the caller's
3780 // call into the runtime to handle illegal instructions exception
3781 // Do not use call_VM_leaf, because we need to make a GC map at this call site.
3805 // We are back the the original state on entry and ready to go.
3835 // Generate a stub that calls into vm to find out the proper destination
3865 // call into the runtime to handle illegal instructions exception
3866 // Do not use call_VM_leaf, because we need to make a GC map at this call site.
3872 // O0 contains the address we are going to jump to assuming no exception got installed
3895 // O0 is where we want to jump, overwrite G3 which is saved and scratch
3901 // We are back the the original state on entry and ready to go.