21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "asm/macroAssembler.hpp"
  27 #include "interpreter/bytecodeHistogram.hpp"
  28 #include "interpreter/interpreter.hpp"
  29 #include "interpreter/interpreterGenerator.hpp"
  30 #include "interpreter/interpreterRuntime.hpp"
  31 #include "interpreter/interp_masm.hpp"
  32 #include "interpreter/templateTable.hpp"
  33 #include "oops/arrayOop.hpp"
  34 #include "oops/methodData.hpp"
  35 #include "oops/method.hpp"
  36 #include "oops/oop.inline.hpp"
  37 #include "prims/jvmtiExport.hpp"
  38 #include "prims/jvmtiThreadState.hpp"
  39 #include "prims/methodHandles.hpp"
  40 #include "runtime/arguments.hpp"
  41 #include "runtime/deoptimization.hpp"
  42 #include "runtime/frame.inline.hpp"
  43 #include "runtime/sharedRuntime.hpp"
  44 #include "runtime/stubRoutines.hpp"
  45 #include "runtime/synchronizer.hpp"
  46 #include "runtime/timer.hpp"
  47 #include "runtime/vframeArray.hpp"
  48 #include "utilities/debug.hpp"
  49 #ifdef COMPILER1
  50 #include "c1/c1_Runtime1.hpp"
  51 #endif
  52 
  53 #define __ _masm->
  54 
  55 //------------------------------------------------------------------------------------------------------------------------
  56 
  57 address AbstractInterpreterGenerator::generate_slow_signature_handler() {
  58   address entry = __ pc();
  59   // rbx,: method
  60   // rcx: temporary
  61   // rdi: pointer to locals

 166       __ addptr(rsp, 2*wordSize);
 167     break;
 168     default                              :
 169         ShouldNotReachHere();
 170   }
 171 
 172   // return double result in xmm0 for interpreter and compilers.
 173   if (UseSSE >= 2) {
 174     __ subptr(rsp, 2*wordSize);
 175     __ fstp_d(Address(rsp, 0));
 176     __ movdbl(xmm0, Address(rsp, 0));
 177     __ addptr(rsp, 2*wordSize);
 178   }
 179 
 180   // done, result in FPU ST(0) or XMM0
 181   __ pop(rdi);                               // get return address
 182   __ mov(rsp, rsi);                          // set sp to sender sp
 183   __ jmp(rdi);
 184 
 185   return entry_point;
 186 }
 187 
 188 
 189 void Deoptimization::unwind_callee_save_values(frame* f, vframeArray* vframe_array) {
 190 
 191   // This code is sort of the equivalent of C2IAdapter::setup_stack_frame back in
 192   // the days we had adapter frames. When we deoptimize a situation where a
 193   // compiled caller calls a compiled caller will have registers it expects
 194   // to survive the call to the callee. If we deoptimize the callee the only
 195   // way we can restore these registers is to have the oldest interpreter
 196   // frame that we create restore these values. That is what this routine
 197   // will accomplish.
 198 
 199   // At the moment we have modified c2 to not have any callee save registers
 200   // so this problem does not exist and this routine is just a place holder.
 201 
 202   assert(f->is_interpreted_frame(), "must be interpreted");
 203 }

  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "asm/macroAssembler.hpp"
  27 #include "interpreter/bytecodeHistogram.hpp"
  28 #include "interpreter/interpreter.hpp"
  29 #include "interpreter/interpreterGenerator.hpp"
  30 #include "interpreter/interpreterRuntime.hpp"
  31 #include "interpreter/interp_masm.hpp"
  32 #include "interpreter/templateTable.hpp"
  33 #include "oops/arrayOop.hpp"
  34 #include "oops/methodData.hpp"
  35 #include "oops/method.hpp"
  36 #include "oops/oop.inline.hpp"
  37 #include "prims/jvmtiExport.hpp"
  38 #include "prims/jvmtiThreadState.hpp"
  39 #include "prims/methodHandles.hpp"
  40 #include "runtime/arguments.hpp"

  41 #include "runtime/frame.inline.hpp"
  42 #include "runtime/sharedRuntime.hpp"
  43 #include "runtime/stubRoutines.hpp"
  44 #include "runtime/synchronizer.hpp"
  45 #include "runtime/timer.hpp"
  46 #include "runtime/vframeArray.hpp"
  47 #include "utilities/debug.hpp"
  48 #ifdef COMPILER1
  49 #include "c1/c1_Runtime1.hpp"
  50 #endif
  51 
  52 #define __ _masm->
  53 
  54 //------------------------------------------------------------------------------------------------------------------------
  55 
  56 address AbstractInterpreterGenerator::generate_slow_signature_handler() {
  57   address entry = __ pc();
  58   // rbx,: method
  59   // rcx: temporary
  60   // rdi: pointer to locals

 165       __ addptr(rsp, 2*wordSize);
 166     break;
 167     default                              :
 168         ShouldNotReachHere();
 169   }
 170 
 171   // return double result in xmm0 for interpreter and compilers.
 172   if (UseSSE >= 2) {
 173     __ subptr(rsp, 2*wordSize);
 174     __ fstp_d(Address(rsp, 0));
 175     __ movdbl(xmm0, Address(rsp, 0));
 176     __ addptr(rsp, 2*wordSize);
 177   }
 178 
 179   // done, result in FPU ST(0) or XMM0
 180   __ pop(rdi);                               // get return address
 181   __ mov(rsp, rsi);                          // set sp to sender sp
 182   __ jmp(rdi);
 183 
 184   return entry_point;

















 185 }