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);
1133 increment_mdp_data_at(mdp,
1134 index,
1135 in_bytes(MultiBranchData::relative_count_offset()));
1136
1137 // The method data pointer needs to be updated.
1138 update_mdp_by_offset(mdp,
1139 index,
1140 in_bytes(MultiBranchData::
1141 relative_displacement_offset()));
1142
1143 bind(profile_continue);
1144 }
1145 }
1146
1147 void InterpreterMacroAssembler::_interp_verify_oop(Register reg, TosState state, const char* file, int line) {
1148 if (state == atos) {
1149 MacroAssembler::_verify_oop_checked(reg, "broken oop", file, line);
1150 }
1151 }
1152
1153 void InterpreterMacroAssembler::notify_method_entry() {
1154 // Whenever JVMTI is interp_only_mode, method entry/exit events are sent to
1155 // track stack depth. If it is possible to enter interp_only_mode we add
1156 // the code to check if the event should be sent.
1157 if (JvmtiExport::can_post_interpreter_events()) {
1158 Label L;
1159 ldrw(r3, Address(rthread, JavaThread::interp_only_mode_offset()));
1160 cbzw(r3, L);
1161 call_VM(noreg, CAST_FROM_FN_PTR(address,
1162 InterpreterRuntime::post_method_entry));
1163 bind(L);
1164 }
1165
1166 if (DTraceMethodProbes) {
1167 get_method(c_rarg1);
1168 call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_entry),
1169 rthread, c_rarg1);
1170 }
1171
1172 // RedefineClasses() tracing support for obsolete method entry
1173 if (log_is_enabled(Trace, redefine, class, obsolete)) {
1174 get_method(c_rarg1);
1175 call_VM_leaf(
1176 CAST_FROM_FN_PTR(address, SharedRuntime::rc_trace_method_entry),
1177 rthread, c_rarg1);
1178 }
1179
1180 }
1181
1182
1183 void InterpreterMacroAssembler::notify_method_exit(
1184 TosState state, NotifyMethodExitMode mode) {
1185 // Whenever JVMTI is interp_only_mode, method entry/exit events are sent to
1186 // track stack depth. If it is possible to enter interp_only_mode we add
1187 // the code to check if the event should be sent.
1188 if (mode == NotifyJVMTI && JvmtiExport::can_post_interpreter_events()) {
1189 Label L;
1190 // Note: frame::interpreter_frame_result has a dependency on how the
1191 // method result is saved across the call to post_method_exit. If this
1192 // is changed then the interpreter_frame_result implementation will
1193 // 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);
1134 increment_mdp_data_at(mdp,
1135 index,
1136 in_bytes(MultiBranchData::relative_count_offset()));
1137
1138 // The method data pointer needs to be updated.
1139 update_mdp_by_offset(mdp,
1140 index,
1141 in_bytes(MultiBranchData::
1142 relative_displacement_offset()));
1143
1144 bind(profile_continue);
1145 }
1146 }
1147
1148 void InterpreterMacroAssembler::_interp_verify_oop(Register reg, TosState state, const char* file, int line) {
1149 if (state == atos) {
1150 MacroAssembler::_verify_oop_checked(reg, "broken oop", file, line);
1151 }
1152 }
1153
1154 void InterpreterMacroAssembler::generate_runtime_upcalls_on_method_entry()
1155 {
1156 address upcall = RuntimeUpcalls::on_method_entry_upcall_address();
1157 if (RuntimeUpcalls::does_upcall_need_method_parameter(upcall)) {
1158 get_method(c_rarg1);
1159 call_VM(noreg,upcall, c_rarg1);
1160 } else {
1161 call_VM(noreg,upcall);
1162 }
1163 }
1164
1165 void InterpreterMacroAssembler::notify_method_entry() {
1166 // Whenever JVMTI is interp_only_mode, method entry/exit events are sent to
1167 // track stack depth. If it is possible to enter interp_only_mode we add
1168 // the code to check if the event should be sent.
1169 if (JvmtiExport::can_post_interpreter_events()) {
1170 Label L;
1171 ldrw(r3, Address(rthread, JavaThread::interp_only_mode_offset()));
1172 cbzw(r3, L);
1173 call_VM(noreg, CAST_FROM_FN_PTR(address,
1174 InterpreterRuntime::post_method_entry));
1175 bind(L);
1176 }
1177
1178 if (DTraceMethodProbes) {
1179 get_method(c_rarg1);
1180 call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_entry),
1181 rthread, c_rarg1);
1182 }
1183
1184 // RedefineClasses() tracing support for obsolete method entry
1185 if (log_is_enabled(Trace, redefine, class, obsolete) ||
1186 log_is_enabled(Trace, interpreter, bytecode)) {
1187 get_method(c_rarg1);
1188 call_VM_leaf(
1189 CAST_FROM_FN_PTR(address, SharedRuntime::rc_trace_method_entry),
1190 rthread, c_rarg1);
1191 }
1192
1193 }
1194
1195
1196 void InterpreterMacroAssembler::notify_method_exit(
1197 TosState state, NotifyMethodExitMode mode) {
1198 // Whenever JVMTI is interp_only_mode, method entry/exit events are sent to
1199 // track stack depth. If it is possible to enter interp_only_mode we add
1200 // the code to check if the event should be sent.
1201 if (mode == NotifyJVMTI && JvmtiExport::can_post_interpreter_events()) {
1202 Label L;
1203 // Note: frame::interpreter_frame_result has a dependency on how the
1204 // method result is saved across the call to post_method_exit. If this
1205 // is changed then the interpreter_frame_result implementation will
1206 // need to be updated too.
|