8370509: [lworld] EnableValhalla is not needed for sync

Reviewed-by: phubner, fparain

Author: coleenp

src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp

@@ -7873,10 +7873,9 @@ void MacroAssembler::lightweight_lock(Register basic_lock, Register obj, Registe
   // Try to lock. Transition lock bits 0b01 => 0b00
   assert(oopDesc::mark_offset_in_bytes() == 0, "required to avoid lea");
   orr(mark, mark, markWord::unlocked_value);
-  if (EnableValhalla) {
-    // Mask inline_type bit such that we go to the slow path if object is an inline type
-    andr(mark, mark, ~((int) markWord::inline_type_bit_in_place));
-  }
+  // Mask inline_type bit such that we go to the slow path if object is an inline type
+  andr(mark, mark, ~((int) markWord::inline_type_bit_in_place));
+
   eor(t, mark, markWord::unlocked_value);
   cmpxchg(/*addr*/ obj, /*expected*/ mark, /*new*/ t, Assembler::xword,
           /*acquire*/ true, /*release*/ false, /*weak*/ false, noreg);

src/hotspot/cpu/x86/macroAssembler_x86.cpp

@@ -10439,10 +10439,9 @@ void MacroAssembler::lightweight_lock(Register basic_lock, Register obj, Registe
   movptr(tmp, reg_rax);
   andptr(tmp, ~(int32_t)markWord::unlocked_value);
   orptr(reg_rax, markWord::unlocked_value);
-  if (EnableValhalla) {
-    // Mask inline_type bit such that we go to the slow path if object is an inline type
-    andptr(reg_rax, ~((int) markWord::inline_type_bit_in_place));
-  }
+  // Mask inline_type bit such that we go to the slow path if object is an inline type
+  andptr(reg_rax, ~((int) markWord::inline_type_bit_in_place));
+
   lock(); cmpxchgptr(tmp, Address(obj, oopDesc::mark_offset_in_bytes()));
   jcc(Assembler::notEqual, slow);
 

src/hotspot/share/runtime/synchronizer.cpp

@@ -315,14 +315,14 @@ static bool _no_progress_skip_increment = false;
 // These checks are required for wait, notify and exit to avoid inflating the monitor to
 // find out this inline type object cannot be locked.
 #define CHECK_THROW_NOSYNC_IMSE(obj)  \
-  if (EnableValhalla && (obj)->mark().is_inline_type()) {  \
+  if ((obj)->mark().is_inline_type()) {  \
     JavaThread* THREAD = current;           \
     ResourceMark rm(THREAD);                \
     THROW_MSG(vmSymbols::java_lang_IllegalMonitorStateException(), obj->klass()->external_name()); \
   }
 
 #define CHECK_THROW_NOSYNC_IMSE_0(obj)  \
-  if (EnableValhalla && (obj)->mark().is_inline_type()) {  \
+  if ((obj)->mark().is_inline_type()) {  \
     JavaThread* THREAD = current;             \
     ResourceMark rm(THREAD);                  \
     THROW_MSG_0(vmSymbols::java_lang_IllegalMonitorStateException(), obj->klass()->external_name()); \
@@ -354,7 +354,7 @@ bool ObjectSynchronizer::quick_notify(oopDesc* obj, JavaThread* current, bool al
   assert(current->thread_state() == _thread_in_Java, "invariant");
   NoSafepointVerifier nsv;
   if (obj == nullptr) return false;  // slow-path for invalid obj
-  assert(!EnableValhalla || !obj->klass()->is_inline_klass(), "monitor op on inline type");
+  assert(!obj->klass()->is_inline_klass(), "monitor op on inline type");
   const markWord mark = obj->mark();
 
   if (mark.is_fast_locked() && current->lock_stack().contains(cast_to_oop(obj))) {
@@ -446,7 +446,7 @@ void ObjectSynchronizer::enter_for(Handle obj, BasicLock* lock, JavaThread* lock
   // the locking_thread with respect to the current thread. Currently only used when
   // deoptimizing and re-locking locks. See Deoptimization::relock_objects
   assert(locking_thread == Thread::current() || locking_thread->is_obj_deopt_suspend(), "must be");
-  assert(!EnableValhalla || !obj->klass()->is_inline_klass(), "JITed code should never have locked an instance of a value class");
+  assert(!obj->klass()->is_inline_klass(), "JITed code should never have locked an instance of a value class");
   return LightweightSynchronizer::enter_for(obj, lock, locking_thread);
 }
 
@@ -463,7 +463,7 @@ void ObjectSynchronizer::jni_enter(Handle obj, JavaThread* current) {
     handle_sync_on_value_based_class(obj, current);
   }
 
-  if (EnableValhalla && obj->klass()->is_inline_klass()) {
+  if (obj->klass()->is_inline_klass()) {
     ResourceMark rm(THREAD);
     const char* desc = "Cannot synchronize on an instance of value class ";
     const char* className = obj->klass()->external_name();
@@ -681,10 +681,9 @@ static intptr_t install_hash_code(Thread* current, oop obj) {
 }
 
 intptr_t ObjectSynchronizer::FastHashCode(Thread* current, oop obj) {
-  if (EnableValhalla && obj->klass()->is_inline_klass()) {
-    // VM should be calling bootstrap method
-    ShouldNotReachHere();
-  }
+  // VM should be calling bootstrap method.
+  assert(!obj->klass()->is_inline_klass(), "FastHashCode should not be called for inline classes");
+
   if (UseObjectMonitorTable) {
     // Since the monitor isn't in the object header, the hash can simply be
     // installed in the object header.
@@ -786,7 +785,7 @@ intptr_t ObjectSynchronizer::FastHashCode(Thread* current, oop obj) {
 
 bool ObjectSynchronizer::current_thread_holds_lock(JavaThread* current,
                                                    Handle h_obj) {
-  if (EnableValhalla && h_obj->mark().is_inline_type()) {
+  if (h_obj->mark().is_inline_type()) {
     return false;
   }
   assert(current == JavaThread::current(), "Can only be called on current thread");