diff a/test/hotspot/jtreg/compiler/c2/irTests/TestVectorizationMismatchedAccess.java b/test/hotspot/jtreg/compiler/c2/irTests/TestVectorizationMismatchedAccess.java
--- a/test/hotspot/jtreg/compiler/c2/irTests/TestVectorizationMismatchedAccess.java
+++ b/test/hotspot/jtreg/compiler/c2/irTests/TestVectorizationMismatchedAccess.java
@@ -150,11 +150,12 @@
     }
 
     @Test
     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
-        applyIfPlatform = {"64-bit", "true"})
+        applyIfPlatform = {"64-bit", "true"},
+        applyIf = {"UseCompactObjectHeaders", "false"})
     // 32-bit: offsets are badly aligned (UNSAFE.ARRAY_BYTE_BASE_OFFSET is 4 byte aligned, but not 8 byte aligned).
     //         might get fixed with JDK-8325155.
     public static void testByteLong1a(byte[] dest, long[] src) {
         for (int i = 0; i < src.length; i++) {
             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i, src[i]);
@@ -162,32 +163,35 @@
     }
 
     @Test
     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
-        applyIfPlatform = {"64-bit", "true"})
+        applyIfPlatform = {"64-bit", "true"},
+        applyIf = {"UseCompactObjectHeaders", "false"})
     // 32-bit: address has ConvL2I for cast of long to address, not supported.
     public static void testByteLong1b(byte[] dest, long[] src) {
         for (int i = 0; i < src.length; i++) {
             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * i, src[i]);
         }
     }
 
     @Test
     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
-        applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"})
+        applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
+        applyIf = {"UseCompactObjectHeaders", "false"})
     public static void testByteLong1c(byte[] dest, long[] src) {
         long base = 64; // make sure it is big enough and 8 byte aligned (required for 32-bit)
         for (int i = 0; i < src.length - 8; i++) {
             UNSAFE.putLongUnaligned(dest, base + 8 * i, src[i]);
         }
     }
 
     @Test
     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
-        applyIfPlatform = {"64-bit", "true"})
+        applyIfPlatform = {"64-bit", "true"},
+        applyIf = {"UseCompactObjectHeaders", "false"})
     // 32-bit: address has ConvL2I for cast of long to address, not supported.
     public static void testByteLong1d(byte[] dest, long[] src) {
         long base = 64; // make sure it is big enough and 8 byte aligned (required for 32-bit)
         for (int i = 0; i < src.length - 8; i++) {
             UNSAFE.putLongUnaligned(dest, base + 8L * i, src[i]);
@@ -203,11 +207,12 @@
     }
 
     @Test
     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
-        applyIfPlatform = {"64-bit", "true"})
+        applyIfPlatform = {"64-bit", "true"},
+        applyIf = {"UseCompactObjectHeaders", "false"})
     // 32-bit: offsets are badly aligned (UNSAFE.ARRAY_BYTE_BASE_OFFSET is 4 byte aligned, but not 8 byte aligned).
     //         might get fixed with JDK-8325155.
     public static void testByteLong2a(byte[] dest, long[] src) {
         for (int i = 1; i < src.length; i++) {
             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i - 1), src[i]);
@@ -215,11 +220,12 @@
     }
 
     @Test
     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
-        applyIfPlatform = {"64-bit", "true"})
+        applyIfPlatform = {"64-bit", "true"},
+        applyIf = {"UseCompactObjectHeaders", "false"})
     // 32-bit: address has ConvL2I for cast of long to address, not supported.
     public static void testByteLong2b(byte[] dest, long[] src) {
         for (int i = 1; i < src.length; i++) {
             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i - 1), src[i]);
         }
@@ -232,11 +238,12 @@
     }
 
     @Test
     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
-        applyIfPlatform = {"64-bit", "true"})
+        applyIfPlatform = {"64-bit", "true"},
+        applyIf = {"UseCompactObjectHeaders", "false"})
     // 32-bit: offsets are badly aligned (UNSAFE.ARRAY_BYTE_BASE_OFFSET is 4 byte aligned, but not 8 byte aligned).
     //         might get fixed with JDK-8325155.
     public static void testByteLong3a(byte[] dest, long[] src) {
         for (int i = 0; i < src.length - 1; i++) {
             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i + 1), src[i]);
@@ -244,11 +251,12 @@
     }
 
     @Test
     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
-        applyIfPlatform = {"64-bit", "true"})
+        applyIfPlatform = {"64-bit", "true"},
+        applyIf = {"UseCompactObjectHeaders", "false"})
     // 32-bit: address has ConvL2I for cast of long to address, not supported.
     public static void testByteLong3b(byte[] dest, long[] src) {
         for (int i = 0; i < src.length - 1; i++) {
             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i + 1), src[i]);
         }
@@ -291,11 +299,12 @@
     }
 
     @Test
     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
-        applyIfPlatform = {"64-bit", "true"})
+        applyIfPlatform = {"64-bit", "true"},
+        applyIf = {"UseCompactObjectHeaders", "false"})
     // 32-bit: offsets are badly aligned (UNSAFE.ARRAY_BYTE_BASE_OFFSET is 4 byte aligned, but not 8 byte aligned).
     //         might get fixed with JDK-8325155.
     public static void testByteLong5a(byte[] dest, long[] src, int start, int stop) {
         for (int i = start; i < stop; i++) {
             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i + baseOffset), src[i]);
@@ -303,11 +312,12 @@
     }
 
     @Test
     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
-        applyIfPlatform = {"64-bit", "true"})
+        applyIfPlatform = {"64-bit", "true"},
+        applyIf = {"UseCompactObjectHeaders", "false"})
     // 32-bit: address has ConvL2I for cast of long to address, not supported.
     public static void testByteLong5b(byte[] dest, long[] src, int start, int stop) {
         for (int i = start; i < stop; i++) {
             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i + baseOffset), src[i]);
         }
@@ -321,11 +331,12 @@
     }
 
     @Test
     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
-        applyIfPlatform = {"64-bit", "true"})
+        applyIfPlatform = {"64-bit", "true"},
+        applyIf = {"UseCompactObjectHeaders", "false"})
     // 32-bit: offsets are badly aligned (UNSAFE.ARRAY_BYTE_BASE_OFFSET is 4 byte aligned, but not 8 byte aligned).
     //         might get fixed with JDK-8325155.
     public static void testByteByte1a(byte[] dest, byte[] src) {
         for (int i = 0; i < src.length / 8; i++) {
             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i, UNSAFE.getLongUnaligned(src, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i));
@@ -333,11 +344,12 @@
     }
 
     @Test
     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
-        applyIfPlatform = {"64-bit", "true"})
+        applyIfPlatform = {"64-bit", "true"},
+        applyIf = {"UseCompactObjectHeaders", "false"})
     // 32-bit: address has ConvL2I for cast of long to address, not supported.
     public static void testByteByte1b(byte[] dest, byte[] src) {
         for (int i = 0; i < src.length / 8; i++) {
             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * i, UNSAFE.getLongUnaligned(src, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * i));
         }
