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 #ifndef FAST_DISPATCH 51 #define FAST_DISPATCH 1 52 #endif 53 #undef FAST_DISPATCH 54 55 56 // Generation of Interpreter 57 // 58 // The TemplateInterpreterGenerator generates the interpreter into Interpreter::_code. 59 60 61 #define __ _masm-> 62 63 64 //---------------------------------------------------------------------------------------------------- 65 66 67 void TemplateInterpreterGenerator::save_native_result(void) { 68 // result potentially in O0/O1: save it across calls 69 const Address& l_tmp = InterpreterMacroAssembler::l_tmp; 70 71 // result potentially in F0/F1: save it across calls 72 const Address& d_tmp = InterpreterMacroAssembler::d_tmp; 73 74 // save and restore any potential method result value around the unlocking operation 75 __ stf(FloatRegisterImpl::D, F0, d_tmp); 76 #ifdef _LP64 77 __ stx(O0, l_tmp); 78 #else 79 __ std(O0, l_tmp); 80 #endif 81 } 82 83 void TemplateInterpreterGenerator::restore_native_result(void) { 84 const Address& l_tmp = InterpreterMacroAssembler::l_tmp; 85 const Address& d_tmp = InterpreterMacroAssembler::d_tmp; | 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 #ifndef FAST_DISPATCH 51 #define FAST_DISPATCH 1 52 #endif 53 #undef FAST_DISPATCH 54 55 // Size of interpreter code. Increase if too small. Interpreter will 56 // fail with a guarantee ("not enough space for interpreter generation"); 57 // if too small. 58 // Run with +PrintInterpreter to get the VM to print out the size. 59 // Max size with JVMTI 60 #ifdef _LP64 61 // The sethi() instruction generates lots more instructions when shell 62 // stack limit is unlimited, so that's why this is much bigger. 63 int TemplateInterpreter::InterpreterCodeSize = 260 * K; 64 #else 65 int TemplateInterpreter::InterpreterCodeSize = 230 * K; 66 #endif 67 68 // Generation of Interpreter 69 // 70 // The TemplateInterpreterGenerator generates the interpreter into Interpreter::_code. 71 72 73 #define __ _masm-> 74 75 76 //---------------------------------------------------------------------------------------------------- 77 78 #ifndef _LP64 79 address TemplateInterpreterGenerator::generate_slow_signature_handler() { 80 address entry = __ pc(); 81 Argument argv(0, true); 82 83 // We are in the jni transition frame. Save the last_java_frame corresponding to the 84 // outer interpreter frame 85 // 86 __ set_last_Java_frame(FP, noreg); 87 // make sure the interpreter frame we've pushed has a valid return pc 88 __ mov(O7, I7); 89 __ mov(Lmethod, G3_scratch); 90 __ mov(Llocals, G4_scratch); 91 __ save_frame(0); 92 __ mov(G2_thread, L7_thread_cache); 93 __ add(argv.address_in_frame(), O3); 94 __ mov(G2_thread, O0); 95 __ mov(G3_scratch, O1); 96 __ call(CAST_FROM_FN_PTR(address, InterpreterRuntime::slow_signature_handler), relocInfo::runtime_call_type); 97 __ delayed()->mov(G4_scratch, O2); 98 __ mov(L7_thread_cache, G2_thread); 99 __ reset_last_Java_frame(); 100 101 // load the register arguments (the C code packed them as varargs) 102 for (Argument ldarg = argv.successor(); ldarg.is_register(); ldarg = ldarg.successor()) { 103 __ ld_ptr(ldarg.address_in_frame(), ldarg.as_register()); 104 } 105 __ ret(); 106 __ delayed()-> 107 restore(O0, 0, Lscratch); // caller's Lscratch gets the result handler 108 return entry; 109 } 110 111 112 #else 113 // LP64 passes floating point arguments in F1, F3, F5, etc. instead of 114 // O0, O1, O2 etc.. 115 // Doubles are passed in D0, D2, D4 116 // We store the signature of the first 16 arguments in the first argument 117 // slot because it will be overwritten prior to calling the native 118 // function, with the pointer to the JNIEnv. 119 // If LP64 there can be up to 16 floating point arguments in registers 120 // or 6 integer registers. 121 address TemplateInterpreterGenerator::generate_slow_signature_handler() { 122 123 enum { 124 non_float = 0, 125 float_sig = 1, 126 double_sig = 2, 127 sig_mask = 3 128 }; 129 130 address entry = __ pc(); 131 Argument argv(0, true); 132 133 // We are in the jni transition frame. Save the last_java_frame corresponding to the 134 // outer interpreter frame 135 // 136 __ set_last_Java_frame(FP, noreg); 137 // make sure the interpreter frame we've pushed has a valid return pc 138 __ mov(O7, I7); 139 __ mov(Lmethod, G3_scratch); 140 __ mov(Llocals, G4_scratch); 141 __ save_frame(0); 142 __ mov(G2_thread, L7_thread_cache); 143 __ add(argv.address_in_frame(), O3); 144 __ mov(G2_thread, O0); 145 __ mov(G3_scratch, O1); 146 __ call(CAST_FROM_FN_PTR(address, InterpreterRuntime::slow_signature_handler), relocInfo::runtime_call_type); 147 __ delayed()->mov(G4_scratch, O2); 148 __ mov(L7_thread_cache, G2_thread); 149 __ reset_last_Java_frame(); 150 151 152 // load the register arguments (the C code packed them as varargs) 153 Address Sig = argv.address_in_frame(); // Argument 0 holds the signature 154 __ ld_ptr( Sig, G3_scratch ); // Get register argument signature word into G3_scratch 155 __ mov( G3_scratch, G4_scratch); 156 __ srl( G4_scratch, 2, G4_scratch); // Skip Arg 0 157 Label done; 158 for (Argument ldarg = argv.successor(); ldarg.is_float_register(); ldarg = ldarg.successor()) { 159 Label NonFloatArg; 160 Label LoadFloatArg; 161 Label LoadDoubleArg; 162 Label NextArg; 163 Address a = ldarg.address_in_frame(); 164 __ andcc(G4_scratch, sig_mask, G3_scratch); 165 __ br(Assembler::zero, false, Assembler::pt, NonFloatArg); 166 __ delayed()->nop(); 167 168 __ cmp(G3_scratch, float_sig ); 169 __ br(Assembler::equal, false, Assembler::pt, LoadFloatArg); 170 __ delayed()->nop(); 171 172 __ cmp(G3_scratch, double_sig ); 173 __ br(Assembler::equal, false, Assembler::pt, LoadDoubleArg); 174 __ delayed()->nop(); 175 176 __ bind(NonFloatArg); 177 // There are only 6 integer register arguments! 178 if ( ldarg.is_register() ) 179 __ ld_ptr(ldarg.address_in_frame(), ldarg.as_register()); 180 else { 181 // Optimization, see if there are any more args and get out prior to checking 182 // all 16 float registers. My guess is that this is rare. 183 // If is_register is false, then we are done the first six integer args. 184 __ br_null_short(G4_scratch, Assembler::pt, done); 185 } 186 __ ba(NextArg); 187 __ delayed()->srl( G4_scratch, 2, G4_scratch ); 188 189 __ bind(LoadFloatArg); 190 __ ldf( FloatRegisterImpl::S, a, ldarg.as_float_register(), 4); 191 __ ba(NextArg); 192 __ delayed()->srl( G4_scratch, 2, G4_scratch ); 193 194 __ bind(LoadDoubleArg); 195 __ ldf( FloatRegisterImpl::D, a, ldarg.as_double_register() ); 196 __ ba(NextArg); 197 __ delayed()->srl( G4_scratch, 2, G4_scratch ); 198 199 __ bind(NextArg); 200 201 } 202 203 __ bind(done); 204 __ ret(); 205 __ delayed()-> 206 restore(O0, 0, Lscratch); // caller's Lscratch gets the result handler 207 return entry; 208 } 209 #endif 210 211 void TemplateInterpreterGenerator::generate_counter_overflow(Label& Lcontinue) { 212 213 // Generate code to initiate compilation on the counter overflow. 214 215 // InterpreterRuntime::frequency_counter_overflow takes two arguments, 216 // the first indicates if the counter overflow occurs at a backwards branch (NULL bcp) 217 // and the second is only used when the first is true. We pass zero for both. 218 // The call returns the address of the verified entry point for the method or NULL 219 // if the compilation did not complete (either went background or bailed out). 220 __ set((int)false, O2); 221 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::frequency_counter_overflow), O2, O2, true); 222 // returns verified_entry_point or NULL 223 // we ignore it in any case 224 __ ba_short(Lcontinue); 225 226 } 227 228 229 // End of helpers 230 231 // Various method entries 232 233 // Abstract method entry 234 // Attempt to execute abstract method. Throw exception 235 // 236 address TemplateInterpreterGenerator::generate_abstract_entry(void) { 237 address entry = __ pc(); 238 // abstract method entry 239 // throw exception 240 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_AbstractMethodError)); 241 // the call_VM checks for exception, so we should never return here. 242 __ should_not_reach_here(); 243 return entry; 244 245 } 246 247 void TemplateInterpreterGenerator::save_native_result(void) { 248 // result potentially in O0/O1: save it across calls 249 const Address& l_tmp = InterpreterMacroAssembler::l_tmp; 250 251 // result potentially in F0/F1: save it across calls 252 const Address& d_tmp = InterpreterMacroAssembler::d_tmp; 253 254 // save and restore any potential method result value around the unlocking operation 255 __ stf(FloatRegisterImpl::D, F0, d_tmp); 256 #ifdef _LP64 257 __ stx(O0, l_tmp); 258 #else 259 __ std(O0, l_tmp); 260 #endif 261 } 262 263 void TemplateInterpreterGenerator::restore_native_result(void) { 264 const Address& l_tmp = InterpreterMacroAssembler::l_tmp; 265 const Address& d_tmp = InterpreterMacroAssembler::d_tmp; |