1053 CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter),
1054 lock_reg);
1055 } else {
1056 Label done;
1057
1058 const Register swap_reg = rax; // Must use rax for cmpxchg instruction
1059 const Register tmp_reg = rbx; // Will be passed to biased_locking_enter to avoid a
1060 // problematic case where tmp_reg = no_reg.
1061 const Register obj_reg = LP64_ONLY(c_rarg3) NOT_LP64(rcx); // Will contain the oop
1062
1063 const int obj_offset = BasicObjectLock::obj_offset_in_bytes();
1064 const int lock_offset = BasicObjectLock::lock_offset_in_bytes ();
1065 const int mark_offset = lock_offset +
1066 BasicLock::displaced_header_offset_in_bytes();
1067
1068 Label slow_case;
1069
1070 // Load object pointer into obj_reg
1071 movptr(obj_reg, Address(lock_reg, obj_offset));
1072
1073 if (UseBiasedLocking) {
1074 biased_locking_enter(lock_reg, obj_reg, swap_reg, tmp_reg, false, done, &slow_case);
1075 }
1076
1077 // Load immediate 1 into swap_reg %rax
1078 movl(swap_reg, (int32_t)1);
1079
1080 // Load (object->mark() | 1) into swap_reg %rax
1081 orptr(swap_reg, Address(obj_reg, 0));
1082
1083 // Save (object->mark() | 1) into BasicLock's displaced header
1084 movptr(Address(lock_reg, mark_offset), swap_reg);
1085
1086 assert(lock_offset == 0,
1087 "displached header must be first word in BasicObjectLock");
1088
1089 if (os::is_MP()) lock();
1090 cmpxchgptr(lock_reg, Address(obj_reg, 0));
1091 if (PrintBiasedLockingStatistics) {
1092 cond_inc32(Assembler::zero,
1147
1148 if (UseHeavyMonitors) {
1149 call_VM(noreg,
1150 CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorexit),
1151 lock_reg);
1152 } else {
1153 Label done;
1154
1155 const Register swap_reg = rax; // Must use rax for cmpxchg instruction
1156 const Register header_reg = LP64_ONLY(c_rarg2) NOT_LP64(rbx); // Will contain the old oopMark
1157 const Register obj_reg = LP64_ONLY(c_rarg3) NOT_LP64(rcx); // Will contain the oop
1158
1159 save_bcp(); // Save in case of exception
1160
1161 // Convert from BasicObjectLock structure to object and BasicLock
1162 // structure Store the BasicLock address into %rax
1163 lea(swap_reg, Address(lock_reg, BasicObjectLock::lock_offset_in_bytes()));
1164
1165 // Load oop into obj_reg(%c_rarg3)
1166 movptr(obj_reg, Address(lock_reg, BasicObjectLock::obj_offset_in_bytes()));
1167
1168 // Free entry
1169 movptr(Address(lock_reg, BasicObjectLock::obj_offset_in_bytes()), (int32_t)NULL_WORD);
1170
1171 if (UseBiasedLocking) {
1172 biased_locking_exit(obj_reg, header_reg, done);
1173 }
1174
1175 // Load the old header from BasicLock structure
1176 movptr(header_reg, Address(swap_reg,
1177 BasicLock::displaced_header_offset_in_bytes()));
1178
1179 // Test for recursion
1180 testptr(header_reg, header_reg);
1181
1182 // zero for recursive case
1183 jcc(Assembler::zero, done);
1184
1185 // Atomic swap back the old header
1186 if (os::is_MP()) lock();
|
1053 CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter),
1054 lock_reg);
1055 } else {
1056 Label done;
1057
1058 const Register swap_reg = rax; // Must use rax for cmpxchg instruction
1059 const Register tmp_reg = rbx; // Will be passed to biased_locking_enter to avoid a
1060 // problematic case where tmp_reg = no_reg.
1061 const Register obj_reg = LP64_ONLY(c_rarg3) NOT_LP64(rcx); // Will contain the oop
1062
1063 const int obj_offset = BasicObjectLock::obj_offset_in_bytes();
1064 const int lock_offset = BasicObjectLock::lock_offset_in_bytes ();
1065 const int mark_offset = lock_offset +
1066 BasicLock::displaced_header_offset_in_bytes();
1067
1068 Label slow_case;
1069
1070 // Load object pointer into obj_reg
1071 movptr(obj_reg, Address(lock_reg, obj_offset));
1072
1073 // Need to preemptively evacuate obj because we CAS the mark word later.
1074 oopDesc::bs()->interpreter_write_barrier(this, obj_reg);
1075
1076 if (UseBiasedLocking) {
1077 biased_locking_enter(lock_reg, obj_reg, swap_reg, tmp_reg, false, done, &slow_case);
1078 }
1079
1080 // Load immediate 1 into swap_reg %rax
1081 movl(swap_reg, (int32_t)1);
1082
1083 // Load (object->mark() | 1) into swap_reg %rax
1084 orptr(swap_reg, Address(obj_reg, 0));
1085
1086 // Save (object->mark() | 1) into BasicLock's displaced header
1087 movptr(Address(lock_reg, mark_offset), swap_reg);
1088
1089 assert(lock_offset == 0,
1090 "displached header must be first word in BasicObjectLock");
1091
1092 if (os::is_MP()) lock();
1093 cmpxchgptr(lock_reg, Address(obj_reg, 0));
1094 if (PrintBiasedLockingStatistics) {
1095 cond_inc32(Assembler::zero,
1150
1151 if (UseHeavyMonitors) {
1152 call_VM(noreg,
1153 CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorexit),
1154 lock_reg);
1155 } else {
1156 Label done;
1157
1158 const Register swap_reg = rax; // Must use rax for cmpxchg instruction
1159 const Register header_reg = LP64_ONLY(c_rarg2) NOT_LP64(rbx); // Will contain the old oopMark
1160 const Register obj_reg = LP64_ONLY(c_rarg3) NOT_LP64(rcx); // Will contain the oop
1161
1162 save_bcp(); // Save in case of exception
1163
1164 // Convert from BasicObjectLock structure to object and BasicLock
1165 // structure Store the BasicLock address into %rax
1166 lea(swap_reg, Address(lock_reg, BasicObjectLock::lock_offset_in_bytes()));
1167
1168 // Load oop into obj_reg(%c_rarg3)
1169 movptr(obj_reg, Address(lock_reg, BasicObjectLock::obj_offset_in_bytes()));
1170
1171 // Need to preemptively evacuate obj because we CAS the mark word later.
1172 oopDesc::bs()->interpreter_write_barrier(this, obj_reg);
1173
1174 // Free entry
1175 movptr(Address(lock_reg, BasicObjectLock::obj_offset_in_bytes()), (int32_t)NULL_WORD);
1176
1177 if (UseBiasedLocking) {
1178 biased_locking_exit(obj_reg, header_reg, done);
1179 }
1180
1181 // Load the old header from BasicLock structure
1182 movptr(header_reg, Address(swap_reg,
1183 BasicLock::displaced_header_offset_in_bytes()));
1184
1185 // Test for recursion
1186 testptr(header_reg, header_reg);
1187
1188 // zero for recursive case
1189 jcc(Assembler::zero, done);
1190
1191 // Atomic swap back the old header
1192 if (os::is_MP()) lock();
|