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()); |