src/cpu/x86/vm/templateInterpreter_x86_32.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File 8026328 Sdiff src/cpu/x86/vm

src/cpu/x86/vm/templateInterpreter_x86_32.cpp

Print this page




 133     } else {
 134       __ movptr(rbx, NULL_WORD);
 135     }
 136     __ call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception), rax, rbx);
 137   }
 138   // throw exception
 139   __ jump(ExternalAddress(Interpreter::throw_exception_entry()));
 140   return entry;
 141 }
 142 
 143 
 144 address TemplateInterpreterGenerator::generate_continuation_for(TosState state) {
 145   address entry = __ pc();
 146   // NULL last_sp until next java call
 147   __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);
 148   __ dispatch_next(state);
 149   return entry;
 150 }
 151 
 152 
 153 address TemplateInterpreterGenerator::generate_return_entry_for(TosState state, int step) {
 154   TosState incoming_state = state;
 155   address entry = __ pc();
 156 
 157 #ifdef COMPILER2
 158   // The FPU stack is clean if UseSSE >= 2 but must be cleaned in other cases
 159   if ((incoming_state == ftos && UseSSE < 1) || (incoming_state == dtos && UseSSE < 2)) {
 160     for (int i = 1; i < 8; i++) {
 161         __ ffree(i);
 162     }
 163   } else if (UseSSE < 2) {
 164     __ empty_FPU_stack();
 165   }
 166 #endif
 167   if ((incoming_state == ftos && UseSSE < 1) || (incoming_state == dtos && UseSSE < 2)) {
 168     __ MacroAssembler::verify_FPU(1, "generate_return_entry_for compiled");
 169   } else {
 170     __ MacroAssembler::verify_FPU(0, "generate_return_entry_for compiled");
 171   }
 172 
 173   // In SSE mode, interpreter returns FP results in xmm0 but they need
 174   // to end up back on the FPU so it can operate on them.
 175   if (incoming_state == ftos && UseSSE >= 1) {
 176     __ subptr(rsp, wordSize);
 177     __ movflt(Address(rsp, 0), xmm0);
 178     __ fld_s(Address(rsp, 0));
 179     __ addptr(rsp, wordSize);
 180   } else if (incoming_state == dtos && UseSSE >= 2) {
 181     __ subptr(rsp, 2*wordSize);
 182     __ movdbl(Address(rsp, 0), xmm0);
 183     __ fld_d(Address(rsp, 0));
 184     __ addptr(rsp, 2*wordSize);
 185   }
 186 
 187   __ MacroAssembler::verify_FPU(state == ftos || state == dtos ? 1 : 0, "generate_return_entry_for in interpreter");
 188 
 189   // Restore stack bottom in case i2c adjusted stack
 190   __ movptr(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize));
 191   // and NULL it as marker that rsp is now tos until next java call
 192   __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);
 193 
 194   __ restore_bcp();
 195   __ restore_locals();
 196 
 197   if (incoming_state == atos) {
 198     Register mdp = rbx;
 199     Register tmp = rcx;
 200     __ profile_return_type(mdp, rax, tmp);
 201   }
 202 
 203   Label L_got_cache, L_giant_index;
 204   if (EnableInvokeDynamic) {
 205     __ cmpb(Address(rsi, 0), Bytecodes::_invokedynamic);
 206     __ jcc(Assembler::equal, L_giant_index);
 207   }
 208   __ get_cache_and_index_at_bcp(rbx, rcx, 1, sizeof(u2));
 209   __ bind(L_got_cache);
 210   __ movl(rbx, Address(rbx, rcx,
 211                     Address::times_ptr, ConstantPoolCache::base_offset() +
 212                     ConstantPoolCacheEntry::flags_offset()));
 213   __ andptr(rbx, 0xFF);
 214   __ lea(rsp, Address(rsp, rbx, Interpreter::stackElementScale()));
 215   __ dispatch_next(state, step);
 216 
 217   // out of the main line of code...
 218   if (EnableInvokeDynamic) {
 219     __ bind(L_giant_index);
 220     __ get_cache_and_index_at_bcp(rbx, rcx, 1, sizeof(u4));
 221     __ jmp(L_got_cache);
 222   }
 223 
 224   return entry;
 225 }
 226 
 227 
 228 address TemplateInterpreterGenerator::generate_deopt_entry_for(TosState state, int step) {
 229   address entry = __ pc();
 230 
 231   // In SSE mode, FP results are in xmm0
 232   if (state == ftos && UseSSE > 0) {
 233     __ subptr(rsp, wordSize);
 234     __ movflt(Address(rsp, 0), xmm0);
 235     __ fld_s(Address(rsp, 0));
 236     __ addptr(rsp, wordSize);
 237   } else if (state == dtos && UseSSE >= 2) {
 238     __ subptr(rsp, 2*wordSize);
 239     __ movdbl(Address(rsp, 0), xmm0);
 240     __ fld_d(Address(rsp, 0));
 241     __ addptr(rsp, 2*wordSize);
 242   }
 243 




 133     } else {
 134       __ movptr(rbx, NULL_WORD);
 135     }
 136     __ call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception), rax, rbx);
 137   }
 138   // throw exception
 139   __ jump(ExternalAddress(Interpreter::throw_exception_entry()));
 140   return entry;
 141 }
 142 
 143 
 144 address TemplateInterpreterGenerator::generate_continuation_for(TosState state) {
 145   address entry = __ pc();
 146   // NULL last_sp until next java call
 147   __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);
 148   __ dispatch_next(state);
 149   return entry;
 150 }
 151 
 152 
 153 address TemplateInterpreterGenerator::generate_return_entry_for(TosState state, int step, size_t index_size) {

 154   address entry = __ pc();
 155 
 156 #ifdef COMPILER2
 157   // The FPU stack is clean if UseSSE >= 2 but must be cleaned in other cases
 158   if ((state == ftos && UseSSE < 1) || (state == dtos && UseSSE < 2)) {
 159     for (int i = 1; i < 8; i++) {
 160         __ ffree(i);
 161     }
 162   } else if (UseSSE < 2) {
 163     __ empty_FPU_stack();
 164   }
 165 #endif
 166   if ((state == ftos && UseSSE < 1) || (state == dtos && UseSSE < 2)) {
 167     __ MacroAssembler::verify_FPU(1, "generate_return_entry_for compiled");
 168   } else {
 169     __ MacroAssembler::verify_FPU(0, "generate_return_entry_for compiled");
 170   }
 171 
 172   // In SSE mode, interpreter returns FP results in xmm0 but they need
 173   // to end up back on the FPU so it can operate on them.
 174   if (state == ftos && UseSSE >= 1) {
 175     __ subptr(rsp, wordSize);
 176     __ movflt(Address(rsp, 0), xmm0);
 177     __ fld_s(Address(rsp, 0));
 178     __ addptr(rsp, wordSize);
 179   } else if (state == dtos && UseSSE >= 2) {
 180     __ subptr(rsp, 2*wordSize);
 181     __ movdbl(Address(rsp, 0), xmm0);
 182     __ fld_d(Address(rsp, 0));
 183     __ addptr(rsp, 2*wordSize);
 184   }
 185 
 186   __ MacroAssembler::verify_FPU(state == ftos || state == dtos ? 1 : 0, "generate_return_entry_for in interpreter");
 187 
 188   // Restore stack bottom in case i2c adjusted stack
 189   __ movptr(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize));
 190   // and NULL it as marker that rsp is now tos until next java call
 191   __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);
 192 
 193   __ restore_bcp();
 194   __ restore_locals();
 195 
 196   if (state == atos) {
 197     Register mdp = rbx;
 198     Register tmp = rcx;
 199     __ profile_return_type(mdp, rax, tmp);
 200   }
 201 
 202   const Register cache = rbx;
 203   const Register index = rcx;
 204   __ get_cache_and_index_at_bcp(cache, index, 1, index_size);
 205 
 206   const Register flags = cache;
 207   __ movl(flags, Address(cache, index, Address::times_ptr, ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset()));
 208   __ andl(flags, ConstantPoolCacheEntry::parameter_size_mask);
 209   __ lea(rsp, Address(rsp, flags, Interpreter::stackElementScale()));




 210   __ dispatch_next(state, step);
 211 







 212   return entry;
 213 }
 214 
 215 
 216 address TemplateInterpreterGenerator::generate_deopt_entry_for(TosState state, int step) {
 217   address entry = __ pc();
 218 
 219   // In SSE mode, FP results are in xmm0
 220   if (state == ftos && UseSSE > 0) {
 221     __ subptr(rsp, wordSize);
 222     __ movflt(Address(rsp, 0), xmm0);
 223     __ fld_s(Address(rsp, 0));
 224     __ addptr(rsp, wordSize);
 225   } else if (state == dtos && UseSSE >= 2) {
 226     __ subptr(rsp, 2*wordSize);
 227     __ movdbl(Address(rsp, 0), xmm0);
 228     __ fld_d(Address(rsp, 0));
 229     __ addptr(rsp, 2*wordSize);
 230   }
 231 


src/cpu/x86/vm/templateInterpreter_x86_32.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File