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

 241 address InterpreterGenerator::generate_abstract_entry(void) {
 242   // rmethod: Method*
 243   // r13: sender SP
 244 
 245   address entry_point = __ pc();
 246 
 247   // abstract method entry
 248 
 249   //  pop return address, reset last_sp to NULL
 250   __ empty_expression_stack();
 251   __ restore_bcp();      // bcp must be correct for exception handler   (was destroyed)
 252   __ restore_locals();   // make sure locals pointer is correct as well (was destroyed)
 253 
 254   // throw exception
 255   __ call_VM(noreg, CAST_FROM_FN_PTR(address,
 256                              InterpreterRuntime::throw_AbstractMethodError));
 257   // the call_VM checks for exception, so we should never return here.
 258   __ should_not_reach_here();
 259 
 260   return entry_point;
 261 }
 262 
 263 
 264 void Deoptimization::unwind_callee_save_values(frame* f, vframeArray* vframe_array) {
 265 
 266   // This code is sort of the equivalent of C2IAdapter::setup_stack_frame back in
 267   // the days we had adapter frames. When we deoptimize a situation where a
 268   // compiled caller calls a compiled caller will have registers it expects
 269   // to survive the call to the callee. If we deoptimize the callee the only
 270   // way we can restore these registers is to have the oldest interpreter
 271   // frame that we create restore these values. That is what this routine
 272   // will accomplish.
 273 
 274   // At the moment we have modified c2 to not have any callee save registers
 275   // so this problem does not exist and this routine is just a place holder.
 276 
 277   assert(f->is_interpreted_frame(), "must be interpreted");
 278 }

  22  * questions.
  23  *
  24  */
  25 
  26 #include "precompiled.hpp"
  27 #include "asm/macroAssembler.hpp"
  28 #include "interpreter/bytecodeHistogram.hpp"
  29 #include "interpreter/interpreter.hpp"
  30 #include "interpreter/interpreterGenerator.hpp"
  31 #include "interpreter/interpreterRuntime.hpp"
  32 #include "interpreter/interp_masm.hpp"
  33 #include "interpreter/templateTable.hpp"
  34 #include "oops/arrayOop.hpp"
  35 #include "oops/methodData.hpp"
  36 #include "oops/method.hpp"
  37 #include "oops/oop.inline.hpp"
  38 #include "prims/jvmtiExport.hpp"
  39 #include "prims/jvmtiThreadState.hpp"
  40 #include "prims/methodHandles.hpp"
  41 #include "runtime/arguments.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 address AbstractInterpreterGenerator::generate_slow_signature_handler() {
  57   address entry = __ pc();
  58 
  59   __ andr(esp, esp, -16);
  60   __ mov(c_rarg3, esp);
  61   // rmethod

 240 address InterpreterGenerator::generate_abstract_entry(void) {
 241   // rmethod: Method*
 242   // r13: sender SP
 243 
 244   address entry_point = __ pc();
 245 
 246   // abstract method entry
 247 
 248   //  pop return address, reset last_sp to NULL
 249   __ empty_expression_stack();
 250   __ restore_bcp();      // bcp must be correct for exception handler   (was destroyed)
 251   __ restore_locals();   // make sure locals pointer is correct as well (was destroyed)
 252 
 253   // throw exception
 254   __ call_VM(noreg, CAST_FROM_FN_PTR(address,
 255                              InterpreterRuntime::throw_AbstractMethodError));
 256   // the call_VM checks for exception, so we should never return here.
 257   __ should_not_reach_here();
 258 
 259   return entry_point;

















 260 }