793 jccb(Assembler::zero, run_compiled_code);
794 jmp(Address(method, Method::interpreter_entry_offset()));
795 bind(run_compiled_code);
796 }
797
798 jmp(Address(method, Method::from_interpreted_offset()));
799 }
800
801 // The following two routines provide a hook so that an implementation
802 // can schedule the dispatch in two parts. x86 does not do this.
803 void InterpreterMacroAssembler::dispatch_prolog(TosState state, int step) {
804 // Nothing x86 specific to be done here
805 }
806
807 void InterpreterMacroAssembler::dispatch_epilog(TosState state, int step) {
808 dispatch_next(state, step);
809 }
810
811 void InterpreterMacroAssembler::dispatch_base(TosState state,
812 address* table,
813 bool verifyoop) {
814 verify_FPU(1, state);
815 if (VerifyActivationFrameSize) {
816 Label L;
817 mov(rcx, rbp);
818 subptr(rcx, rsp);
819 int32_t min_frame_size =
820 (frame::link_offset - frame::interpreter_frame_initial_sp_offset) *
821 wordSize;
822 cmpptr(rcx, (int32_t)min_frame_size);
823 jcc(Assembler::greaterEqual, L);
824 stop("broken stack frame");
825 bind(L);
826 }
827 if (verifyoop) {
828 verify_oop(rax, state);
829 }
830 #ifdef _LP64
831
832 Label no_safepoint, dispatch;
833 address* const safepoint_table = Interpreter::safept_table(state);
834 if (SafepointMechanism::uses_thread_local_poll() && table != safepoint_table) {
835 NOT_PRODUCT(block_comment("Thread-local Safepoint poll"));
836
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 ExternalAddress tbl((address)table);
852 ArrayAddress dispatch(tbl, index);
853 jump(dispatch);
854 #endif // _LP64
855 }
856
857 void InterpreterMacroAssembler::dispatch_only(TosState state) {
858 dispatch_base(state, Interpreter::dispatch_table(state));
859 }
860
861 void InterpreterMacroAssembler::dispatch_only_normal(TosState state) {
862 dispatch_base(state, Interpreter::normal_table(state));
863 }
864
865 void InterpreterMacroAssembler::dispatch_only_noverify(TosState state) {
866 dispatch_base(state, Interpreter::normal_table(state), false);
867 }
868
869
870 void InterpreterMacroAssembler::dispatch_next(TosState state, int step) {
871 // load next bytecode (load before advancing _bcp_register to prevent AGI)
872 load_unsigned_byte(rbx, Address(_bcp_register, step));
873 // advance _bcp_register
874 increment(_bcp_register, step);
875 dispatch_base(state, Interpreter::dispatch_table(state));
876 }
877
878 void InterpreterMacroAssembler::dispatch_via(TosState state, address* table) {
879 // load current bytecode
880 load_unsigned_byte(rbx, Address(_bcp_register, 0));
881 dispatch_base(state, table);
882 }
883
884 void InterpreterMacroAssembler::narrow(Register result) {
885
886 // Get method->_constMethod->_result_type
887 movptr(rcx, Address(rbp, frame::interpreter_frame_method_offset * wordSize));
888 movptr(rcx, Address(rcx, Method::const_offset()));
889 load_unsigned_byte(rcx, Address(rcx, ConstMethod::result_type_offset()));
890
891 Label done, notBool, notByte, notChar;
892
893 // common case first
894 cmpl(rcx, T_INT);
895 jcc(Assembler::equal, done);
|
793 jccb(Assembler::zero, run_compiled_code);
794 jmp(Address(method, Method::interpreter_entry_offset()));
795 bind(run_compiled_code);
796 }
797
798 jmp(Address(method, Method::from_interpreted_offset()));
799 }
800
801 // The following two routines provide a hook so that an implementation
802 // can schedule the dispatch in two parts. x86 does not do this.
803 void InterpreterMacroAssembler::dispatch_prolog(TosState state, int step) {
804 // Nothing x86 specific to be done here
805 }
806
807 void InterpreterMacroAssembler::dispatch_epilog(TosState state, int step) {
808 dispatch_next(state, step);
809 }
810
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
875 increment(_bcp_register, step);
876 dispatch_base(state, Interpreter::dispatch_table(state), true, generate_poll);
877 }
878
879 void InterpreterMacroAssembler::dispatch_via(TosState state, address* table) {
880 // load current bytecode
881 load_unsigned_byte(rbx, Address(_bcp_register, 0));
882 dispatch_base(state, table);
883 }
884
885 void InterpreterMacroAssembler::narrow(Register result) {
886
887 // Get method->_constMethod->_result_type
888 movptr(rcx, Address(rbp, frame::interpreter_frame_method_offset * wordSize));
889 movptr(rcx, Address(rcx, Method::const_offset()));
890 load_unsigned_byte(rcx, Address(rcx, ConstMethod::result_type_offset()));
891
892 Label done, notBool, notByte, notChar;
893
894 // common case first
895 cmpl(rcx, T_INT);
896 jcc(Assembler::equal, done);
|