< prev index next >

src/hotspot/cpu/x86/interp_masm_x86.cpp

Print this page
rev 48494 : 8195112: x86 (32 bit): implementation for Thread-local handshakes
Reviewed-by:


 811 void InterpreterMacroAssembler::dispatch_base(TosState state,
 812                                               address* table,
 813                                               bool verifyoop,
 814                                               bool generate_poll) {
 815   verify_FPU(1, state);
 816   if (VerifyActivationFrameSize) {
 817     Label L;
 818     mov(rcx, rbp);
 819     subptr(rcx, rsp);
 820     int32_t min_frame_size =
 821       (frame::link_offset - frame::interpreter_frame_initial_sp_offset) *
 822       wordSize;
 823     cmpptr(rcx, (int32_t)min_frame_size);
 824     jcc(Assembler::greaterEqual, L);
 825     stop("broken stack frame");
 826     bind(L);
 827   }
 828   if (verifyoop) {
 829     verify_oop(rax, state);
 830   }
 831 #ifdef _LP64
 832 
 833   Label no_safepoint, dispatch;
 834   address* const safepoint_table = Interpreter::safept_table(state);


 835   if (SafepointMechanism::uses_thread_local_poll() && table != safepoint_table && generate_poll) {
 836     NOT_PRODUCT(block_comment("Thread-local Safepoint poll"));
 837 
 838     testb(Address(r15_thread, Thread::polling_page_offset()), SafepointMechanism::poll_bit());
 839 
 840     jccb(Assembler::zero, no_safepoint);
 841     lea(rscratch1, ExternalAddress((address)safepoint_table));
 842     jmpb(dispatch);
 843   }
 844 
 845   bind(no_safepoint);
 846   lea(rscratch1, ExternalAddress((address)table));
 847   bind(dispatch);
 848   jmp(Address(rscratch1, rbx, Address::times_8));
 849 
 850 #else
 851   Address index(noreg, rbx, Address::times_ptr);
 852   ExternalAddress tbl((address)table);
 853   ArrayAddress dispatch(tbl, index);
 854   jump(dispatch);














 855 #endif // _LP64
 856 }
 857 
 858 void InterpreterMacroAssembler::dispatch_only(TosState state, bool generate_poll) {
 859   dispatch_base(state, Interpreter::dispatch_table(state), true, generate_poll);
 860 }
 861 
 862 void InterpreterMacroAssembler::dispatch_only_normal(TosState state) {
 863   dispatch_base(state, Interpreter::normal_table(state));
 864 }
 865 
 866 void InterpreterMacroAssembler::dispatch_only_noverify(TosState state) {
 867   dispatch_base(state, Interpreter::normal_table(state), false);
 868 }
 869 
 870 
 871 void InterpreterMacroAssembler::dispatch_next(TosState state, int step, bool generate_poll) {
 872   // load next bytecode (load before advancing _bcp_register to prevent AGI)
 873   load_unsigned_byte(rbx, Address(_bcp_register, step));
 874   // advance _bcp_register




 811 void InterpreterMacroAssembler::dispatch_base(TosState state,
 812                                               address* table,
 813                                               bool verifyoop,
 814                                               bool generate_poll) {
 815   verify_FPU(1, state);
 816   if (VerifyActivationFrameSize) {
 817     Label L;
 818     mov(rcx, rbp);
 819     subptr(rcx, rsp);
 820     int32_t min_frame_size =
 821       (frame::link_offset - frame::interpreter_frame_initial_sp_offset) *
 822       wordSize;
 823     cmpptr(rcx, (int32_t)min_frame_size);
 824     jcc(Assembler::greaterEqual, L);
 825     stop("broken stack frame");
 826     bind(L);
 827   }
 828   if (verifyoop) {
 829     verify_oop(rax, state);
 830   }

 831 

 832   address* const safepoint_table = Interpreter::safept_table(state);
 833 #ifdef _LP64
 834   Label no_safepoint, dispatch;
 835   if (SafepointMechanism::uses_thread_local_poll() && table != safepoint_table && generate_poll) {
 836     NOT_PRODUCT(block_comment("Thread-local Safepoint poll"));

 837     testb(Address(r15_thread, Thread::polling_page_offset()), SafepointMechanism::poll_bit());
 838 
 839     jccb(Assembler::zero, no_safepoint);
 840     lea(rscratch1, ExternalAddress((address)safepoint_table));
 841     jmpb(dispatch);
 842   }
 843 
 844   bind(no_safepoint);
 845   lea(rscratch1, ExternalAddress((address)table));
 846   bind(dispatch);
 847   jmp(Address(rscratch1, rbx, Address::times_8));
 848 
 849 #else
 850   Address index(noreg, rbx, Address::times_ptr);
 851   if (SafepointMechanism::uses_thread_local_poll() && table != safepoint_table && generate_poll) {
 852     NOT_PRODUCT(block_comment("Thread-local Safepoint poll"));
 853     Label no_safepoint;
 854     const Register thread = rcx;
 855     get_thread(thread);
 856     testb(Address(thread, Thread::polling_page_offset()), SafepointMechanism::poll_bit());
 857 
 858     jccb(Assembler::zero, no_safepoint);
 859     ArrayAddress dispatch_addr(ExternalAddress((address)safepoint_table), index);
 860     jump(dispatch_addr);
 861     bind(no_safepoint);
 862   }
 863 
 864   {
 865     ArrayAddress dispatch_addr(ExternalAddress((address)table), index);
 866     jump(dispatch_addr);
 867   }
 868 #endif // _LP64
 869 }
 870 
 871 void InterpreterMacroAssembler::dispatch_only(TosState state, bool generate_poll) {
 872   dispatch_base(state, Interpreter::dispatch_table(state), true, generate_poll);
 873 }
 874 
 875 void InterpreterMacroAssembler::dispatch_only_normal(TosState state) {
 876   dispatch_base(state, Interpreter::normal_table(state));
 877 }
 878 
 879 void InterpreterMacroAssembler::dispatch_only_noverify(TosState state) {
 880   dispatch_base(state, Interpreter::normal_table(state), false);
 881 }
 882 
 883 
 884 void InterpreterMacroAssembler::dispatch_next(TosState state, int step, bool generate_poll) {
 885   // load next bytecode (load before advancing _bcp_register to prevent AGI)
 886   load_unsigned_byte(rbx, Address(_bcp_register, step));
 887   // advance _bcp_register


< prev index next >