792 const Register tmp = c_rarg2;
793 const Register obj_reg = c_rarg3; // Will contain the oop
794
795 const int obj_offset = BasicObjectLock::obj_offset_in_bytes();
796 const int lock_offset = BasicObjectLock::lock_offset_in_bytes ();
797 const int mark_offset = lock_offset +
798 BasicLock::displaced_header_offset_in_bytes();
799
800 Label slow_case;
801
802 // Load object pointer into obj_reg c_rarg3
803 ld(obj_reg, Address(lock_reg, obj_offset));
804
805 if (DiagnoseSyncOnValueBasedClasses != 0) {
806 load_klass(tmp, obj_reg);
807 lwu(tmp, Address(tmp, Klass::access_flags_offset()));
808 andi(tmp, tmp, JVM_ACC_IS_VALUE_BASED_CLASS);
809 bnez(tmp, slow_case);
810 }
811
812 // Load (object->mark() | 1) into swap_reg
813 ld(t0, Address(obj_reg, oopDesc::mark_offset_in_bytes()));
814 ori(swap_reg, t0, 1);
815
816 // Save (object->mark() | 1) into BasicLock's displaced header
817 sd(swap_reg, Address(lock_reg, mark_offset));
818
819 assert(lock_offset == 0,
820 "displached header must be first word in BasicObjectLock");
821
822 cmpxchg_obj_header(swap_reg, lock_reg, obj_reg, t0, count, /*fallthrough*/NULL);
823
824 // Test if the oopMark is an obvious stack pointer, i.e.,
825 // 1) (mark & 7) == 0, and
826 // 2) sp <= mark < mark + os::pagesize()
827 //
828 // These 3 tests can be done by evaluating the following
829 // expression: ((mark - sp) & (7 - os::vm_page_size())),
830 // assuming both stack pointer and pagesize have their
831 // least significant 3 bits clear.
832 // NOTE: the oopMark is in swap_reg x10 as the result of cmpxchg
833 sub(swap_reg, swap_reg, sp);
834 mv(t0, (int64_t)(7 - (int)os::vm_page_size()));
835 andr(swap_reg, swap_reg, t0);
836
837 // Save the test result, for recursive case, the result is zero
838 sd(swap_reg, Address(lock_reg, mark_offset));
839 beqz(swap_reg, count);
840
841 bind(slow_case);
842
843 // Call the runtime routine for slow case
844 call_VM(noreg,
845 CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter),
846 lock_reg);
847
848 j(done);
849
850 bind(count);
851 increment(Address(xthread, JavaThread::held_monitor_count_offset()));
852
853 bind(done);
854 }
855 }
856
857
858 // Unlocks an object. Used in monitorexit bytecode and
859 // remove_activation. Throws an IllegalMonitorException if object is
860 // not locked by current thread.
861 //
862 // Args:
863 // c_rarg1: BasicObjectLock for lock
864 //
865 // Kills:
866 // x10
867 // c_rarg0, c_rarg1, c_rarg2, c_rarg3, ... (param regs)
868 // t0, t1 (temp regs)
869 void InterpreterMacroAssembler::unlock_object(Register lock_reg)
870 {
871 assert(lock_reg == c_rarg1, "The argument is only for looks. It must be rarg1");
872
873 if (UseHeavyMonitors) {
874 call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorexit), lock_reg);
875 } else {
876 Label count, done;
877
878 const Register swap_reg = x10;
879 const Register header_reg = c_rarg2; // Will contain the old oopMark
880 const Register obj_reg = c_rarg3; // Will contain the oop
881
882 save_bcp(); // Save in case of exception
883
884 // Convert from BasicObjectLock structure to object and BasicLock
885 // structure Store the BasicLock address into x10
886 la(swap_reg, Address(lock_reg, BasicObjectLock::lock_offset_in_bytes()));
887
888 // Load oop into obj_reg(c_rarg3)
889 ld(obj_reg, Address(lock_reg, BasicObjectLock::obj_offset_in_bytes()));
890
891 // Free entry
892 sd(zr, Address(lock_reg, BasicObjectLock::obj_offset_in_bytes()));
893
894 // Load the old header from BasicLock structure
895 ld(header_reg, Address(swap_reg,
896 BasicLock::displaced_header_offset_in_bytes()));
897
898 // Test for recursion
899 beqz(header_reg, count);
900
901 // Atomic swap back the old header
902 cmpxchg_obj_header(swap_reg, header_reg, obj_reg, t0, count, /*fallthrough*/NULL);
903
904 // Call the runtime routine for slow case.
905 sd(obj_reg, Address(lock_reg, BasicObjectLock::obj_offset_in_bytes())); // restore obj
906 call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorexit), lock_reg);
907
908 j(done);
909
910 bind(count);
911 decrement(Address(xthread, JavaThread::held_monitor_count_offset()));
912
913 bind(done);
914
915 restore_bcp();
916 }
917 }
918
919
920 void InterpreterMacroAssembler::test_method_data_pointer(Register mdp,
921 Label& zero_continue) {
922 assert(ProfileInterpreter, "must be profiling interpreter");
|
792 const Register tmp = c_rarg2;
793 const Register obj_reg = c_rarg3; // Will contain the oop
794
795 const int obj_offset = BasicObjectLock::obj_offset_in_bytes();
796 const int lock_offset = BasicObjectLock::lock_offset_in_bytes ();
797 const int mark_offset = lock_offset +
798 BasicLock::displaced_header_offset_in_bytes();
799
800 Label slow_case;
801
802 // Load object pointer into obj_reg c_rarg3
803 ld(obj_reg, Address(lock_reg, obj_offset));
804
805 if (DiagnoseSyncOnValueBasedClasses != 0) {
806 load_klass(tmp, obj_reg);
807 lwu(tmp, Address(tmp, Klass::access_flags_offset()));
808 andi(tmp, tmp, JVM_ACC_IS_VALUE_BASED_CLASS);
809 bnez(tmp, slow_case);
810 }
811
812 if (UseFastLocking) {
813 ld(tmp, Address(obj_reg, oopDesc::mark_offset_in_bytes()));
814 fast_lock(obj_reg, tmp, t0, t1, slow_case);
815 j(count);
816 } else {
817 // Load (object->mark() | 1) into swap_reg
818 ld(t0, Address(obj_reg, oopDesc::mark_offset_in_bytes()));
819 ori(swap_reg, t0, 1);
820
821 // Save (object->mark() | 1) into BasicLock's displaced header
822 sd(swap_reg, Address(lock_reg, mark_offset));
823
824 assert(lock_offset == 0,
825 "displached header must be first word in BasicObjectLock");
826
827 cmpxchg_obj_header(swap_reg, lock_reg, obj_reg, t0, count, /*fallthrough*/NULL);
828
829 // Test if the oopMark is an obvious stack pointer, i.e.,
830 // 1) (mark & 7) == 0, and
831 // 2) sp <= mark < mark + os::pagesize()
832 //
833 // These 3 tests can be done by evaluating the following
834 // expression: ((mark - sp) & (7 - os::vm_page_size())),
835 // assuming both stack pointer and pagesize have their
836 // least significant 3 bits clear.
837 // NOTE: the oopMark is in swap_reg x10 as the result of cmpxchg
838 sub(swap_reg, swap_reg, sp);
839 mv(t0, (int64_t)(7 - (int)os::vm_page_size()));
840 andr(swap_reg, swap_reg, t0);
841
842 // Save the test result, for recursive case, the result is zero
843 sd(swap_reg, Address(lock_reg, mark_offset));
844 beqz(swap_reg, count);
845 }
846
847 bind(slow_case);
848
849 // Call the runtime routine for slow case
850 call_VM(noreg,
851 CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter),
852 UseFastLocking ? obj_reg : lock_reg);
853
854 j(done);
855
856 bind(count);
857 increment(Address(xthread, JavaThread::held_monitor_count_offset()));
858
859 bind(done);
860 }
861 }
862
863
864 // Unlocks an object. Used in monitorexit bytecode and
865 // remove_activation. Throws an IllegalMonitorException if object is
866 // not locked by current thread.
867 //
868 // Args:
869 // c_rarg1: BasicObjectLock for lock
870 //
871 // Kills:
872 // x10
873 // c_rarg0, c_rarg1, c_rarg2, c_rarg3, ... (param regs)
874 // t0, t1 (temp regs)
875 void InterpreterMacroAssembler::unlock_object(Register lock_reg)
876 {
877 assert(lock_reg == c_rarg1, "The argument is only for looks. It must be rarg1");
878
879 if (UseHeavyMonitors) {
880 call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorexit), lock_reg);
881 } else {
882 Label count, done;
883
884 const Register swap_reg = x10;
885 const Register header_reg = c_rarg2; // Will contain the old oopMark
886 const Register obj_reg = c_rarg3; // Will contain the oop
887
888 save_bcp(); // Save in case of exception
889
890 if (UseFastLocking) {
891 Label slow_case;
892 // Load oop into obj_reg(c_rarg3)
893 ld(obj_reg, Address(lock_reg, BasicObjectLock::obj_offset_in_bytes()));
894
895 // Free entry
896 sd(zr, Address(lock_reg, BasicObjectLock::obj_offset_in_bytes()));
897
898 // Check for non-symmetric locking. This is allowed by the spec and the interpreter
899 // must handle it.
900 Register tmp = header_reg;
901 ld(tmp, Address(xthread, JavaThread::lock_stack_current_offset()));
902 ld(tmp, Address(tmp, -oopSize));
903 bne(tmp, obj_reg, slow_case);
904
905 ld(header_reg, Address(obj_reg, oopDesc::mark_offset_in_bytes()));
906 fast_unlock(obj_reg, header_reg, swap_reg, t0, slow_case);
907 j(count);
908
909 bind(slow_case);
910 } else {
911 // Convert from BasicObjectLock structure to object and BasicLock
912 // structure Store the BasicLock address into x10
913 la(swap_reg, Address(lock_reg, BasicObjectLock::lock_offset_in_bytes()));
914
915 // Load oop into obj_reg(c_rarg3)
916 ld(obj_reg, Address(lock_reg, BasicObjectLock::obj_offset_in_bytes()));
917
918 // Free entry
919 sd(zr, Address(lock_reg, BasicObjectLock::obj_offset_in_bytes()));
920
921 // Load the old header from BasicLock structure
922 ld(header_reg, Address(swap_reg,
923 BasicLock::displaced_header_offset_in_bytes()));
924
925 // Test for recursion
926 beqz(header_reg, count);
927
928 // Atomic swap back the old header
929 cmpxchg_obj_header(swap_reg, header_reg, obj_reg, t0, count, /*fallthrough*/NULL);
930 }
931
932 // Call the runtime routine for slow case.
933 sd(obj_reg, Address(lock_reg, BasicObjectLock::obj_offset_in_bytes())); // restore obj
934 call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorexit), lock_reg);
935
936 j(done);
937
938 bind(count);
939 decrement(Address(xthread, JavaThread::held_monitor_count_offset()));
940
941 bind(done);
942
943 restore_bcp();
944 }
945 }
946
947
948 void InterpreterMacroAssembler::test_method_data_pointer(Register mdp,
949 Label& zero_continue) {
950 assert(ProfileInterpreter, "must be profiling interpreter");
|