diff a/test/hotspot/jtreg/compiler/loopopts/superword/TestIndependentPacksWithCyclicDependency.java b/test/hotspot/jtreg/compiler/loopopts/superword/TestIndependentPacksWithCyclicDependency.java
--- a/test/hotspot/jtreg/compiler/loopopts/superword/TestIndependentPacksWithCyclicDependency.java
+++ b/test/hotspot/jtreg/compiler/loopopts/superword/TestIndependentPacksWithCyclicDependency.java
@@ -128,24 +128,19 @@
         verify("test0", dataF, goldF0);
     }
 
     @Test
     @IR(counts = {IRNode.ADD_VI, "> 0", IRNode.MUL_VF, "> 0"},
-        applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
         applyIfPlatform = {"64-bit", "true"},
         applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true", "rvv", "true"})
     static void test0(int[] dataIa, int[] dataIb, float[] dataFa, float[] dataFb) {
         for (int i = 0; i < RANGE; i+=2) {
             // Hand-unrolled 2x. Int and Float slice are completely separate.
             dataIb[i+0] = dataIa[i+0] + 3;
             dataIb[i+1] = dataIa[i+1] + 3;
             dataFb[i+0] = dataFa[i+0] * 1.3f;
             dataFb[i+1] = dataFa[i+1] * 1.3f;
-            // With AlignVector, we need 8-byte alignment of vector loads/stores.
-            // UseCompactObjectHeaders=false                 UseCompactObjectHeaders=true
-            // adr = base + 16 + 8*i   ->  always            adr = base + 12 + 8*i   ->  never
-            // -> vectorize                                  -> no vectorization
         }
     }
 
     @Run(test = "test1")
     @Warmup(100)
@@ -158,24 +153,19 @@
         verify("test1", dataF, goldF1);
     }
 
     @Test
     @IR(counts = {IRNode.ADD_VI, "> 0", IRNode.MUL_VF, "> 0", IRNode.VECTOR_CAST_F2I, "> 0", IRNode.VECTOR_CAST_I2F, "> 0"},
-        applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
         applyIfPlatform = {"64-bit", "true"},
         applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true", "rvv", "true"})
     static void test1(int[] dataIa, int[] dataIb, float[] dataFa, float[] dataFb) {
         for (int i = 0; i < RANGE; i+=2) {
             // Hand-unrolled 2x. Converst to and from. StoreF -> LoadF dependency.
             dataFa[i+0] = dataIa[i+0] + 3;
             dataFa[i+1] = dataIa[i+1] + 3;
             dataIb[i+0] = (int)(dataFb[i+0] * 1.3f);
             dataIb[i+1] = (int)(dataFb[i+1] * 1.3f);
-            // With AlignVector, we need 8-byte alignment of vector loads/stores.
-            // UseCompactObjectHeaders=false                 UseCompactObjectHeaders=true
-            // adr = base + 16 + 8*i   ->  always            adr = base + 12 + 8*i   ->  never
-            // -> vectorize                                  -> no vectorization
         }
     }
 
     @Run(test = "test2")
     public void runTest2() {
@@ -187,24 +177,19 @@
         verify("test2", dataF, goldF2);
     }
 
     @Test
     @IR(counts = {IRNode.ADD_VI, "> 0", IRNode.MUL_VI, "> 0"},
-        applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
         applyIfPlatform = {"64-bit", "true"},
         applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true", "rvv", "true"})
     static void test2(int[] dataIa, int[] dataIb, float[] dataFa, float[] dataFb) {
         for (int i = 0; i < RANGE; i+=2) {
             // int and float arrays are two slices. But we pretend both are of type int.
             unsafe.putInt(dataFa, unsafe.ARRAY_FLOAT_BASE_OFFSET + 4L * i + 0, dataIa[i+0] + 1);
             unsafe.putInt(dataFa, unsafe.ARRAY_FLOAT_BASE_OFFSET + 4L * i + 4, dataIa[i+1] + 1);
             dataIb[i+0] = 11 * unsafe.getInt(dataFb, unsafe.ARRAY_INT_BASE_OFFSET + 4L * i + 0);
             dataIb[i+1] = 11 * unsafe.getInt(dataFb, unsafe.ARRAY_INT_BASE_OFFSET + 4L * i + 4);
-            // With AlignVector, we need 8-byte alignment of vector loads/stores.
-            // UseCompactObjectHeaders=false                 UseCompactObjectHeaders=true
-            // adr = base + 16 + 8*i   ->  always            adr = base + 12 + 8*i   ->  never
-            // -> vectorize                                  -> no vectorization
         }
     }
 
     @Run(test = "test3")
     @Warmup(100)
@@ -217,11 +202,10 @@
         verify("test3", dataF, goldF3);
     }
 
     @Test
     @IR(counts = {IRNode.ADD_VI, "> 0", IRNode.MUL_VF, "> 0"},
-        applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
         applyIfPlatform = {"64-bit", "true"},
         applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true", "rvv", "true"})
     static void test3(int[] dataIa, int[] dataIb, float[] dataFa, float[] dataFb) {
         for (int i = 0; i < RANGE; i+=2) {
             // Inversion of orders. But because we operate on separate slices, this should
@@ -229,14 +213,10 @@
             // reorder them.
             dataIb[i+0] = dataIa[i+0] + 3;
             dataFb[i+1] = dataFa[i+1] * 1.3f;
             dataFb[i+0] = dataFa[i+0] * 1.3f;
             dataIb[i+1] = dataIa[i+1] + 3;
-            // With AlignVector, we need 8-byte alignment of vector loads/stores.
-            // UseCompactObjectHeaders=false                 UseCompactObjectHeaders=true
-            // adr = base + 16 + 8*i   ->  always            adr = base + 12 + 8*i   ->  never
-            // -> vectorize                                  -> no vectorization
         }
     }
 
     @Run(test = "test4")
     @Warmup(100)
@@ -299,11 +279,10 @@
         verify("test6", dataL, goldL6);
     }
 
     @Test
     @IR(counts = {IRNode.ADD_VI, "> 0", IRNode.MUL_VI, "> 0", IRNode.ADD_VF, "> 0"},
-        applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
         applyIfPlatform = {"64-bit", "true"},
         applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true", "rvv", "true"})
     static void test6(int[] dataIa, int[] dataIb, float[] dataFa, float[] dataFb,
                       long[] dataLa, long[] dataLb) {
         for (int i = 0; i < RANGE; i+=2) {
@@ -318,14 +297,10 @@
             unsafe.putInt(dataLa, unsafe.ARRAY_LONG_BASE_OFFSET + 4L * i + 4, v11);
             float v20 = unsafe.getFloat(dataLb, unsafe.ARRAY_LONG_BASE_OFFSET + 4L * i + 0) + 0.55f;
             float v21 = unsafe.getFloat(dataLb, unsafe.ARRAY_LONG_BASE_OFFSET + 4L * i + 4) + 0.55f;
             unsafe.putFloat(dataIb, unsafe.ARRAY_INT_BASE_OFFSET + 4L * i + 0, v20);
             unsafe.putFloat(dataIb, unsafe.ARRAY_INT_BASE_OFFSET + 4L * i + 4, v21);
-            // With AlignVector, we need 8-byte alignment of vector loads/stores.
-            // UseCompactObjectHeaders=false                 UseCompactObjectHeaders=true
-            // adr = base + 16 + 8*i   ->  always            adr = base + 12 + 8*i   ->  never
-            // -> vectorize                                  -> no vectorization
         }
     }
 
     @Run(test = "test7")
     public void runTest7() {
