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));
          }