26 #include "asm/macroAssembler.inline.hpp"
27 #include "compiler/compiler_globals.hpp"
28 #include "gc/shared/barrierSet.hpp"
29 #include "gc/shared/barrierSetAssembler.hpp"
30 #include "interp_masm_aarch64.hpp"
31 #include "interpreter/interpreter.hpp"
32 #include "interpreter/interpreterRuntime.hpp"
33 #include "logging/log.hpp"
34 #include "oops/arrayOop.hpp"
35 #include "oops/markWord.hpp"
36 #include "oops/method.hpp"
37 #include "oops/methodData.hpp"
38 #include "oops/resolvedFieldEntry.hpp"
39 #include "oops/resolvedIndyEntry.hpp"
40 #include "oops/resolvedMethodEntry.hpp"
41 #include "prims/jvmtiExport.hpp"
42 #include "prims/jvmtiThreadState.hpp"
43 #include "runtime/basicLock.hpp"
44 #include "runtime/frame.inline.hpp"
45 #include "runtime/javaThread.hpp"
46 #include "runtime/safepointMechanism.hpp"
47 #include "runtime/sharedRuntime.hpp"
48 #include "utilities/powerOfTwo.hpp"
49
50 void InterpreterMacroAssembler::narrow(Register result) {
51
52 // Get method->_constMethod->_result_type
53 ldr(rscratch1, Address(rfp, frame::interpreter_frame_method_offset * wordSize));
54 ldr(rscratch1, Address(rscratch1, Method::const_offset()));
55 ldrb(rscratch1, Address(rscratch1, ConstMethod::result_type_offset()));
56
57 Label done, notBool, notByte, notChar;
58
59 // common case first
60 cmpw(rscratch1, T_INT);
61 br(Assembler::EQ, done);
62
63 // mask integer result to narrower return type.
64 cmpw(rscratch1, T_BOOLEAN);
65 br(Assembler::NE, notBool);
1260 increment_mdp_data_at(mdp,
1261 index,
1262 in_bytes(MultiBranchData::relative_count_offset()));
1263
1264 // The method data pointer needs to be updated.
1265 update_mdp_by_offset(mdp,
1266 index,
1267 in_bytes(MultiBranchData::
1268 relative_displacement_offset()));
1269
1270 bind(profile_continue);
1271 }
1272 }
1273
1274 void InterpreterMacroAssembler::_interp_verify_oop(Register reg, TosState state, const char* file, int line) {
1275 if (state == atos) {
1276 MacroAssembler::_verify_oop_checked(reg, "broken oop", file, line);
1277 }
1278 }
1279
1280 void InterpreterMacroAssembler::notify_method_entry() {
1281 // Whenever JVMTI is interp_only_mode, method entry/exit events are sent to
1282 // track stack depth. If it is possible to enter interp_only_mode we add
1283 // the code to check if the event should be sent.
1284 if (JvmtiExport::can_post_interpreter_events()) {
1285 Label L;
1286 ldrw(r3, Address(rthread, JavaThread::interp_only_mode_offset()));
1287 cbzw(r3, L);
1288 call_VM(noreg, CAST_FROM_FN_PTR(address,
1289 InterpreterRuntime::post_method_entry));
1290 bind(L);
1291 }
1292
1293 if (DTraceMethodProbes) {
1294 get_method(c_rarg1);
1295 call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_entry),
1296 rthread, c_rarg1);
1297 }
1298
1299 // RedefineClasses() tracing support for obsolete method entry
1300 if (log_is_enabled(Trace, redefine, class, obsolete)) {
1301 get_method(c_rarg1);
1302 call_VM_leaf(
1303 CAST_FROM_FN_PTR(address, SharedRuntime::rc_trace_method_entry),
1304 rthread, c_rarg1);
1305 }
1306
1307 }
1308
1309
1310 void InterpreterMacroAssembler::notify_method_exit(
1311 TosState state, NotifyMethodExitMode mode) {
1312 // Whenever JVMTI is interp_only_mode, method entry/exit events are sent to
1313 // track stack depth. If it is possible to enter interp_only_mode we add
1314 // the code to check if the event should be sent.
1315 if (mode == NotifyJVMTI && JvmtiExport::can_post_interpreter_events()) {
1316 Label L;
1317 // Note: frame::interpreter_frame_result has a dependency on how the
1318 // method result is saved across the call to post_method_exit. If this
1319 // is changed then the interpreter_frame_result implementation will
1320 // need to be updated too.
|
26 #include "asm/macroAssembler.inline.hpp"
27 #include "compiler/compiler_globals.hpp"
28 #include "gc/shared/barrierSet.hpp"
29 #include "gc/shared/barrierSetAssembler.hpp"
30 #include "interp_masm_aarch64.hpp"
31 #include "interpreter/interpreter.hpp"
32 #include "interpreter/interpreterRuntime.hpp"
33 #include "logging/log.hpp"
34 #include "oops/arrayOop.hpp"
35 #include "oops/markWord.hpp"
36 #include "oops/method.hpp"
37 #include "oops/methodData.hpp"
38 #include "oops/resolvedFieldEntry.hpp"
39 #include "oops/resolvedIndyEntry.hpp"
40 #include "oops/resolvedMethodEntry.hpp"
41 #include "prims/jvmtiExport.hpp"
42 #include "prims/jvmtiThreadState.hpp"
43 #include "runtime/basicLock.hpp"
44 #include "runtime/frame.inline.hpp"
45 #include "runtime/javaThread.hpp"
46 #include "runtime/runtimeUpcalls.hpp"
47 #include "runtime/safepointMechanism.hpp"
48 #include "runtime/sharedRuntime.hpp"
49 #include "utilities/powerOfTwo.hpp"
50
51 void InterpreterMacroAssembler::narrow(Register result) {
52
53 // Get method->_constMethod->_result_type
54 ldr(rscratch1, Address(rfp, frame::interpreter_frame_method_offset * wordSize));
55 ldr(rscratch1, Address(rscratch1, Method::const_offset()));
56 ldrb(rscratch1, Address(rscratch1, ConstMethod::result_type_offset()));
57
58 Label done, notBool, notByte, notChar;
59
60 // common case first
61 cmpw(rscratch1, T_INT);
62 br(Assembler::EQ, done);
63
64 // mask integer result to narrower return type.
65 cmpw(rscratch1, T_BOOLEAN);
66 br(Assembler::NE, notBool);
1261 increment_mdp_data_at(mdp,
1262 index,
1263 in_bytes(MultiBranchData::relative_count_offset()));
1264
1265 // The method data pointer needs to be updated.
1266 update_mdp_by_offset(mdp,
1267 index,
1268 in_bytes(MultiBranchData::
1269 relative_displacement_offset()));
1270
1271 bind(profile_continue);
1272 }
1273 }
1274
1275 void InterpreterMacroAssembler::_interp_verify_oop(Register reg, TosState state, const char* file, int line) {
1276 if (state == atos) {
1277 MacroAssembler::_verify_oop_checked(reg, "broken oop", file, line);
1278 }
1279 }
1280
1281 void InterpreterMacroAssembler::generate_runtime_upcalls_on_method_entry()
1282 {
1283 address upcall = RuntimeUpcalls::on_method_entry_upcall_address();
1284 if (RuntimeUpcalls::does_upcall_need_method_parameter(upcall)) {
1285 get_method(c_rarg1);
1286 call_VM(noreg,upcall, c_rarg1);
1287 } else {
1288 call_VM(noreg,upcall);
1289 }
1290 }
1291
1292 void InterpreterMacroAssembler::notify_method_entry() {
1293 // Whenever JVMTI is interp_only_mode, method entry/exit events are sent to
1294 // track stack depth. If it is possible to enter interp_only_mode we add
1295 // the code to check if the event should be sent.
1296 if (JvmtiExport::can_post_interpreter_events()) {
1297 Label L;
1298 ldrw(r3, Address(rthread, JavaThread::interp_only_mode_offset()));
1299 cbzw(r3, L);
1300 call_VM(noreg, CAST_FROM_FN_PTR(address,
1301 InterpreterRuntime::post_method_entry));
1302 bind(L);
1303 }
1304
1305 if (DTraceMethodProbes) {
1306 get_method(c_rarg1);
1307 call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_entry),
1308 rthread, c_rarg1);
1309 }
1310
1311 // RedefineClasses() tracing support for obsolete method entry
1312 if (log_is_enabled(Trace, redefine, class, obsolete) ||
1313 log_is_enabled(Trace, interpreter, bytecode)) {
1314 get_method(c_rarg1);
1315 call_VM_leaf(
1316 CAST_FROM_FN_PTR(address, SharedRuntime::rc_trace_method_entry),
1317 rthread, c_rarg1);
1318 }
1319
1320 }
1321
1322
1323 void InterpreterMacroAssembler::notify_method_exit(
1324 TosState state, NotifyMethodExitMode mode) {
1325 // Whenever JVMTI is interp_only_mode, method entry/exit events are sent to
1326 // track stack depth. If it is possible to enter interp_only_mode we add
1327 // the code to check if the event should be sent.
1328 if (mode == NotifyJVMTI && JvmtiExport::can_post_interpreter_events()) {
1329 Label L;
1330 // Note: frame::interpreter_frame_result has a dependency on how the
1331 // method result is saved across the call to post_method_exit. If this
1332 // is changed then the interpreter_frame_result implementation will
1333 // need to be updated too.
|