287 // If deoptimization happens, this method returns the point where to continue in

   287 // If deoptimization happens, this function returns the point of next bytecode to continue execution

   288 // interpreter. For calls (invokexxxx, newxxxx) the continuation is at next

   288 address AbstractInterpreter::deopt_continue_after_entry(methodOop method, address bcp, int callee_parameters, bool is_top_frame) {

   289 // bci and the top of stack is in eax/edx/FPU tos.

   290 // For putfield/getfield, put/getstatic, the continuation is at the same

   291 // bci and the TOS is on stack.

   292 

   293 // Note: deopt_entry(type, 0) means reexecute bytecode

   294 //       deopt_entry(type, length) means continue at next bytecode

   295 

   296 address AbstractInterpreter::continuation_for(methodOop method, address bcp, int callee_parameters, bool is_top_frame, bool& use_next_mdp) {

   305   // when continuing after a compiler safepoint, re-execute the bytecode

   298 

   306   // (an invoke is continued after the safepoint)

   299   switch (code) {

   307   use_next_mdp = true;

   300     case Bytecodes::_invokevirtual  :

   301     case Bytecodes::_invokespecial  :

   302     case Bytecodes::_invokestatic   :

   303     case Bytecodes::_invokeinterface: {

   304       Thread *thread = Thread::current();

   305       ResourceMark rm(thread);

   306       methodHandle mh(thread, method);

   307       type = Bytecode_invoke_at(mh, bci)->result_type(thread);

   308       // since the cache entry might not be initialized:

   309       // (NOT needed for the old calling convension)

   310       if (!is_top_frame) {

   311         int index = Bytes::get_native_u2(bcp+1);

   312         method->constants()->cache()->entry_at(index)->set_parameter_size(callee_parameters);

   313       }

   314       break;

   315     }

   316 

   317     case Bytecodes::_ldc   :

   318       type = constant_pool_type( method, *(bcp+1) );

   319       break;

   320 

   321     case Bytecodes::_ldc_w : // fall through

   322     case Bytecodes::_ldc2_w:

   323       type = constant_pool_type( method, Bytes::get_Java_u2(bcp+1) );

   324       break;

   325 

   326     default:

   327       type = Bytecodes::result_type(code);

   328       break;

   329   }

   330 

   331   // return entry point for computed continuation state & bytecode length

   332   return

   333     is_top_frame

   334     ? Interpreter::deopt_entry (as_TosState(type), length)

   335     : Interpreter::return_entry(as_TosState(type), length);

   336 }

   337 

   338 // If deoptimization happens, this function returns the point where the interpreter reexecutes

   339 // the bytecode.

   340 // Note: Bytecodes::_athrow is a special case in that it does not return

   341 //       Interpreter::deopt_entry(vtos, 0) like others

   342 address AbstractInterpreter::deopt_reexecute_entry(methodOop method, address bcp) {

   343   assert(method->contains(bcp), "just checkin'");

   344   Bytecodes::Code code   = Bytecodes::java_code_at(bcp);

   345 #ifdef COMPILER1

   346   if(code == Bytecodes::_athrow ) {

   347     return Interpreter::rethrow_exception_entry();

   348   }

   349 #endif /* COMPILER1 */

   350   return Interpreter::deopt_entry(vtos, 0);

   351 }

   352 

   353 // If deoptimization happens, the interpreter should reexecute these bytecodes.

   354 // This function mainly helps the compilers to set up the reexecute bit.

   355 bool AbstractInterpreter::bytecode_should_reexecute(Bytecodes::Code code) {

   351       assert(is_top_frame, "must be top frame");

   394 #endif

   352       use_next_mdp = false;

   395       return true;

   353       return Interpreter::rethrow_exception_entry();

   354       break;

   355 #endif /* COMPILER1 */

   356 

   357     case Bytecodes::_invokevirtual  :

   358     case Bytecodes::_invokespecial  :

   359     case Bytecodes::_invokestatic   :

   360     case Bytecodes::_invokeinterface: {

   361       Thread *thread = Thread::current();

   362       ResourceMark rm(thread);

   363       methodHandle mh(thread, method);

   364       type = Bytecode_invoke_at(mh, bci)->result_type(thread);

   365       // since the cache entry might not be initialized:

   366       // (NOT needed for the old calling convension)

   367       if (!is_top_frame) {

   368         int index = Bytes::get_native_u2(bcp+1);

   369         method->constants()->cache()->entry_at(index)->set_parameter_size(callee_parameters);

   370       }

   371       break;

   372     }

   373 

   374     case Bytecodes::_ldc   :

   375       type = constant_pool_type( method, *(bcp+1) );

   376       break;

   377 

   378     case Bytecodes::_ldc_w : // fall through

   379     case Bytecodes::_ldc2_w:

   380       type = constant_pool_type( method, Bytes::get_Java_u2(bcp+1) );

   381       break;

   384       type = Bytecodes::result_type(code);

   398       return false;

   385       break;

   399   }

   386   }

   387 

   388   // return entry point for computed continuation state & bytecode length

   389   return

   390     is_top_frame

   391     ? Interpreter::deopt_entry (as_TosState(type), length)

   392     : Interpreter::return_entry(as_TosState(type), length);