diff a/src/hotspot/cpu/s390/macroAssembler_s390.cpp b/src/hotspot/cpu/s390/macroAssembler_s390.cpp
--- a/src/hotspot/cpu/s390/macroAssembler_s390.cpp
+++ b/src/hotspot/cpu/s390/macroAssembler_s390.cpp
@@ -3258,36 +3258,43 @@
     z_bru(done);
   }
 
   bind(object_has_monitor);
 
-  Register zero = temp;
-  Register monitor_tagged = displacedHeader; // Tagged with markWord::monitor_value.
-  // The object's monitor m is unlocked iff m->owner is null,
-  // otherwise m->owner may contain a thread or a stack address.
-
-  // Try to CAS m->owner from null to current thread.
-  // If m->owner is null, then csg succeeds and sets m->owner=THREAD and CR=EQ.
-  // Otherwise, register zero is filled with the current owner.
-  z_lghi(zero, 0);
-  z_csg(zero, Z_thread, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner), monitor_tagged);
-  if (LockingMode != LM_LIGHTWEIGHT) {
-    // Store a non-null value into the box.
-    z_stg(box, BasicLock::displaced_header_offset_in_bytes(), box);
-  }
-
-  z_bre(done); // acquired the lock for the first time.
-
-  BLOCK_COMMENT("fast_path_recursive_lock {");
-  // Check if we are already the owner (recursive lock)
-  z_cgr(Z_thread, zero); // owner is stored in zero by "z_csg" above
-  z_brne(done); // not a recursive lock
-
-  // Current thread already owns the lock. Just increment recursion count.
-  z_agsi(Address(monitor_tagged, OM_OFFSET_NO_MONITOR_VALUE_TAG(recursions)), 1ll);
-  z_cgr(zero, zero); // set the CC to EQUAL
-  BLOCK_COMMENT("} fast_path_recursive_lock");
+  if (!UseObjectMonitorTable) {
+    Register zero = temp;
+    Register monitor_tagged = displacedHeader; // Tagged with markWord::monitor_value.
+    // The object's monitor m is unlocked iff m->owner is null,
+    // otherwise m->owner may contain a thread or a stack address.
+
+    // Try to CAS m->owner from null to current thread.
+    // If m->owner is null, then csg succeeds and sets m->owner=THREAD and CR=EQ.
+    // Otherwise, register zero is filled with the current owner.
+    z_lghi(zero, 0);
+    z_csg(zero, Z_thread, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner), monitor_tagged);
+    if (LockingMode != LM_LIGHTWEIGHT) {
+      // Store a non-null value into the box.
+      z_stg(box, BasicLock::displaced_header_offset_in_bytes(), box);
+    }
+
+    z_bre(done); // acquired the lock for the first time.
+
+    BLOCK_COMMENT("fast_path_recursive_lock {");
+    // Check if we are already the owner (recursive lock)
+    z_cgr(Z_thread, zero); // owner is stored in zero by "z_csg" above
+    z_brne(done); // not a recursive lock
+
+    // Current thread already owns the lock. Just increment recursion count.
+    z_agsi(Address(monitor_tagged, OM_OFFSET_NO_MONITOR_VALUE_TAG(recursions)), 1ll);
+    z_cgr(zero, zero); // set the CC to EQUAL
+    BLOCK_COMMENT("} fast_path_recursive_lock");
+  } else {
+    // OMCache lookup not supported yet. Take the slowpath.
+    // Set flag to NE
+    z_ltgr(oop, oop);
+    z_bru(done);
+  }
   bind(done);
 
   BLOCK_COMMENT("} compiler_fast_lock_object");
   // If locking was successful, CR should indicate 'EQ'.
   // The compiler or the native wrapper generates a branch to the runtime call
@@ -3344,31 +3351,38 @@
   // This is handled like owner thread mismatches: We take the slow path.
 
   // Handle existing monitor.
   bind(object_has_monitor);
 
-  z_cg(Z_thread, Address(currentHeader, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)));
-  z_brne(done);
+  if (!UseObjectMonitorTable) {
+    z_cg(Z_thread, Address(currentHeader, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)));
+    z_brne(done);
 
-  BLOCK_COMMENT("fast_path_recursive_unlock {");
-  load_and_test_long(temp, Address(currentHeader, OM_OFFSET_NO_MONITOR_VALUE_TAG(recursions)));
-  z_bre(not_recursive); // if 0 then jump, it's not recursive locking
+    BLOCK_COMMENT("fast_path_recursive_unlock {");
+    load_and_test_long(temp, Address(currentHeader, OM_OFFSET_NO_MONITOR_VALUE_TAG(recursions)));
+    z_bre(not_recursive); // if 0 then jump, it's not recursive locking
 
-  // Recursive inflated unlock
-  z_agsi(Address(currentHeader, OM_OFFSET_NO_MONITOR_VALUE_TAG(recursions)), -1ll);
-  z_cgr(currentHeader, currentHeader); // set the CC to EQUAL
-  BLOCK_COMMENT("} fast_path_recursive_unlock");
-  z_bru(done);
+    // Recursive inflated unlock
+    z_agsi(Address(currentHeader, OM_OFFSET_NO_MONITOR_VALUE_TAG(recursions)), -1ll);
+    z_cgr(currentHeader, currentHeader); // set the CC to EQUAL
+    BLOCK_COMMENT("} fast_path_recursive_unlock");
+    z_bru(done);
 
-  bind(not_recursive);
+    bind(not_recursive);
 
-  load_and_test_long(temp, Address(currentHeader, OM_OFFSET_NO_MONITOR_VALUE_TAG(EntryList)));
-  z_brne(done);
-  load_and_test_long(temp, Address(currentHeader, OM_OFFSET_NO_MONITOR_VALUE_TAG(cxq)));
-  z_brne(done);
-  z_release();
-  z_stg(temp/*=0*/, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner), currentHeader);
+    load_and_test_long(temp, Address(currentHeader, OM_OFFSET_NO_MONITOR_VALUE_TAG(EntryList)));
+    z_brne(done);
+    load_and_test_long(temp, Address(currentHeader, OM_OFFSET_NO_MONITOR_VALUE_TAG(cxq)));
+    z_brne(done);
+    z_release();
+    z_stg(temp/*=0*/, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner), currentHeader);
+  } else {
+    // OMCache lookup not supported yet. Take the slowpath.
+    // Set flag to NE
+    z_ltgr(oop, oop);
+    z_bru(done);
+  }
 
   bind(done);
 
   BLOCK_COMMENT("} compiler_fast_unlock_object");
   // flag == EQ indicates success
@@ -3523,11 +3537,11 @@
 
   BLOCK_COMMENT("cKlass encoder {");
 
 #ifdef ASSERT
   Label ok;
-  z_tmll(current, KlassAlignmentInBytes-1); // Check alignment.
+  z_tmll(current, CompressedKlassPointers::klass_alignment_in_bytes() - 1); // Check alignment.
   z_brc(Assembler::bcondAllZero, ok);
   // The plain disassembler does not recognize illtrap. It instead displays
   // a 32-bit value. Issuing two illtraps assures the disassembler finds
   // the proper beginning of the next instruction.
   z_illtrap(0xee);
@@ -3537,11 +3551,10 @@
 
   // Scale down the incoming klass pointer first.
   // We then can be sure we calculate an offset that fits into 32 bit.
   // More generally speaking: all subsequent calculations are purely 32-bit.
   if (shift != 0) {
-    assert (LogKlassAlignmentInBytes == shift, "decode alg wrong");
     z_srlg(dst, current, shift);
     current = dst;
   }
 
   if (base != nullptr) {
@@ -3667,11 +3680,11 @@
     }
   }
 
 #ifdef ASSERT
   Label ok;
-  z_tmll(dst, KlassAlignmentInBytes-1); // Check alignment.
+  z_tmll(dst, CompressedKlassPointers::klass_alignment_in_bytes() - 1); // Check alignment.
   z_brc(Assembler::bcondAllZero, ok);
   // The plain disassembler does not recognize illtrap. It instead displays
   // a 32-bit value. Issuing two illtraps assures the disassembler finds
   // the proper beginning of the next instruction.
   z_illtrap(0xd1);
@@ -3714,11 +3727,11 @@
     }
   }
 
 #ifdef ASSERT
   Label ok;
-  z_tmll(dst, KlassAlignmentInBytes-1); // Check alignment.
+  z_tmll(dst, CompressedKlassPointers::klass_alignment_in_bytes() - 1); // Check alignment.
   z_brc(Assembler::bcondAllZero, ok);
   // The plain disassembler does not recognize illtrap. It instead displays
   // a 32-bit value. Issuing two illtraps assures the disassembler finds
   // the proper beginning of the next instruction.
   z_illtrap(0xd2);
@@ -3783,11 +3796,15 @@
 
   if (UseCompressedClassPointers) {
     const int shift = CompressedKlassPointers::shift();
     address   base  = CompressedKlassPointers::base();
 
-    assert((shift == 0) || (shift == LogKlassAlignmentInBytes), "cKlass encoder detected bad shift");
+    if (CompressedKlassPointers::tiny_classpointer_mode()) {
+      assert(shift >= 3, "cKlass encoder detected bad shift");
+    } else {
+      assert((shift == 0) || (shift == 3), "cKlass encoder detected bad shift");
+    }
     assert_different_registers(Rop1, Z_R0);
     assert_different_registers(Rop1, Rbase, Z_R1);
 
     // First encode register oop and then compare with cOop in memory.
     // This sequence saves an unnecessary cOop load and decode.
