test/hotspot/jtreg/compiler/c2/irTests/TestVectorizationMismatchedAccess.java

*** 145,11 ***
              }
          }
      }
  
      @Test
!     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
      public static void testByteLong1(byte[] dest, long[] src) {
          for (int i = 0; i < src.length; i++) {
              UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i, src[i]);
          }
      }
--- 145,12 ---
              }
          }
      }
  
      @Test
!     @IR(applyIf = {"UseCompactObjectHeaders", "false"},
+         counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
      public static void testByteLong1(byte[] dest, long[] src) {
          for (int i = 0; i < src.length; i++) {
              UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i, src[i]);
          }
      }

*** 158,11 ***
      public static void testByteLong1_runner() {
          runAndVerify(() -> testByteLong1(byteArray, longArray), 0);
      }
  
      @Test
!     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
      public static void testByteLong2(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]);
          }
      }
--- 159,12 ---
      public static void testByteLong1_runner() {
          runAndVerify(() -> testByteLong1(byteArray, longArray), 0);
      }
  
      @Test
!     @IR(applyIf = {"UseCompactObjectHeaders", "false"},
+         counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
      public static void testByteLong2(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]);
          }
      }

*** 171,11 ***
      public static void testByteLong2_runner() {
          runAndVerify(() -> testByteLong2(byteArray, longArray), -8);
      }
  
      @Test
!     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
      public static void testByteLong3(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]);
          }
      }
--- 173,12 ---
      public static void testByteLong2_runner() {
          runAndVerify(() -> testByteLong2(byteArray, longArray), -8);
      }
  
      @Test
!     @IR(applyIf = {"UseCompactObjectHeaders", "false"},
+         counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
      public static void testByteLong3(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]);
          }
      }

*** 200,11 ***
          baseOffset = UNSAFE.ARRAY_BYTE_BASE_OFFSET;
          runAndVerify(() -> testByteLong4(byteArray, longArray, 0, size), 0);
      }
  
      @Test
!     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
      public static void testByteLong5(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]);
          }
      }
--- 203,12 ---
          baseOffset = UNSAFE.ARRAY_BYTE_BASE_OFFSET;
          runAndVerify(() -> testByteLong4(byteArray, longArray, 0, size), 0);
      }
  
      @Test
!     @IR(applyIf = {"UseCompactObjectHeaders", "false"},
+         counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
      public static void testByteLong5(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]);
          }
      }

*** 214,11 ***
          baseOffset = 1;
          runAndVerify(() -> testByteLong5(byteArray, longArray, 0, size-1), 8);
      }
  
      @Test
!     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
      public static void testByteByte1(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));
          }
      }
--- 218,12 ---
          baseOffset = 1;
          runAndVerify(() -> testByteLong5(byteArray, longArray, 0, size-1), 8);
      }
  
      @Test
!     @IR(applyIf = {"UseCompactObjectHeaders", "false"},
+         counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
      public static void testByteByte1(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));
          }
      }

*** 227,11 ***
      public static void testByteByte1_runner() {
          runAndVerify2(() -> testByteByte1(byteArray, byteArray), 0);
      }
  
      @Test
!     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
      public static void testByteByte2(byte[] dest, byte[] src) {
          for (int i = 1; i < src.length / 8; i++) {
              UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i - 1), UNSAFE.getLongUnaligned(src, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i));
          }
      }
--- 232,12 ---
      public static void testByteByte1_runner() {
          runAndVerify2(() -> testByteByte1(byteArray, byteArray), 0);
      }
  
      @Test
!     @IR(applyIf = {"UseCompactObjectHeaders", "false"},
+         counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
      public static void testByteByte2(byte[] dest, byte[] src) {
          for (int i = 1; i < src.length / 8; i++) {
              UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i - 1), UNSAFE.getLongUnaligned(src, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i));
          }
      }