test/hotspot/jtreg/compiler/loopopts/superword/TestIndependentPacksWithCyclicDependency.java

*** 128,24 ***
          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)
--- 128,19 ---

*** 158,24 ***
          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() {
--- 153,19 ---

*** 187,24 ***
          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)
--- 177,19 ---

*** 217,11 ***
          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
--- 202,10 ---

*** 229,14 ***
              // 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)
--- 213,10 ---

*** 299,11 ***
          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) {
--- 279,10 ---

*** 318,14 ***
              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() {
--- 297,10 ---