src/cpu/x86/vm/templateInterpreterGenerator_x86.cpp

Print this page




  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 "runtime/arguments.hpp"
  40 #include "runtime/deoptimization.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 #include "utilities/macros.hpp"
  49 
  50 #define __ _masm->
  51 











  52 // Global Register Names
  53 static const Register rbcp     = LP64_ONLY(r13) NOT_LP64(rsi);
  54 static const Register rlocals  = LP64_ONLY(r14) NOT_LP64(rdi);
  55 
  56 const int method_offset = frame::interpreter_frame_method_offset * wordSize;
  57 const int bcp_offset    = frame::interpreter_frame_bcp_offset    * wordSize;
  58 const int locals_offset = frame::interpreter_frame_locals_offset * wordSize;
  59 

  60 //-----------------------------------------------------------------------------
  61 
  62 address TemplateInterpreterGenerator::generate_StackOverflowError_handler() {
  63   address entry = __ pc();
  64 
  65 #ifdef ASSERT
  66   {
  67     Label L;
  68     __ lea(rax, Address(rbp,
  69                         frame::interpreter_frame_monitor_block_top_offset *
  70                         wordSize));
  71     __ cmpptr(rax, rsp); // rax = maximal rsp for current rbp (stack
  72                          // grows negative)
  73     __ jcc(Assembler::aboveEqual, L); // check if frame is complete
  74     __ stop ("interpreter frame not set up");
  75     __ bind(L);
  76   }
  77 #endif // ASSERT
  78   // Restore bcp under the assumption that the current frame is still
  79   // interpreted


1283   LP64_ONLY( __ pop(dtos));
1284 
1285   __ movptr(t, Address(rbp,
1286                        (frame::interpreter_frame_result_handler_offset) * wordSize));
1287   __ call(t);
1288 
1289   // remove activation
1290   __ movptr(t, Address(rbp,
1291                        frame::interpreter_frame_sender_sp_offset *
1292                        wordSize)); // get sender sp
1293   __ leave();                                // remove frame anchor
1294   __ pop(rdi);                               // get return address
1295   __ mov(rsp, t);                            // set sp to sender sp
1296   __ jmp(rdi);
1297 
1298   if (inc_counter) {
1299     // Handle overflow of counter and compile method
1300     __ bind(invocation_counter_overflow);
1301     generate_counter_overflow(continue_after_compile);
1302   }





















1303 
1304   return entry_point;
1305 }
1306 
1307 //
1308 // Generic interpreted method entry to (asm) interpreter
1309 //
1310 address TemplateInterpreterGenerator::generate_normal_entry(bool synchronized) {
1311   // determine code generation flags
1312   bool inc_counter  = UseCompiler || CountCompiledCalls || LogTouchedMethods;
1313 
1314   // ebx: Method*
1315   // rbcp: sender sp
1316   address entry_point = __ pc();
1317 
1318   const Address constMethod(rbx, Method::const_offset());
1319   const Address access_flags(rbx, Method::access_flags_offset());
1320   const Address size_of_parameters(rdx,
1321                                    ConstMethod::size_of_parameters_offset());
1322   const Address size_of_locals(rdx, ConstMethod::size_of_locals_offset());




  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 "runtime/arguments.hpp"
  40 #include "runtime/deoptimization.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 #include "utilities/macros.hpp"
  49 
  50 #define __ _masm->
  51 
  52 // Size of interpreter code.  Increase if too small.  Interpreter will
  53 // fail with a guarantee ("not enough space for interpreter generation");
  54 // if too small.
  55 // Run with +PrintInterpreter to get the VM to print out the size.
  56 // Max size with JVMTI
  57 #ifdef AMD64
  58 int TemplateInterpreter::InterpreterCodeSize = 256 * 1024;
  59 #else
  60 int TemplateInterpreter::InterpreterCodeSize = 224 * 1024;
  61 #endif // AMD64
  62 
  63 // Global Register Names
  64 static const Register rbcp     = LP64_ONLY(r13) NOT_LP64(rsi);
  65 static const Register rlocals  = LP64_ONLY(r14) NOT_LP64(rdi);
  66 
  67 const int method_offset = frame::interpreter_frame_method_offset * wordSize;
  68 const int bcp_offset    = frame::interpreter_frame_bcp_offset    * wordSize;
  69 const int locals_offset = frame::interpreter_frame_locals_offset * wordSize;
  70 
  71 
  72 //-----------------------------------------------------------------------------
  73 
  74 address TemplateInterpreterGenerator::generate_StackOverflowError_handler() {
  75   address entry = __ pc();
  76 
  77 #ifdef ASSERT
  78   {
  79     Label L;
  80     __ lea(rax, Address(rbp,
  81                         frame::interpreter_frame_monitor_block_top_offset *
  82                         wordSize));
  83     __ cmpptr(rax, rsp); // rax = maximal rsp for current rbp (stack
  84                          // grows negative)
  85     __ jcc(Assembler::aboveEqual, L); // check if frame is complete
  86     __ stop ("interpreter frame not set up");
  87     __ bind(L);
  88   }
  89 #endif // ASSERT
  90   // Restore bcp under the assumption that the current frame is still
  91   // interpreted


1295   LP64_ONLY( __ pop(dtos));
1296 
1297   __ movptr(t, Address(rbp,
1298                        (frame::interpreter_frame_result_handler_offset) * wordSize));
1299   __ call(t);
1300 
1301   // remove activation
1302   __ movptr(t, Address(rbp,
1303                        frame::interpreter_frame_sender_sp_offset *
1304                        wordSize)); // get sender sp
1305   __ leave();                                // remove frame anchor
1306   __ pop(rdi);                               // get return address
1307   __ mov(rsp, t);                            // set sp to sender sp
1308   __ jmp(rdi);
1309 
1310   if (inc_counter) {
1311     // Handle overflow of counter and compile method
1312     __ bind(invocation_counter_overflow);
1313     generate_counter_overflow(continue_after_compile);
1314   }
1315 
1316   return entry_point;
1317 }
1318 
1319 // Abstract method entry
1320 // Attempt to execute abstract method. Throw exception
1321 address TemplateInterpreterGenerator::generate_abstract_entry(void) {
1322 
1323   address entry_point = __ pc();
1324 
1325   // abstract method entry
1326 
1327   //  pop return address, reset last_sp to NULL
1328   __ empty_expression_stack();
1329   __ restore_bcp();      // rsi must be correct for exception handler   (was destroyed)
1330   __ restore_locals();   // make sure locals pointer is correct as well (was destroyed)
1331 
1332   // throw exception
1333   __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_AbstractMethodError));
1334   // the call_VM checks for exception, so we should never return here.
1335   __ should_not_reach_here();
1336 
1337   return entry_point;
1338 }
1339 
1340 //
1341 // Generic interpreted method entry to (asm) interpreter
1342 //
1343 address TemplateInterpreterGenerator::generate_normal_entry(bool synchronized) {
1344   // determine code generation flags
1345   bool inc_counter  = UseCompiler || CountCompiledCalls || LogTouchedMethods;
1346 
1347   // ebx: Method*
1348   // rbcp: sender sp
1349   address entry_point = __ pc();
1350 
1351   const Address constMethod(rbx, Method::const_offset());
1352   const Address access_flags(rbx, Method::access_flags_offset());
1353   const Address size_of_parameters(rdx,
1354                                    ConstMethod::size_of_parameters_offset());
1355   const Address size_of_locals(rdx, ConstMethod::size_of_locals_offset());