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

*** 150,11 ***
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
!         applyIfPlatform = {"64-bit", "true"})
      // 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]);
--- 150,12 ---
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "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 ***
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
!         applyIfPlatform = {"64-bit", "true"})
      // 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"})
      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"})
      // 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]);
--- 163,35 ---
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "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"},
+         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"},
+         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 ***
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
!         applyIfPlatform = {"64-bit", "true"})
      // 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]);
--- 207,12 ---
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "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 ***
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
!         applyIfPlatform = {"64-bit", "true"})
      // 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]);
          }
--- 220,12 ---
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "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 ***
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
!         applyIfPlatform = {"64-bit", "true"})
      // 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]);
--- 238,12 ---
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "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 ***
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
!         applyIfPlatform = {"64-bit", "true"})
      // 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]);
          }
--- 251,12 ---
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "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 ***
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
!         applyIfPlatform = {"64-bit", "true"})
      // 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]);
--- 299,12 ---
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "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 ***
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
!         applyIfPlatform = {"64-bit", "true"})
      // 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]);
          }
--- 312,12 ---
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "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 ***
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
!         applyIfPlatform = {"64-bit", "true"})
      // 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));
--- 331,12 ---
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "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 ***
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
!         applyIfPlatform = {"64-bit", "true"})
      // 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));
          }
--- 344,12 ---
      }
  
      @Test
      @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
          applyIfCPUFeatureOr = {"sse2", "true", "asimd", "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));
          }