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 #ifdef _WIN64
  56 address AbstractInterpreterGenerator::generate_slow_signature_handler() {
  57   address entry = __ pc();
  58 
  59   // rbx: method
  60   // r14: pointer to locals
  61   // c_rarg3: first stack arg - wordSize

 280           __ pow_with_fallback(0);
 281           break;
 282       default                              :
 283           ShouldNotReachHere();
 284     }
 285 
 286     // return double result in xmm0 for interpreter and compilers.
 287     __ subptr(rsp, 2*wordSize);
 288     // Round to 64bit precision
 289     __ fstp_d(Address(rsp, 0));
 290     __ movdbl(xmm0, Address(rsp, 0));
 291     __ addptr(rsp, 2*wordSize);
 292   }
 293 
 294 
 295   __ pop(rax);
 296   __ mov(rsp, r13);
 297   __ jmp(rax);
 298 
 299   return entry_point;
 300 }
 301 
 302 void Deoptimization::unwind_callee_save_values(frame* f, vframeArray* vframe_array) {
 303 
 304   // This code is sort of the equivalent of C2IAdapter::setup_stack_frame back in
 305   // the days we had adapter frames. When we deoptimize a situation where a
 306   // compiled caller calls a compiled caller will have registers it expects
 307   // to survive the call to the callee. If we deoptimize the callee the only
 308   // way we can restore these registers is to have the oldest interpreter
 309   // frame that we create restore these values. That is what this routine
 310   // will accomplish.
 311 
 312   // At the moment we have modified c2 to not have any callee save registers
 313   // so this problem does not exist and this routine is just a place holder.
 314 
 315   assert(f->is_interpreted_frame(), "must be interpreted");
 316 }

  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 #ifdef _WIN64
  55 address AbstractInterpreterGenerator::generate_slow_signature_handler() {
  56   address entry = __ pc();
  57 
  58   // rbx: method
  59   // r14: pointer to locals
  60   // c_rarg3: first stack arg - wordSize

 279           __ pow_with_fallback(0);
 280           break;
 281       default                              :
 282           ShouldNotReachHere();
 283     }
 284 
 285     // return double result in xmm0 for interpreter and compilers.
 286     __ subptr(rsp, 2*wordSize);
 287     // Round to 64bit precision
 288     __ fstp_d(Address(rsp, 0));
 289     __ movdbl(xmm0, Address(rsp, 0));
 290     __ addptr(rsp, 2*wordSize);
 291   }
 292 
 293 
 294   __ pop(rax);
 295   __ mov(rsp, r13);
 296   __ jmp(rax);
 297 
 298   return entry_point;
















 299 }