/* * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ /* * @test * @bug 8367483 * @summary Reproducing case from 8367483 * @library /test/lib / * @run driver compiler.c2.Test_8367483 */ package compiler.c2; // --- IMPORTS start --- import compiler.lib.ir_framework.*; import java.lang.foreign.*; import java.util.Random; import compiler.lib.generators.*; import compiler.lib.verify.*; import jdk.test.lib.Utils; // --- IMPORTS end --- public class Test_8367483 { // --- CLASS_HOOK insertions start --- // --- CLASS_HOOK insertions end --- public static void main(String[] vmFlags) { TestFramework framework = new TestFramework(Test_8367483.class); framework.addFlags(vmFlags); framework.start(); } // --- LIST OF TESTS start --- private static final Random RANDOM = Utils.getRandomInstance(); public static record IndexForm(int con, int ivScale, int invar0Scale, int[] invarRestScales, int size) { public IndexForm { if (ivScale == 0 || invar0Scale == 0) { throw new RuntimeException("Bad scales: " + ivScale + " " + invar0Scale); } } public static record Range(int lo, int hi) { public Range { if (lo >= hi) { throw new RuntimeException("Bad range: " + lo + " " + hi); } } } public int err() { int sum = 0; for (int scale : invarRestScales) { sum += Math.abs(scale); } return sum; } public int invar0ForIvLo(Range range, int ivLo) { if (ivScale > 0) { // index(iv) is smallest for iv = ivLo, so we must satisfy: // range.lo <= con + iv.lo * ivScale + invar0 * invar0Scale + invarRest // <= con + iv.lo * ivScale + invar0 * invar0Scale - err // It follows: // invar0 * invar0Scale >= range.lo - con - iv.lo * ivScale + err int rhs = range.lo() - con - ivLo * ivScale + err(); int invar0 = (invar0Scale > 0) ? // invar0 * invar0Scale >= range.lo - con - iv.lo * ivScale + err // invar0 >= (range.lo - con - iv.lo * ivScale + err) / invar0Scale Math.floorDiv(rhs + invar0Scale - 1, invar0Scale) // round up division : // invar0 * invar0Scale >= range.lo - con - iv.lo * ivScale + err // invar0 <= (range.lo - con - iv.lo * ivScale + err) / invar0Scale Math.floorDiv(rhs, invar0Scale); // round down division if (range.lo() > con + ivLo * ivScale + invar0 * invar0Scale - err()) { throw new RuntimeException("sanity check failed (1)"); } return invar0; } else { // index(iv) is largest for iv = ivLo, so we must satisfy: // range.hi >= con + iv.lo * ivScale + invar0 * invar0Scale + invarRest + size // >= con + iv.lo * ivScale + invar0 * invar0Scale + err + size // It follows: // invar0 * invar0Scale <= range.hi - con - iv.lo * ivScale - err - size int rhs = range.hi() - con - ivLo * ivScale - err() - size(); int invar0 = (invar0Scale > 0) ? // invar0 * invar0Scale <= rhs // invar0 <= rhs / invar0Scale Math.floorDiv(rhs, invar0Scale) // round down division : // invar0 * invar0Scale <= rhs // invar0 >= rhs / invar0Scale Math.floorDiv(rhs + invar0Scale + 1, invar0Scale); // round up division if (range.hi() < con + ivLo * ivScale + invar0 * invar0Scale + err() + size()) { throw new RuntimeException("sanity check failed (2)"); } return invar0; } } public int ivHiForInvar0(Range range, int invar0) { if (ivScale > 0) { // index(iv) is largest for iv = ivHi, so we must satisfy: // range.hi >= con + iv.hi * ivScale + invar0 * invar0Scale + invarRest + size // >= con + iv.hi * ivScale + invar0 * invar0Scale + err + size // It follows: // iv.hi * ivScale <= range.hi - con - invar0 * invar0Scale - err - size // iv.hi <= (range.hi - con - invar0 * invar0Scale - err - size) / ivScale int rhs = range.hi() - con - invar0 * invar0Scale - err() - size(); int ivHi = Math.floorDiv(rhs, ivScale); // round down division if (range.hi() < con + ivHi * ivScale + invar0 * invar0Scale + err() + size()) { throw new RuntimeException("sanity check failed (3)"); } return ivHi; } else { // index(iv) is smallest for iv = ivHi, so we must satisfy: // range.lo <= con + iv.hi * ivScale + invar0 * invar0Scale + invarRest // <= con + iv.hi * ivScale + invar0 * invar0Scale - err // It follows: // iv.hi * ivScale >= range.lo - con - invar0 * invar0Scale + err // iv.hi <= (range.lo - con - invar0 * invar0Scale + err) / ivScale int rhs = range.lo() - con - invar0 * invar0Scale + err(); int ivHi = Math.floorDiv(rhs, ivScale); // round down division if (range.lo() > con + ivHi * ivScale + invar0 * invar0Scale - err()) { throw new RuntimeException("sanity check failed (4)"); } return ivHi; } } } // --- test_3 start --- // invarRest fields: // Containers fields: private static char[] original_container0_3 = new char[18788]; private static char[] test_container0_3 = new char[18788]; private static char[] reference_container0_3 = new char[18788]; private static char[] original_container1_3 = new char[18788]; private static char[] test_container1_3 = new char[18788]; private static char[] reference_container1_3 = new char[18788]; // Index forms for the accesses: private static IndexForm index0_3 = new IndexForm(56784, 1, -1, new int[] {}, 1); private static IndexForm index1_3 = new IndexForm(-16368, 1, -1, new int[] {}, 1); // Count the run invocations. private static int iterations_3 = 0; @Run(test = "test_3") @Warmup(100) public static void run_3(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_3++; // Init containers from original data: System.arraycopy(original_container0_3, 0, test_container0_3, 0, 18788); System.arraycopy(original_container0_3, 0, reference_container0_3, 0, 18788); System.arraycopy(original_container1_3, 0, test_container1_3, 0, 18788); System.arraycopy(original_container1_3, 0, reference_container1_3, 0, 18788); // Container aliasing: var test_0 = (iterations_3 % 2 == 0) ? test_container0_3 : test_container0_3; var reference_0 = (iterations_3 % 2 == 0) ? reference_container0_3 : reference_container0_3; var test_1 = (iterations_3 % 2 == 0) ? test_container1_3 : test_container0_3; var reference_1 = (iterations_3 % 2 == 0) ? reference_container1_3 : reference_container0_3; // Generate ranges: int middle = RANDOM.nextInt(18788 / 3, 18788 * 2 / 3); int rnd = Math.min(256, 18788 / 10); int range = 18788 / 3 - RANDOM.nextInt(rnd); var r0 = new IndexForm.Range(0, middle); var r1 = new IndexForm.Range(middle, 18788); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 37576; int invar0_0 = index0_3.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_3.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_3.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_3.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(56784 + 1 * i + -1 * invar0_0); int lo_1 = (int)(-16368 + 1 * i + -1 * invar0_1); i = ivHi; int hi_0 = (int)(56784 + 1 * i + -1 * invar0_0); int hi_1 = (int)(-16368 + 1 * i + -1 * invar0_1); // Bounds should not overlap. if (false || (lo_1 < lo_0 && lo_1 < hi_0 && hi_1 < lo_0 && hi_1 < hi_0) || (lo_1 > lo_0 && lo_1 > hi_0 && hi_1 > lo_0 && hi_1 > hi_0) ) { // pass } else { throw new RuntimeException("bounds overlap!"); } // Run test and compare with interpreter results. var result = test_3(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_3(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_3 @Test // Good ivScales, vectorization expected. @IR(counts = {IRNode.LOAD_VECTOR_C, "> 0", IRNode.STORE_VECTOR, "> 0"}, applyIfAnd = {"UseAutoVectorizationSpeculativeAliasingChecks", "true", "AlignVector", "false"}, applyIfPlatform = {"64-bit", "true"}, applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) // Aliasing check should never fail at runtime, so the predicate // should never fail, and we do not have to use multiversioning. // Failure could have a few causes: // - issues with doing RCE / missing predicates // -> other loop-opts need to be fixed // - predicate fails: recompile with multiversioning // -> logic in runtime check may be wrong @IR(counts = {".*multiversion.*", "= 0"}, phase = CompilePhase.PRINT_IDEAL, applyIf = {"UseAutoVectorizationPredicate", "true"}, applyIfPlatform = {"64-bit", "true"}, applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) public static Object test_3(char[] container_0, int invar0_0, char[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { container_0[56784 + 1 * i + -1 * invar0_0] = container_1[-16368 + 1 * i + -1 * invar0_1]; } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_3(char[] container_0, int invar0_0, char[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { container_0[56784 + 1 * i + -1 * invar0_0] = container_1[-16368 + 1 * i + -1 * invar0_1]; } return new Object[] { container_0, container_1 }; } // --- test_3 end --- // --- test_37 start --- // invarRest fields: private static int invar0_37 = 0; private static int invar1_37 = 0; private static int invar2_37 = 0; // Containers fields: private static int[] original_container0_37 = new int[19683]; private static int[] test_container0_37 = new int[19683]; private static int[] reference_container0_37 = new int[19683]; private static int[] original_container1_37 = new int[19683]; private static int[] test_container1_37 = new int[19683]; private static int[] reference_container1_37 = new int[19683]; // Index forms for the accesses: private static IndexForm index0_37 = new IndexForm(64828, -1, -4, new int[] {1, -1, 1}, 1); private static IndexForm index1_37 = new IndexForm(87951, 1, 1, new int[] {0, 1, 1}, 1); // Count the run invocations. private static int iterations_37 = 0; @Run(test = "test_37") @Warmup(100) public static void run_37(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_37++; // Init containers from original data: System.arraycopy(original_container0_37, 0, test_container0_37, 0, 19683); System.arraycopy(original_container0_37, 0, reference_container0_37, 0, 19683); System.arraycopy(original_container1_37, 0, test_container1_37, 0, 19683); System.arraycopy(original_container1_37, 0, reference_container1_37, 0, 19683); // Container aliasing: var test_0 = (iterations_37 % 2 == 0) ? test_container0_37 : test_container0_37; var reference_0 = (iterations_37 % 2 == 0) ? reference_container0_37 : reference_container0_37; var test_1 = (iterations_37 % 2 == 0) ? test_container0_37 : test_container0_37; var reference_1 = (iterations_37 % 2 == 0) ? reference_container0_37 : reference_container0_37; // Generate ranges: int lo0 = RANDOM.nextInt(0, 19683 * 3 / 4); int lo1 = RANDOM.nextInt(0, 19683 * 3 / 4); var r0 = new IndexForm.Range(lo0, lo0 + 19683 / 4); var r1 = new IndexForm.Range(lo1, lo1 + 19683 / 4); // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 78732; int invar0_0 = index0_37.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_37.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_37.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_37.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_37 = RANDOM.nextInt(-1, 2); invar1_37 = RANDOM.nextInt(-1, 2); invar2_37 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(64828 + -1 * i + -4 * invar0_0 + 1 * invar0_37 + -1 * invar1_37 + 1 * invar2_37); int lo_1 = (int)(87951 + 1 * i + 1 * invar0_1 + 0 * invar0_37 + 1 * invar1_37 + 1 * invar2_37); i = ivHi; int hi_0 = (int)(64828 + -1 * i + -4 * invar0_0 + 1 * invar0_37 + -1 * invar1_37 + 1 * invar2_37); int hi_1 = (int)(87951 + 1 * i + 1 * invar0_1 + 0 * invar0_37 + 1 * invar1_37 + 1 * invar2_37); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_37(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_37(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_37 @Test // Bad ivScales, no vectorization expected. @IR(counts = {IRNode.LOAD_VECTOR_I, "= 0", IRNode.STORE_VECTOR, "= 0"}, applyIfPlatform = {"64-bit", "true"}, applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) // Aliasing unknown, we may use the predicate or multiversioning. public static Object test_37(int[] container_0, int invar0_0, int[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { container_0[64828 + -1 * i + -4 * invar0_0 + 1 * invar0_37 + -1 * invar1_37 + 1 * invar2_37] = container_1[87951 + 1 * i + 1 * invar0_1 + 0 * invar0_37 + 1 * invar1_37 + 1 * invar2_37]; } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_37(int[] container_0, int invar0_0, int[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { container_0[64828 + -1 * i + -4 * invar0_0 + 1 * invar0_37 + -1 * invar1_37 + 1 * invar2_37] = container_1[87951 + 1 * i + 1 * invar0_1 + 0 * invar0_37 + 1 * invar1_37 + 1 * invar2_37]; } return new Object[] { container_0, container_1 }; } // --- test_37 end --- // --- test_71 start --- // invarRest fields: private static int invar0_71 = 0; private static int invar1_71 = 0; private static int invar2_71 = 0; // Containers fields: private static int[] original_container0_71 = new int[19260]; private static int[] test_container0_71 = new int[19260]; private static int[] reference_container0_71 = new int[19260]; private static int[] original_container1_71 = new int[19260]; private static int[] test_container1_71 = new int[19260]; private static int[] reference_container1_71 = new int[19260]; // Index forms for the accesses: private static IndexForm index0_71 = new IndexForm(-89228, -1, 1, new int[] {0, -1, 1}, 1); private static IndexForm index1_71 = new IndexForm(-14422, -1, -1, new int[] {0, -1, 0}, 1); // Count the run invocations. private static int iterations_71 = 0; @Run(test = "test_71") @Warmup(100) public static void run_71(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_71++; // Init containers from original data: System.arraycopy(original_container0_71, 0, test_container0_71, 0, 19260); System.arraycopy(original_container0_71, 0, reference_container0_71, 0, 19260); System.arraycopy(original_container1_71, 0, test_container1_71, 0, 19260); System.arraycopy(original_container1_71, 0, reference_container1_71, 0, 19260); // Container aliasing: var test_0 = (iterations_71 % 2 == 0) ? test_container0_71 : test_container0_71; var reference_0 = (iterations_71 % 2 == 0) ? reference_container0_71 : reference_container0_71; var test_1 = (iterations_71 % 2 == 0) ? test_container1_71 : test_container0_71; var reference_1 = (iterations_71 % 2 == 0) ? reference_container1_71 : reference_container0_71; // Generate ranges: int middle = RANDOM.nextInt(19260 / 3, 19260 * 2 / 3); int rnd = Math.min(256, 19260 / 10); int range = 19260 / 3 - RANDOM.nextInt(rnd); var r0 = new IndexForm.Range(middle - range, middle); var r1 = new IndexForm.Range(middle, middle + range); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 77040; int invar0_0 = index0_71.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_71.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_71.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_71.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_71 = RANDOM.nextInt(-1, 2); invar1_71 = RANDOM.nextInt(-1, 2); invar2_71 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(-89228 + -1 * i + 1 * invar0_0 + 0 * invar0_71 + -1 * invar1_71 + 1 * invar2_71); int lo_1 = (int)(-14422 + -1 * i + -1 * invar0_1 + 0 * invar0_71 + -1 * invar1_71 + 0 * invar2_71); i = ivHi; int hi_0 = (int)(-89228 + -1 * i + 1 * invar0_0 + 0 * invar0_71 + -1 * invar1_71 + 1 * invar2_71); int hi_1 = (int)(-14422 + -1 * i + -1 * invar0_1 + 0 * invar0_71 + -1 * invar1_71 + 0 * invar2_71); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_71(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_71(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_71 @Test // Good ivScales, vectorization expected. @IR(counts = {IRNode.LOAD_VECTOR_I, "= 0", IRNode.STORE_VECTOR, "> 0"}, applyIfAnd = {"UseAutoVectorizationSpeculativeAliasingChecks", "true", "AlignVector", "false"}, applyIfPlatform = {"64-bit", "true"}, applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) // Aliasing unknown, we may use the predicate or multiversioning. public static Object test_71(int[] container_0, int invar0_0, int[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { container_0[-89228 + -1 * i + 1 * invar0_0 + 0 * invar0_71 + -1 * invar1_71 + 1 * invar2_71] = (int)0x0102030405060708L; container_1[-14422 + -1 * i + -1 * invar0_1 + 0 * invar0_71 + -1 * invar1_71 + 0 * invar2_71] = (int)0x1112131415161718L; } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_71(int[] container_0, int invar0_0, int[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { container_0[-89228 + -1 * i + 1 * invar0_0 + 0 * invar0_71 + -1 * invar1_71 + 1 * invar2_71] = (int)0x0102030405060708L; container_1[-14422 + -1 * i + -1 * invar0_1 + 0 * invar0_71 + -1 * invar1_71 + 0 * invar2_71] = (int)0x1112131415161718L; } return new Object[] { container_0, container_1 }; } // --- test_71 end --- // --- test_105 start --- // invarRest fields: private static int invar0_105 = 0; private static int invar1_105 = 0; // Containers fields: private static float[] original_container0_105 = new float[18417]; private static float[] test_container0_105 = new float[18417]; private static float[] reference_container0_105 = new float[18417]; private static float[] original_container1_105 = new float[18417]; private static float[] test_container1_105 = new float[18417]; private static float[] reference_container1_105 = new float[18417]; // Index forms for the accesses: private static IndexForm index0_105 = new IndexForm(83259, -3, -1, new int[] {1, 1}, 1); private static IndexForm index1_105 = new IndexForm(-23353, -1, 1, new int[] {1, 1}, 1); // Count the run invocations. private static int iterations_105 = 0; @Run(test = "test_105") @Warmup(100) public static void run_105(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_105++; // Init containers from original data: System.arraycopy(original_container0_105, 0, test_container0_105, 0, 18417); System.arraycopy(original_container0_105, 0, reference_container0_105, 0, 18417); System.arraycopy(original_container1_105, 0, test_container1_105, 0, 18417); System.arraycopy(original_container1_105, 0, reference_container1_105, 0, 18417); // Container aliasing: var test_0 = (iterations_105 % 2 == 0) ? test_container0_105 : test_container0_105; var reference_0 = (iterations_105 % 2 == 0) ? reference_container0_105 : reference_container0_105; var test_1 = (iterations_105 % 2 == 0) ? test_container1_105 : test_container0_105; var reference_1 = (iterations_105 % 2 == 0) ? reference_container1_105 : reference_container0_105; // Generate ranges: int middle = RANDOM.nextInt(18417 / 3, 18417 * 2 / 3); int rnd = Math.min(256, 18417 / 10); int range = 18417 / 3 - RANDOM.nextInt(rnd); var r0 = new IndexForm.Range(middle - range, middle); var r1 = new IndexForm.Range(middle, middle + range); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 73668; int invar0_0 = index0_105.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_105.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_105.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_105.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_105 = RANDOM.nextInt(-1, 2); invar1_105 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(83259 + -3 * i + -1 * invar0_0 + 1 * invar0_105 + 1 * invar1_105); int lo_1 = (int)(-23353 + -1 * i + 1 * invar0_1 + 1 * invar0_105 + 1 * invar1_105); i = ivHi; int hi_0 = (int)(83259 + -3 * i + -1 * invar0_0 + 1 * invar0_105 + 1 * invar1_105); int hi_1 = (int)(-23353 + -1 * i + 1 * invar0_1 + 1 * invar0_105 + 1 * invar1_105); // Bounds should not overlap. if (false || (lo_1 < lo_0 && lo_1 < hi_0 && hi_1 < lo_0 && hi_1 < hi_0) || (lo_1 > lo_0 && lo_1 > hi_0 && hi_1 > lo_0 && hi_1 > hi_0) ) { // pass } else { throw new RuntimeException("bounds overlap!"); } // Run test and compare with interpreter results. var result = test_105(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_105(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_105 @Test // Good ivScales, vectorization expected. @IR(counts = {IRNode.LOAD_VECTOR_F, "= 0", IRNode.STORE_VECTOR, "> 0"}, applyIfAnd = {"UseAutoVectorizationSpeculativeAliasingChecks", "true", "AlignVector", "false"}, applyIfPlatform = {"64-bit", "true"}, applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) // Aliasing check should never fail at runtime, so the predicate // should never fail, and we do not have to use multiversioning. // Failure could have a few causes: // - issues with doing RCE / missing predicates // -> other loop-opts need to be fixed // - predicate fails: recompile with multiversioning // -> logic in runtime check may be wrong @IR(counts = {".*multiversion.*", "= 0"}, phase = CompilePhase.PRINT_IDEAL, applyIf = {"UseAutoVectorizationPredicate", "true"}, applyIfPlatform = {"64-bit", "true"}, applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) public static Object test_105(float[] container_0, int invar0_0, float[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { container_0[83259 + -3 * i + -1 * invar0_0 + 1 * invar0_105 + 1 * invar1_105] = (float)0x0102030405060708L; container_1[-23353 + -1 * i + 1 * invar0_1 + 1 * invar0_105 + 1 * invar1_105] = (float)0x1112131415161718L; } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_105(float[] container_0, int invar0_0, float[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { container_0[83259 + -3 * i + -1 * invar0_0 + 1 * invar0_105 + 1 * invar1_105] = (float)0x0102030405060708L; container_1[-23353 + -1 * i + 1 * invar0_1 + 1 * invar0_105 + 1 * invar1_105] = (float)0x1112131415161718L; } return new Object[] { container_0, container_1 }; } // --- test_105 end --- // --- test_139 start --- // invarRest fields: private static int invar0_139 = 0; private static int invar1_139 = 0; private static int invar2_139 = 0; private static int invar3_139 = 0; // Containers fields: private static char[] original_container0_139 = new char[18162]; private static char[] test_container0_139 = new char[18162]; private static char[] reference_container0_139 = new char[18162]; private static char[] original_container1_139 = new char[18162]; private static char[] test_container1_139 = new char[18162]; private static char[] reference_container1_139 = new char[18162]; // Index forms for the accesses: private static IndexForm index0_139 = new IndexForm(31637, 1, -1, new int[] {-1, 1, -1, 0}, 1); private static IndexForm index1_139 = new IndexForm(4917, 1, -1, new int[] {0, -1, -1, 1}, 1); // Count the run invocations. private static int iterations_139 = 0; @Run(test = "test_139") @Warmup(100) public static void run_139(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_139++; // Init containers from original data: System.arraycopy(original_container0_139, 0, test_container0_139, 0, 18162); System.arraycopy(original_container0_139, 0, reference_container0_139, 0, 18162); System.arraycopy(original_container1_139, 0, test_container1_139, 0, 18162); System.arraycopy(original_container1_139, 0, reference_container1_139, 0, 18162); // Container aliasing: var test_0 = (iterations_139 % 2 == 0) ? test_container0_139 : test_container0_139; var reference_0 = (iterations_139 % 2 == 0) ? reference_container0_139 : reference_container0_139; var test_1 = (iterations_139 % 2 == 0) ? test_container0_139 : test_container0_139; var reference_1 = (iterations_139 % 2 == 0) ? reference_container0_139 : reference_container0_139; // Generate ranges: var r0 = new IndexForm.Range(0, 18162); var r1 = new IndexForm.Range(0, 18162); // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 36324; int invar0_0 = index0_139.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_139.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_139.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_139.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_139 = RANDOM.nextInt(-1, 2); invar1_139 = RANDOM.nextInt(-1, 2); invar2_139 = RANDOM.nextInt(-1, 2); invar3_139 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(31637 + 1 * i + -1 * invar0_0 + -1 * invar0_139 + 1 * invar1_139 + -1 * invar2_139 + 0 * invar3_139); int lo_1 = (int)(4917 + 1 * i + -1 * invar0_1 + 0 * invar0_139 + -1 * invar1_139 + -1 * invar2_139 + 1 * invar3_139); i = ivHi; int hi_0 = (int)(31637 + 1 * i + -1 * invar0_0 + -1 * invar0_139 + 1 * invar1_139 + -1 * invar2_139 + 0 * invar3_139); int hi_1 = (int)(4917 + 1 * i + -1 * invar0_1 + 0 * invar0_139 + -1 * invar1_139 + -1 * invar2_139 + 1 * invar3_139); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_139(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_139(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_139 @Test // Good ivScales, vectorization expected. @IR(counts = {IRNode.LOAD_VECTOR_C, "> 0", IRNode.STORE_VECTOR, "> 0"}, applyIfAnd = {"UseAutoVectorizationSpeculativeAliasingChecks", "true", "AlignVector", "false"}, applyIfPlatform = {"64-bit", "true"}, applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) // Aliasing unknown, we may use the predicate or multiversioning. public static Object test_139(char[] container_0, int invar0_0, char[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { container_0[31637 + 1 * i + -1 * invar0_0 + -1 * invar0_139 + 1 * invar1_139 + -1 * invar2_139 + 0 * invar3_139] = container_1[4917 + 1 * i + -1 * invar0_1 + 0 * invar0_139 + -1 * invar1_139 + -1 * invar2_139 + 1 * invar3_139]; } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_139(char[] container_0, int invar0_0, char[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { container_0[31637 + 1 * i + -1 * invar0_0 + -1 * invar0_139 + 1 * invar1_139 + -1 * invar2_139 + 0 * invar3_139] = container_1[4917 + 1 * i + -1 * invar0_1 + 0 * invar0_139 + -1 * invar1_139 + -1 * invar2_139 + 1 * invar3_139]; } return new Object[] { container_0, container_1 }; } // --- test_139 end --- // --- test_173 start --- // invarRest fields: // Containers fields: private static long[] original_container0_173 = new long[18380]; private static long[] test_container0_173 = new long[18380]; private static long[] reference_container0_173 = new long[18380]; private static long[] original_container1_173 = new long[18380]; private static long[] test_container1_173 = new long[18380]; private static long[] reference_container1_173 = new long[18380]; // Index forms for the accesses: private static IndexForm index0_173 = new IndexForm(12334, 1, -1, new int[] {}, 1); private static IndexForm index1_173 = new IndexForm(8635, -1, -1, new int[] {}, 1); // Count the run invocations. private static int iterations_173 = 0; @Run(test = "test_173") @Warmup(100) public static void run_173(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_173++; // Init containers from original data: System.arraycopy(original_container0_173, 0, test_container0_173, 0, 18380); System.arraycopy(original_container0_173, 0, reference_container0_173, 0, 18380); System.arraycopy(original_container1_173, 0, test_container1_173, 0, 18380); System.arraycopy(original_container1_173, 0, reference_container1_173, 0, 18380); // Container aliasing: var test_0 = (iterations_173 % 2 == 0) ? test_container0_173 : test_container0_173; var reference_0 = (iterations_173 % 2 == 0) ? reference_container0_173 : reference_container0_173; var test_1 = (iterations_173 % 2 == 0) ? test_container1_173 : test_container0_173; var reference_1 = (iterations_173 % 2 == 0) ? reference_container1_173 : reference_container0_173; // Generate ranges: int middle = RANDOM.nextInt(18380 / 3, 18380 * 2 / 3); int rnd = Math.min(256, 18380 / 10); int range = 18380 / 3 - RANDOM.nextInt(rnd); var r0 = new IndexForm.Range(middle - range, middle); var r1 = new IndexForm.Range(middle, middle + range); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 147040; int invar0_0 = index0_173.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_173.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_173.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_173.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(12334 + 1 * i + -1 * invar0_0); int lo_1 = (int)(8635 + -1 * i + -1 * invar0_1); i = ivHi; int hi_0 = (int)(12334 + 1 * i + -1 * invar0_0); int hi_1 = (int)(8635 + -1 * i + -1 * invar0_1); // Bounds should not overlap. if (false || (lo_1 < lo_0 && lo_1 < hi_0 && hi_1 < lo_0 && hi_1 < hi_0) || (lo_1 > lo_0 && lo_1 > hi_0 && hi_1 > lo_0 && hi_1 > hi_0) ) { // pass } else { throw new RuntimeException("bounds overlap!"); } // Run test and compare with interpreter results. var result = test_173(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_173(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_173 @Test // Good ivScales, vectorization expected. @IR(counts = {IRNode.LOAD_VECTOR_L, "= 0", IRNode.STORE_VECTOR, "> 0"}, applyIfAnd = {"UseAutoVectorizationSpeculativeAliasingChecks", "true", "AlignVector", "false"}, applyIfPlatform = {"64-bit", "true"}, applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) // Aliasing check should never fail at runtime, so the predicate // should never fail, and we do not have to use multiversioning. // Failure could have a few causes: // - issues with doing RCE / missing predicates // -> other loop-opts need to be fixed // - predicate fails: recompile with multiversioning // -> logic in runtime check may be wrong @IR(counts = {".*multiversion.*", "= 0"}, phase = CompilePhase.PRINT_IDEAL, applyIf = {"UseAutoVectorizationPredicate", "true"}, applyIfPlatform = {"64-bit", "true"}, applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) public static Object test_173(long[] container_0, int invar0_0, long[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivLo; i < ivHi; i+=1) { container_0[12334 + 1 * i + -1 * invar0_0] = (long)0x0102030405060708L; container_1[8635 + -1 * i + -1 * invar0_1] = (long)0x1112131415161718L; } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_173(long[] container_0, int invar0_0, long[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivLo; i < ivHi; i+=1) { container_0[12334 + 1 * i + -1 * invar0_0] = (long)0x0102030405060708L; container_1[8635 + -1 * i + -1 * invar0_1] = (long)0x1112131415161718L; } return new Object[] { container_0, container_1 }; } // --- test_173 end --- // --- test_207 start --- // invarRest fields: private static int invar0_207 = 0; private static int invar1_207 = 0; private static int invar2_207 = 0; private static int invar3_207 = 0; // Containers fields: private static short[] original_container0_207 = new short[18586]; private static short[] test_container0_207 = new short[18586]; private static short[] reference_container0_207 = new short[18586]; private static short[] original_container1_207 = new short[18586]; private static short[] test_container1_207 = new short[18586]; private static short[] reference_container1_207 = new short[18586]; // Index forms for the accesses: private static IndexForm index0_207 = new IndexForm(22619, -1, 1, new int[] {0, 1, -1, 1}, 1); private static IndexForm index1_207 = new IndexForm(-3230, -1, -1, new int[] {-1, 1, 1, 0}, 1); // Count the run invocations. private static int iterations_207 = 0; @Run(test = "test_207") @Warmup(100) public static void run_207(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_207++; // Init containers from original data: System.arraycopy(original_container0_207, 0, test_container0_207, 0, 18586); System.arraycopy(original_container0_207, 0, reference_container0_207, 0, 18586); System.arraycopy(original_container1_207, 0, test_container1_207, 0, 18586); System.arraycopy(original_container1_207, 0, reference_container1_207, 0, 18586); // Container aliasing: var test_0 = (iterations_207 % 2 == 0) ? test_container0_207 : test_container0_207; var reference_0 = (iterations_207 % 2 == 0) ? reference_container0_207 : reference_container0_207; var test_1 = (iterations_207 % 2 == 0) ? test_container1_207 : test_container1_207; var reference_1 = (iterations_207 % 2 == 0) ? reference_container1_207 : reference_container1_207; // Generate ranges: int lo0 = RANDOM.nextInt(0, 18586 * 3 / 4); int lo1 = RANDOM.nextInt(0, 18586 * 3 / 4); var r0 = new IndexForm.Range(lo0, lo0 + 18586 / 4); var r1 = new IndexForm.Range(lo1, lo1 + 18586 / 4); // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 37172; int invar0_0 = index0_207.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_207.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_207.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_207.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_207 = RANDOM.nextInt(-1, 2); invar1_207 = RANDOM.nextInt(-1, 2); invar2_207 = RANDOM.nextInt(-1, 2); invar3_207 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(22619 + -1 * i + 1 * invar0_0 + 0 * invar0_207 + 1 * invar1_207 + -1 * invar2_207 + 1 * invar3_207); int lo_1 = (int)(-3230 + -1 * i + -1 * invar0_1 + -1 * invar0_207 + 1 * invar1_207 + 1 * invar2_207 + 0 * invar3_207); i = ivHi; int hi_0 = (int)(22619 + -1 * i + 1 * invar0_0 + 0 * invar0_207 + 1 * invar1_207 + -1 * invar2_207 + 1 * invar3_207); int hi_1 = (int)(-3230 + -1 * i + -1 * invar0_1 + -1 * invar0_207 + 1 * invar1_207 + 1 * invar2_207 + 0 * invar3_207); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_207(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_207(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_207 @Test // Good ivScales, vectorization expected. @IR(counts = {IRNode.LOAD_VECTOR_S, "> 0", IRNode.STORE_VECTOR, "> 0"}, applyIfAnd = {"UseAutoVectorizationSpeculativeAliasingChecks", "true", "AlignVector", "false"}, applyIfPlatform = {"64-bit", "true"}, applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) // Aliasing check should never fail at runtime, so the predicate // should never fail, and we do not have to use multiversioning. // Failure could have a few causes: // - issues with doing RCE / missing predicates // -> other loop-opts need to be fixed // - predicate fails: recompile with multiversioning // -> logic in runtime check may be wrong @IR(counts = {".*multiversion.*", "= 0"}, phase = CompilePhase.PRINT_IDEAL, applyIf = {"UseAutoVectorizationPredicate", "true"}, applyIfPlatform = {"64-bit", "true"}, applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) public static Object test_207(short[] container_0, int invar0_0, short[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivLo; i < ivHi; i+=1) { container_0[22619 + -1 * i + 1 * invar0_0 + 0 * invar0_207 + 1 * invar1_207 + -1 * invar2_207 + 1 * invar3_207] = container_1[-3230 + -1 * i + -1 * invar0_1 + -1 * invar0_207 + 1 * invar1_207 + 1 * invar2_207 + 0 * invar3_207]; } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_207(short[] container_0, int invar0_0, short[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivLo; i < ivHi; i+=1) { container_0[22619 + -1 * i + 1 * invar0_0 + 0 * invar0_207 + 1 * invar1_207 + -1 * invar2_207 + 1 * invar3_207] = container_1[-3230 + -1 * i + -1 * invar0_1 + -1 * invar0_207 + 1 * invar1_207 + 1 * invar2_207 + 0 * invar3_207]; } return new Object[] { container_0, container_1 }; } // --- test_207 end --- // --- test_241 start --- // invarRest fields: private static int invar0_241 = 0; private static int invar1_241 = 0; private static int invar2_241 = 0; // Containers fields: private static char[] original_container0_241 = new char[18473]; private static char[] test_container0_241 = new char[18473]; private static char[] reference_container0_241 = new char[18473]; private static char[] original_container1_241 = new char[18473]; private static char[] test_container1_241 = new char[18473]; private static char[] reference_container1_241 = new char[18473]; // Index forms for the accesses: private static IndexForm index0_241 = new IndexForm(-1732, -1, -1, new int[] {1, 0, 1}, 1); private static IndexForm index1_241 = new IndexForm(-41681, -1, -1, new int[] {0, -1, -1}, 1); // Count the run invocations. private static int iterations_241 = 0; @Run(test = "test_241") @Warmup(100) public static void run_241(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_241++; // Init containers from original data: System.arraycopy(original_container0_241, 0, test_container0_241, 0, 18473); System.arraycopy(original_container0_241, 0, reference_container0_241, 0, 18473); System.arraycopy(original_container1_241, 0, test_container1_241, 0, 18473); System.arraycopy(original_container1_241, 0, reference_container1_241, 0, 18473); // Container aliasing: var test_0 = (iterations_241 % 2 == 0) ? test_container0_241 : test_container0_241; var reference_0 = (iterations_241 % 2 == 0) ? reference_container0_241 : reference_container0_241; var test_1 = (iterations_241 % 2 == 0) ? test_container1_241 : test_container0_241; var reference_1 = (iterations_241 % 2 == 0) ? reference_container1_241 : reference_container0_241; // Generate ranges: int rnd = Math.min(256, 18473 / 10); int middle = 18473 / 2 + RANDOM.nextInt(-rnd, rnd); int range = 18473 / 3 - RANDOM.nextInt(rnd); int overlap = RANDOM.nextInt(-rnd, rnd); var r0 = new IndexForm.Range(middle - range + overlap, middle + overlap); var r1 = new IndexForm.Range(middle, middle + range); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 36946; int invar0_0 = index0_241.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_241.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_241.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_241.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_241 = RANDOM.nextInt(-1, 2); invar1_241 = RANDOM.nextInt(-1, 2); invar2_241 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(-1732 + -1 * i + -1 * invar0_0 + 1 * invar0_241 + 0 * invar1_241 + 1 * invar2_241); int lo_1 = (int)(-41681 + -1 * i + -1 * invar0_1 + 0 * invar0_241 + -1 * invar1_241 + -1 * invar2_241); i = ivHi; int hi_0 = (int)(-1732 + -1 * i + -1 * invar0_0 + 1 * invar0_241 + 0 * invar1_241 + 1 * invar2_241); int hi_1 = (int)(-41681 + -1 * i + -1 * invar0_1 + 0 * invar0_241 + -1 * invar1_241 + -1 * invar2_241); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_241(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_241(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_241 @Test // Good ivScales, vectorization expected. @IR(counts = {IRNode.LOAD_VECTOR_C, "= 0", IRNode.STORE_VECTOR, "> 0"}, applyIfAnd = {"UseAutoVectorizationSpeculativeAliasingChecks", "true", "AlignVector", "false"}, applyIfPlatform = {"64-bit", "true"}, applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) // Aliasing unknown, we may use the predicate or multiversioning. public static Object test_241(char[] container_0, int invar0_0, char[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { container_0[-1732 + -1 * i + -1 * invar0_0 + 1 * invar0_241 + 0 * invar1_241 + 1 * invar2_241] = (char)0x0102030405060708L; container_1[-41681 + -1 * i + -1 * invar0_1 + 0 * invar0_241 + -1 * invar1_241 + -1 * invar2_241] = (char)0x1112131415161718L; } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_241(char[] container_0, int invar0_0, char[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { container_0[-1732 + -1 * i + -1 * invar0_0 + 1 * invar0_241 + 0 * invar1_241 + 1 * invar2_241] = (char)0x0102030405060708L; container_1[-41681 + -1 * i + -1 * invar0_1 + 0 * invar0_241 + -1 * invar1_241 + -1 * invar2_241] = (char)0x1112131415161718L; } return new Object[] { container_0, container_1 }; } // --- test_241 end --- // --- test_275 start --- // invarRest fields: // Containers fields: private static char[] original_container0_275 = new char[19923]; private static char[] test_container0_275 = new char[19923]; private static char[] reference_container0_275 = new char[19923]; private static char[] original_container1_275 = new char[19923]; private static char[] test_container1_275 = new char[19923]; private static char[] reference_container1_275 = new char[19923]; // Index forms for the accesses: private static IndexForm index0_275 = new IndexForm(-86636, 1, 1, new int[] {}, 1); private static IndexForm index1_275 = new IndexForm(-77711, 1, -1, new int[] {}, 1); // Count the run invocations. private static int iterations_275 = 0; @Run(test = "test_275") @Warmup(100) public static void run_275(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_275++; // Init containers from original data: System.arraycopy(original_container0_275, 0, test_container0_275, 0, 19923); System.arraycopy(original_container0_275, 0, reference_container0_275, 0, 19923); System.arraycopy(original_container1_275, 0, test_container1_275, 0, 19923); System.arraycopy(original_container1_275, 0, reference_container1_275, 0, 19923); // Container aliasing: var test_0 = (iterations_275 % 2 == 0) ? test_container0_275 : test_container0_275; var reference_0 = (iterations_275 % 2 == 0) ? reference_container0_275 : reference_container0_275; var test_1 = (iterations_275 % 2 == 0) ? test_container0_275 : test_container0_275; var reference_1 = (iterations_275 % 2 == 0) ? reference_container0_275 : reference_container0_275; // Generate ranges: int lo0 = RANDOM.nextInt(0, 19923 * 3 / 4); int lo1 = RANDOM.nextInt(0, 19923 * 3 / 4); var r0 = new IndexForm.Range(lo0, lo0 + 19923 / 4); var r1 = new IndexForm.Range(lo1, lo1 + 19923 / 4); // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 39846; int invar0_0 = index0_275.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_275.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_275.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_275.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(-86636 + 1 * i + 1 * invar0_0); int lo_1 = (int)(-77711 + 1 * i + -1 * invar0_1); i = ivHi; int hi_0 = (int)(-86636 + 1 * i + 1 * invar0_0); int hi_1 = (int)(-77711 + 1 * i + -1 * invar0_1); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_275(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_275(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_275 @Test // Good ivScales, vectorization expected. @IR(counts = {IRNode.LOAD_VECTOR_C, "= 0", IRNode.STORE_VECTOR, "> 0"}, applyIfAnd = {"UseAutoVectorizationSpeculativeAliasingChecks", "true", "AlignVector", "false"}, applyIfPlatform = {"64-bit", "true"}, applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) // Aliasing unknown, we may use the predicate or multiversioning. public static Object test_275(char[] container_0, int invar0_0, char[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivLo; i < ivHi; i+=1) { container_0[-86636 + 1 * i + 1 * invar0_0] = (char)0x0102030405060708L; container_1[-77711 + 1 * i + -1 * invar0_1] = (char)0x1112131415161718L; } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_275(char[] container_0, int invar0_0, char[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivLo; i < ivHi; i+=1) { container_0[-86636 + 1 * i + 1 * invar0_0] = (char)0x0102030405060708L; container_1[-77711 + 1 * i + -1 * invar0_1] = (char)0x1112131415161718L; } return new Object[] { container_0, container_1 }; } // --- test_275 end --- // --- test_309 start --- // invarRest fields: private static int invar0_309 = 0; private static int invar1_309 = 0; private static int invar2_309 = 0; private static int invar3_309 = 0; // Containers fields: private static long[] original_container0_309 = new long[18114]; private static long[] test_container0_309 = new long[18114]; private static long[] reference_container0_309 = new long[18114]; private static long[] original_container1_309 = new long[18114]; private static long[] test_container1_309 = new long[18114]; private static long[] reference_container1_309 = new long[18114]; // Index forms for the accesses: private static IndexForm index0_309 = new IndexForm(-93230, -1, 1, new int[] {0, 0, -1, -1}, 1); private static IndexForm index1_309 = new IndexForm(-35474, -1, 1, new int[] {1, 0, 1, 1}, 1); // Count the run invocations. private static int iterations_309 = 0; @Run(test = "test_309") @Warmup(100) public static void run_309(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_309++; // Init containers from original data: System.arraycopy(original_container0_309, 0, test_container0_309, 0, 18114); System.arraycopy(original_container0_309, 0, reference_container0_309, 0, 18114); System.arraycopy(original_container1_309, 0, test_container1_309, 0, 18114); System.arraycopy(original_container1_309, 0, reference_container1_309, 0, 18114); // Container aliasing: var test_0 = (iterations_309 % 2 == 0) ? test_container0_309 : test_container0_309; var reference_0 = (iterations_309 % 2 == 0) ? reference_container0_309 : reference_container0_309; var test_1 = (iterations_309 % 2 == 0) ? test_container1_309 : test_container1_309; var reference_1 = (iterations_309 % 2 == 0) ? reference_container1_309 : reference_container1_309; // Generate ranges: int lo0 = RANDOM.nextInt(0, 18114 * 3 / 4); int lo1 = RANDOM.nextInt(0, 18114 * 3 / 4); var r0 = new IndexForm.Range(lo0, lo0 + 18114 / 4); var r1 = new IndexForm.Range(lo1, lo1 + 18114 / 4); // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 144912; int invar0_0 = index0_309.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_309.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_309.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_309.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_309 = RANDOM.nextInt(-1, 2); invar1_309 = RANDOM.nextInt(-1, 2); invar2_309 = RANDOM.nextInt(-1, 2); invar3_309 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(-93230 + -1 * i + 1 * invar0_0 + 0 * invar0_309 + 0 * invar1_309 + -1 * invar2_309 + -1 * invar3_309); int lo_1 = (int)(-35474 + -1 * i + 1 * invar0_1 + 1 * invar0_309 + 0 * invar1_309 + 1 * invar2_309 + 1 * invar3_309); i = ivHi; int hi_0 = (int)(-93230 + -1 * i + 1 * invar0_0 + 0 * invar0_309 + 0 * invar1_309 + -1 * invar2_309 + -1 * invar3_309); int hi_1 = (int)(-35474 + -1 * i + 1 * invar0_1 + 1 * invar0_309 + 0 * invar1_309 + 1 * invar2_309 + 1 * invar3_309); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_309(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_309(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_309 @Test // Good ivScales, vectorization expected. @IR(counts = {IRNode.LOAD_VECTOR_L, "= 0", IRNode.STORE_VECTOR, "> 0"}, applyIfAnd = {"UseAutoVectorizationSpeculativeAliasingChecks", "true", "AlignVector", "false"}, applyIfPlatform = {"64-bit", "true"}, applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) // Aliasing check should never fail at runtime, so the predicate // should never fail, and we do not have to use multiversioning. // Failure could have a few causes: // - issues with doing RCE / missing predicates // -> other loop-opts need to be fixed // - predicate fails: recompile with multiversioning // -> logic in runtime check may be wrong @IR(counts = {".*multiversion.*", "= 0"}, phase = CompilePhase.PRINT_IDEAL, applyIf = {"UseAutoVectorizationPredicate", "true"}, applyIfPlatform = {"64-bit", "true"}, applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"}) public static Object test_309(long[] container_0, int invar0_0, long[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { container_0[-93230 + -1 * i + 1 * invar0_0 + 0 * invar0_309 + 0 * invar1_309 + -1 * invar2_309 + -1 * invar3_309] = (long)0x0102030405060708L; container_1[-35474 + -1 * i + 1 * invar0_1 + 1 * invar0_309 + 0 * invar1_309 + 1 * invar2_309 + 1 * invar3_309] = (long)0x1112131415161718L; } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_309(long[] container_0, int invar0_0, long[] container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { container_0[-93230 + -1 * i + 1 * invar0_0 + 0 * invar0_309 + 0 * invar1_309 + -1 * invar2_309 + -1 * invar3_309] = (long)0x0102030405060708L; container_1[-35474 + -1 * i + 1 * invar0_1 + 1 * invar0_309 + 0 * invar1_309 + 1 * invar2_309 + 1 * invar3_309] = (long)0x1112131415161718L; } return new Object[] { container_0, container_1 }; } // --- test_309 end --- // --- test_343 start --- // invarRest fields: private static long invar0_343 = 0; private static long invar1_343 = 0; // Containers fields: private static MemorySegment original_container0_343 = Arena.ofAuto().allocate(74660); private static MemorySegment test_container0_343 = Arena.ofAuto().allocate(74660); private static MemorySegment reference_container0_343 = Arena.ofAuto().allocate(74660); private static MemorySegment original_container1_343 = Arena.ofAuto().allocate(74660); private static MemorySegment test_container1_343 = Arena.ofAuto().allocate(74660); private static MemorySegment reference_container1_343 = Arena.ofAuto().allocate(74660); // Index forms for the accesses: private static IndexForm index0_343 = new IndexForm(69830, 2, -2, new int[] {-1, 1}, 2); private static IndexForm index1_343 = new IndexForm(9071, -4, -4, new int[] {1, -1}, 4); // Count the run invocations. private static int iterations_343 = 0; @Run(test = "test_343") @Warmup(100) public static void run_343(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_343++; // Init containers from original data: test_container0_343.copyFrom(original_container0_343); reference_container0_343.copyFrom(original_container0_343); test_container1_343.copyFrom(original_container1_343); reference_container1_343.copyFrom(original_container1_343); // Container aliasing: var test_0 = (iterations_343 % 2 == 0) ? test_container0_343 : test_container0_343; var reference_0 = (iterations_343 % 2 == 0) ? reference_container0_343 : reference_container0_343; var test_1 = (iterations_343 % 2 == 0) ? test_container1_343 : test_container0_343; var reference_1 = (iterations_343 % 2 == 0) ? reference_container1_343 : reference_container0_343; // Generate ranges: int middle = RANDOM.nextInt(74660 / 3, 74660 * 2 / 3); int rnd = Math.min(256, 74660 / 10); int range = 74660 / 3 - RANDOM.nextInt(rnd); var r0 = new IndexForm.Range(0, middle); var r1 = new IndexForm.Range(middle, 74660); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 74660; int invar0_0 = index0_343.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_343.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_343.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_343.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_343 = RANDOM.nextInt(-1, 2); invar1_343 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(69830 + 2 * i + -2 * invar0_0 + -1 * invar0_343 + 1 * invar1_343); int lo_1 = (int)(9071 + -4 * i + -4 * invar0_1 + 1 * invar0_343 + -1 * invar1_343); i = ivHi; int hi_0 = (int)(69830 + 2 * i + -2 * invar0_0 + -1 * invar0_343 + 1 * invar1_343); int hi_1 = (int)(9071 + -4 * i + -4 * invar0_1 + 1 * invar0_343 + -1 * invar1_343); // Bounds should not overlap. if (false || (lo_1 < lo_0 && lo_1 < hi_0 && hi_1 < lo_0 && hi_1 < hi_0) || (lo_1 > lo_0 && lo_1 > hi_0 && hi_1 > lo_0 && hi_1 > hi_0) ) { // pass } else { throw new RuntimeException("bounds overlap!"); } // Run test and compare with interpreter results. var result = test_343(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_343(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_343 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Due to cases like JDK-8360204 and JDK-8365982, there can be issues // with RCE leading cases where we remove predicates and then unroll again // and then end up multiversioning. These cases seem relatively rare but // prevent us from asserting that there is never multiversioning in these cases. public static Object test_343(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivHi-1; i >= ivLo; i-=1) { container_0.set(ValueLayout.JAVA_CHAR_UNALIGNED, 69830L + 2L * i + -2L * invar0_0 + -1L * invar0_343 + 1L * invar1_343, (char)0x0102030405060708L); container_1.set(ValueLayout.JAVA_FLOAT_UNALIGNED, 9071L + -4L * i + -4L * invar0_1 + 1L * invar0_343 + -1L * invar1_343, (float)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_343(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivHi-1; i >= ivLo; i-=1) { container_0.set(ValueLayout.JAVA_CHAR_UNALIGNED, 69830L + 2L * i + -2L * invar0_0 + -1L * invar0_343 + 1L * invar1_343, (char)0x0102030405060708L); container_1.set(ValueLayout.JAVA_FLOAT_UNALIGNED, 9071L + -4L * i + -4L * invar0_1 + 1L * invar0_343 + -1L * invar1_343, (float)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } // --- test_343 end --- // --- test_377 start --- // invarRest fields: private static int invar0_377 = 0; private static int invar1_377 = 0; private static int invar2_377 = 0; private static int invar3_377 = 0; // Containers fields: private static MemorySegment original_container0_377 = MemorySegment.ofArray(new double[9990]); private static MemorySegment test_container0_377 = MemorySegment.ofArray(new double[9990]); private static MemorySegment reference_container0_377 = MemorySegment.ofArray(new double[9990]); private static MemorySegment original_container1_377 = MemorySegment.ofArray(new double[9990]); private static MemorySegment test_container1_377 = MemorySegment.ofArray(new double[9990]); private static MemorySegment reference_container1_377 = MemorySegment.ofArray(new double[9990]); // Index forms for the accesses: private static IndexForm index0_377 = new IndexForm(53979, 2, -2, new int[] {0, 0, 0, 0}, 2); private static IndexForm index1_377 = new IndexForm(-92013, 4, -4, new int[] {0, 0, 0, 0}, 4); // Count the run invocations. private static int iterations_377 = 0; @Run(test = "test_377") @Warmup(100) public static void run_377(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_377++; // Init containers from original data: test_container0_377.copyFrom(original_container0_377); reference_container0_377.copyFrom(original_container0_377); test_container1_377.copyFrom(original_container1_377); reference_container1_377.copyFrom(original_container1_377); // Container aliasing: var test_0 = (iterations_377 % 2 == 0) ? test_container0_377 : test_container0_377; var reference_0 = (iterations_377 % 2 == 0) ? reference_container0_377 : reference_container0_377; var test_1 = (iterations_377 % 2 == 0) ? test_container1_377 : test_container0_377; var reference_1 = (iterations_377 % 2 == 0) ? reference_container1_377 : reference_container0_377; // Generate ranges: int middle = RANDOM.nextInt(79920 / 3, 79920 * 2 / 3); int rnd = Math.min(256, 79920 / 10); int range = 79920 / 3 - RANDOM.nextInt(rnd); var r0 = new IndexForm.Range(middle - range, middle); var r1 = new IndexForm.Range(middle, middle + range); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 79920; int invar0_0 = index0_377.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_377.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_377.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_377.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_377 = RANDOM.nextInt(-1, 2); invar1_377 = RANDOM.nextInt(-1, 2); invar2_377 = RANDOM.nextInt(-1, 2); invar3_377 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(53979 + 2 * i + -2 * invar0_0 + 0 * invar0_377 + 0 * invar1_377 + 0 * invar2_377 + 0 * invar3_377); int lo_1 = (int)(-92013 + 4 * i + -4 * invar0_1 + 0 * invar0_377 + 0 * invar1_377 + 0 * invar2_377 + 0 * invar3_377); i = ivHi; int hi_0 = (int)(53979 + 2 * i + -2 * invar0_0 + 0 * invar0_377 + 0 * invar1_377 + 0 * invar2_377 + 0 * invar3_377); int hi_1 = (int)(-92013 + 4 * i + -4 * invar0_1 + 0 * invar0_377 + 0 * invar1_377 + 0 * invar2_377 + 0 * invar3_377); // Bounds should not overlap. if (false || (lo_1 < lo_0 && lo_1 < hi_0 && hi_1 < lo_0 && hi_1 < hi_0) || (lo_1 > lo_0 && lo_1 > hi_0 && hi_1 > lo_0 && hi_1 > hi_0) ) { // pass } else { throw new RuntimeException("bounds overlap!"); } // Run test and compare with interpreter results. var result = test_377(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_377(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_377 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Due to cases like JDK-8360204 and JDK-8365982, there can be issues // with RCE leading cases where we remove predicates and then unroll again // and then end up multiversioning. These cases seem relatively rare but // prevent us from asserting that there is never multiversioning in these cases. public static Object test_377(MemorySegment container_0, int invar0_0, MemorySegment container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { int v = (int)container_0.get(ValueLayout.JAVA_SHORT_UNALIGNED, 53979L + 2L * i + -2L * invar0_0 + 0L * invar0_377 + 0L * invar1_377 + 0L * invar2_377 + 0L * invar3_377); container_1.set(ValueLayout.JAVA_INT_UNALIGNED, -92013L + 4L * i + -4L * invar0_1 + 0L * invar0_377 + 0L * invar1_377 + 0L * invar2_377 + 0L * invar3_377, v); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_377(MemorySegment container_0, int invar0_0, MemorySegment container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { int v = (int)container_0.get(ValueLayout.JAVA_SHORT_UNALIGNED, 53979L + 2L * i + -2L * invar0_0 + 0L * invar0_377 + 0L * invar1_377 + 0L * invar2_377 + 0L * invar3_377); container_1.set(ValueLayout.JAVA_INT_UNALIGNED, -92013L + 4L * i + -4L * invar0_1 + 0L * invar0_377 + 0L * invar1_377 + 0L * invar2_377 + 0L * invar3_377, v); } return new Object[] { container_0, container_1 }; } // --- test_377 end --- // --- test_411 start --- // invarRest fields: private static long invar0_411 = 0; // Containers fields: private static MemorySegment original_container0_411 = MemorySegment.ofArray(new double[18847]); private static MemorySegment test_container0_411 = MemorySegment.ofArray(new double[18847]); private static MemorySegment reference_container0_411 = MemorySegment.ofArray(new double[18847]); private static MemorySegment original_container1_411 = MemorySegment.ofArray(new double[18847]); private static MemorySegment test_container1_411 = MemorySegment.ofArray(new double[18847]); private static MemorySegment reference_container1_411 = MemorySegment.ofArray(new double[18847]); // Index forms for the accesses: private static IndexForm index0_411 = new IndexForm(-53540, -8, -8, new int[] {-1}, 8); private static IndexForm index1_411 = new IndexForm(10296, 1, -1, new int[] {-1}, 1); // Count the run invocations. private static int iterations_411 = 0; @Run(test = "test_411") @Warmup(100) public static void run_411(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_411++; // Init containers from original data: test_container0_411.copyFrom(original_container0_411); reference_container0_411.copyFrom(original_container0_411); test_container1_411.copyFrom(original_container1_411); reference_container1_411.copyFrom(original_container1_411); // Container aliasing: var test_0 = (iterations_411 % 2 == 0) ? test_container0_411 : test_container0_411; var reference_0 = (iterations_411 % 2 == 0) ? reference_container0_411 : reference_container0_411; var test_1 = (iterations_411 % 2 == 0) ? test_container1_411 : test_container0_411; var reference_1 = (iterations_411 % 2 == 0) ? reference_container1_411 : reference_container0_411; // Generate ranges: int middle = RANDOM.nextInt(150776 / 3, 150776 * 2 / 3); int rnd = Math.min(256, 150776 / 10); int range = 150776 / 3 - RANDOM.nextInt(rnd); var r0 = new IndexForm.Range(0, middle); var r1 = new IndexForm.Range(middle, 150776); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 150776; int invar0_0 = index0_411.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_411.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_411.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_411.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_411 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(-53540 + -8 * i + -8 * invar0_0 + -1 * invar0_411); int lo_1 = (int)(10296 + 1 * i + -1 * invar0_1 + -1 * invar0_411); i = ivHi; int hi_0 = (int)(-53540 + -8 * i + -8 * invar0_0 + -1 * invar0_411); int hi_1 = (int)(10296 + 1 * i + -1 * invar0_1 + -1 * invar0_411); // Bounds should not overlap. if (false || (lo_1 < lo_0 && lo_1 < hi_0 && hi_1 < lo_0 && hi_1 < hi_0) || (lo_1 > lo_0 && lo_1 > hi_0 && hi_1 > lo_0 && hi_1 > hi_0) ) { // pass } else { throw new RuntimeException("bounds overlap!"); } // Run test and compare with interpreter results. var result = test_411(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_411(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_411 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Due to cases like JDK-8360204 and JDK-8365982, there can be issues // with RCE leading cases where we remove predicates and then unroll again // and then end up multiversioning. These cases seem relatively rare but // prevent us from asserting that there is never multiversioning in these cases. public static Object test_411(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivLo; i < ivHi; i+=1) { byte v = (byte)container_0.get(ValueLayout.JAVA_LONG_UNALIGNED, -53540L + -8L * i + -8L * invar0_0 + -1L * invar0_411); container_1.set(ValueLayout.JAVA_BYTE, 10296L + 1L * i + -1L * invar0_1 + -1L * invar0_411, v); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_411(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivLo; i < ivHi; i+=1) { byte v = (byte)container_0.get(ValueLayout.JAVA_LONG_UNALIGNED, -53540L + -8L * i + -8L * invar0_0 + -1L * invar0_411); container_1.set(ValueLayout.JAVA_BYTE, 10296L + 1L * i + -1L * invar0_1 + -1L * invar0_411, v); } return new Object[] { container_0, container_1 }; } // --- test_411 end --- // --- test_445 start --- // invarRest fields: private static int invar0_445 = 0; private static int invar1_445 = 0; private static int invar2_445 = 0; // Containers fields: private static MemorySegment original_container0_445 = MemorySegment.ofArray(new char[79080]); private static MemorySegment test_container0_445 = MemorySegment.ofArray(new char[79080]); private static MemorySegment reference_container0_445 = MemorySegment.ofArray(new char[79080]); private static MemorySegment original_container1_445 = MemorySegment.ofArray(new char[79080]); private static MemorySegment test_container1_445 = MemorySegment.ofArray(new char[79080]); private static MemorySegment reference_container1_445 = MemorySegment.ofArray(new char[79080]); // Index forms for the accesses: private static IndexForm index0_445 = new IndexForm(5871, -4, -13, new int[] {0, 0, -1}, 4); private static IndexForm index1_445 = new IndexForm(65264, -8, -8, new int[] {1, -1, -1}, 8); // Count the run invocations. private static int iterations_445 = 0; @Run(test = "test_445") @Warmup(100) public static void run_445(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_445++; // Init containers from original data: test_container0_445.copyFrom(original_container0_445); reference_container0_445.copyFrom(original_container0_445); test_container1_445.copyFrom(original_container1_445); reference_container1_445.copyFrom(original_container1_445); // Container aliasing: var test_0 = (iterations_445 % 2 == 0) ? test_container0_445 : test_container0_445; var reference_0 = (iterations_445 % 2 == 0) ? reference_container0_445 : reference_container0_445; var test_1 = (iterations_445 % 2 == 0) ? test_container1_445 : test_container1_445; var reference_1 = (iterations_445 % 2 == 0) ? reference_container1_445 : reference_container1_445; // Generate ranges: int lo0 = RANDOM.nextInt(0, 158160 * 3 / 4); int lo1 = RANDOM.nextInt(0, 158160 * 3 / 4); var r0 = new IndexForm.Range(lo0, lo0 + 158160 / 4); var r1 = new IndexForm.Range(lo1, lo1 + 158160 / 4); // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 158160; int invar0_0 = index0_445.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_445.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_445.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_445.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_445 = RANDOM.nextInt(-1, 2); invar1_445 = RANDOM.nextInt(-1, 2); invar2_445 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(5871 + -4 * i + -13 * invar0_0 + 0 * invar0_445 + 0 * invar1_445 + -1 * invar2_445); int lo_1 = (int)(65264 + -8 * i + -8 * invar0_1 + 1 * invar0_445 + -1 * invar1_445 + -1 * invar2_445); i = ivHi; int hi_0 = (int)(5871 + -4 * i + -13 * invar0_0 + 0 * invar0_445 + 0 * invar1_445 + -1 * invar2_445); int hi_1 = (int)(65264 + -8 * i + -8 * invar0_1 + 1 * invar0_445 + -1 * invar1_445 + -1 * invar2_445); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_445(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_445(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_445 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Due to cases like JDK-8360204 and JDK-8365982, there can be issues // with RCE leading cases where we remove predicates and then unroll again // and then end up multiversioning. These cases seem relatively rare but // prevent us from asserting that there is never multiversioning in these cases. public static Object test_445(MemorySegment container_0, int invar0_0, MemorySegment container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { container_0.set(ValueLayout.JAVA_FLOAT_UNALIGNED, 5871L + -4L * i + -13L * invar0_0 + 0L * invar0_445 + 0L * invar1_445 + -1L * invar2_445, (float)0x0102030405060708L); container_1.set(ValueLayout.JAVA_DOUBLE_UNALIGNED, 65264L + -8L * i + -8L * invar0_1 + 1L * invar0_445 + -1L * invar1_445 + -1L * invar2_445, (double)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_445(MemorySegment container_0, int invar0_0, MemorySegment container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { container_0.set(ValueLayout.JAVA_FLOAT_UNALIGNED, 5871L + -4L * i + -13L * invar0_0 + 0L * invar0_445 + 0L * invar1_445 + -1L * invar2_445, (float)0x0102030405060708L); container_1.set(ValueLayout.JAVA_DOUBLE_UNALIGNED, 65264L + -8L * i + -8L * invar0_1 + 1L * invar0_445 + -1L * invar1_445 + -1L * invar2_445, (double)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } // --- test_445 end --- // --- test_479 start --- // invarRest fields: private static long invar0_479 = 0; private static long invar1_479 = 0; private static long invar2_479 = 0; // Containers fields: private static MemorySegment original_container0_479 = MemorySegment.ofArray(new short[74140]); private static MemorySegment test_container0_479 = MemorySegment.ofArray(new short[74140]); private static MemorySegment reference_container0_479 = MemorySegment.ofArray(new short[74140]); private static MemorySegment original_container1_479 = MemorySegment.ofArray(new short[74140]); private static MemorySegment test_container1_479 = MemorySegment.ofArray(new short[74140]); private static MemorySegment reference_container1_479 = MemorySegment.ofArray(new short[74140]); // Index forms for the accesses: private static IndexForm index0_479 = new IndexForm(-38805, 1, -8, new int[] {0, 1, 1}, 8); private static IndexForm index1_479 = new IndexForm(-27653, -1, 8, new int[] {0, -1, -1}, 8); // Count the run invocations. private static int iterations_479 = 0; @Run(test = "test_479") @Warmup(100) public static void run_479(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_479++; // Init containers from original data: test_container0_479.copyFrom(original_container0_479); reference_container0_479.copyFrom(original_container0_479); test_container1_479.copyFrom(original_container1_479); reference_container1_479.copyFrom(original_container1_479); // Container aliasing: var test_0 = (iterations_479 % 2 == 0) ? test_container0_479 : test_container0_479; var reference_0 = (iterations_479 % 2 == 0) ? reference_container0_479 : reference_container0_479; var test_1 = (iterations_479 % 2 == 0) ? test_container1_479 : test_container1_479; var reference_1 = (iterations_479 % 2 == 0) ? reference_container1_479 : reference_container1_479; // Generate ranges: int middle = RANDOM.nextInt(148280 / 3, 148280 * 2 / 3); int rnd = Math.min(256, 148280 / 10); int range = 148280 / 3 - RANDOM.nextInt(rnd); var r0 = new IndexForm.Range(0, middle); var r1 = new IndexForm.Range(middle, 148280); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 148280; int invar0_0 = index0_479.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_479.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_479.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_479.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 8000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_479 = RANDOM.nextInt(-1, 2); invar1_479 = RANDOM.nextInt(-1, 2); invar2_479 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(-38805 + 1 * i + -8 * invar0_0 + 0 * invar0_479 + 1 * invar1_479 + 1 * invar2_479); int lo_1 = (int)(-27653 + -1 * i + 8 * invar0_1 + 0 * invar0_479 + -1 * invar1_479 + -1 * invar2_479); i = ivHi; int hi_0 = (int)(-38805 + 1 * i + -8 * invar0_0 + 0 * invar0_479 + 1 * invar1_479 + 1 * invar2_479); int hi_1 = (int)(-27653 + -1 * i + 8 * invar0_1 + 0 * invar0_479 + -1 * invar1_479 + -1 * invar2_479); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_479(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_479(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_479 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Due to cases like JDK-8360204 and JDK-8365982, there can be issues // with RCE leading cases where we remove predicates and then unroll again // and then end up multiversioning. These cases seem relatively rare but // prevent us from asserting that there is never multiversioning in these cases. public static Object test_479(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivHi-8; i >= ivLo; i-=8) { container_0.set(ValueLayout.JAVA_LONG_UNALIGNED, -38805L + 1L * i + -8L * invar0_0 + 0L * invar0_479 + 1L * invar1_479 + 1L * invar2_479, (long)0x0102030405060708L); container_1.set(ValueLayout.JAVA_DOUBLE_UNALIGNED, -27653L + -1L * i + 8L * invar0_1 + 0L * invar0_479 + -1L * invar1_479 + -1L * invar2_479, (double)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_479(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivHi-8; i >= ivLo; i-=8) { container_0.set(ValueLayout.JAVA_LONG_UNALIGNED, -38805L + 1L * i + -8L * invar0_0 + 0L * invar0_479 + 1L * invar1_479 + 1L * invar2_479, (long)0x0102030405060708L); container_1.set(ValueLayout.JAVA_DOUBLE_UNALIGNED, -27653L + -1L * i + 8L * invar0_1 + 0L * invar0_479 + -1L * invar1_479 + -1L * invar2_479, (double)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } // --- test_479 end --- // --- test_513 start --- // invarRest fields: // Containers fields: private static MemorySegment original_container0_513 = MemorySegment.ofArray(new float[37126]); private static MemorySegment test_container0_513 = MemorySegment.ofArray(new float[37126]); private static MemorySegment reference_container0_513 = MemorySegment.ofArray(new float[37126]); private static MemorySegment original_container1_513 = MemorySegment.ofArray(new float[37126]); private static MemorySegment test_container1_513 = MemorySegment.ofArray(new float[37126]); private static MemorySegment reference_container1_513 = MemorySegment.ofArray(new float[37126]); // Index forms for the accesses: private static IndexForm index0_513 = new IndexForm(17408, 1, 1, new int[] {}, 1); private static IndexForm index1_513 = new IndexForm(-75454, -1, 1, new int[] {}, 1); // Count the run invocations. private static int iterations_513 = 0; @Run(test = "test_513") @Warmup(100) public static void run_513(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_513++; // Init containers from original data: test_container0_513.copyFrom(original_container0_513); reference_container0_513.copyFrom(original_container0_513); test_container1_513.copyFrom(original_container1_513); reference_container1_513.copyFrom(original_container1_513); // Container aliasing: var test_0 = (iterations_513 % 2 == 0) ? test_container0_513 : test_container0_513; var reference_0 = (iterations_513 % 2 == 0) ? reference_container0_513 : reference_container0_513; var test_1 = (iterations_513 % 2 == 0) ? test_container0_513 : test_container0_513; var reference_1 = (iterations_513 % 2 == 0) ? reference_container0_513 : reference_container0_513; // Generate ranges: int middle = RANDOM.nextInt(18563 / 3, 18563 * 2 / 3); int rnd = Math.min(256, 18563 / 10); int range = 18563 / 3 - RANDOM.nextInt(rnd); var r0 = new IndexForm.Range(0, middle); var r1 = new IndexForm.Range(middle, 18563); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 148504; int invar0_0 = index0_513.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_513.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_513.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_513.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(17408 + 1 * i + 1 * invar0_0); int lo_1 = (int)(-75454 + -1 * i + 1 * invar0_1); i = ivHi; int hi_0 = (int)(17408 + 1 * i + 1 * invar0_0); int hi_1 = (int)(-75454 + -1 * i + 1 * invar0_1); // Bounds should not overlap. if (false || (lo_1 < lo_0 && lo_1 < hi_0 && hi_1 < lo_0 && hi_1 < hi_0) || (lo_1 > lo_0 && lo_1 > hi_0 && hi_1 > lo_0 && hi_1 > hi_0) ) { // pass } else { throw new RuntimeException("bounds overlap!"); } // Run test and compare with interpreter results. var result = test_513(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_513(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_513 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Due to cases like JDK-8360204 and JDK-8365982, there can be issues // with RCE leading cases where we remove predicates and then unroll again // and then end up multiversioning. These cases seem relatively rare but // prevent us from asserting that there is never multiversioning in these cases. public static Object test_513(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivHi-1; i >= ivLo; i-=1) { container_0.setAtIndex(ValueLayout.JAVA_LONG_UNALIGNED, 17408L + 1L * i + 1L * invar0_0, (long)0x0102030405060708L); container_1.setAtIndex(ValueLayout.JAVA_LONG_UNALIGNED, -75454L + -1L * i + 1L * invar0_1, (long)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_513(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivHi-1; i >= ivLo; i-=1) { container_0.setAtIndex(ValueLayout.JAVA_LONG_UNALIGNED, 17408L + 1L * i + 1L * invar0_0, (long)0x0102030405060708L); container_1.setAtIndex(ValueLayout.JAVA_LONG_UNALIGNED, -75454L + -1L * i + 1L * invar0_1, (long)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } // --- test_513 end --- // --- test_547 start --- // invarRest fields: // Containers fields: private static MemorySegment original_container0_547 = MemorySegment.ofArray(new char[77516]); private static MemorySegment test_container0_547 = MemorySegment.ofArray(new char[77516]); private static MemorySegment reference_container0_547 = MemorySegment.ofArray(new char[77516]); private static MemorySegment original_container1_547 = MemorySegment.ofArray(new char[77516]); private static MemorySegment test_container1_547 = MemorySegment.ofArray(new char[77516]); private static MemorySegment reference_container1_547 = MemorySegment.ofArray(new char[77516]); // Index forms for the accesses: private static IndexForm index0_547 = new IndexForm(29890, -1, 1, new int[] {}, 1); private static IndexForm index1_547 = new IndexForm(52379, 8, -8, new int[] {}, 8); // Count the run invocations. private static int iterations_547 = 0; @Run(test = "test_547") @Warmup(100) public static void run_547(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_547++; // Init containers from original data: test_container0_547.copyFrom(original_container0_547); reference_container0_547.copyFrom(original_container0_547); test_container1_547.copyFrom(original_container1_547); reference_container1_547.copyFrom(original_container1_547); // Container aliasing: var test_0 = (iterations_547 % 2 == 0) ? test_container0_547 : test_container0_547; var reference_0 = (iterations_547 % 2 == 0) ? reference_container0_547 : reference_container0_547; var test_1 = (iterations_547 % 2 == 0) ? test_container0_547 : test_container0_547; var reference_1 = (iterations_547 % 2 == 0) ? reference_container0_547 : reference_container0_547; // Generate ranges: int lo0 = RANDOM.nextInt(0, 155032 * 3 / 4); int lo1 = RANDOM.nextInt(0, 155032 * 3 / 4); var r0 = new IndexForm.Range(lo0, lo0 + 155032 / 4); var r1 = new IndexForm.Range(lo1, lo1 + 155032 / 4); // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 155032; int invar0_0 = index0_547.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_547.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_547.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_547.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(29890 + -1 * i + 1 * invar0_0); int lo_1 = (int)(52379 + 8 * i + -8 * invar0_1); i = ivHi; int hi_0 = (int)(29890 + -1 * i + 1 * invar0_0); int hi_1 = (int)(52379 + 8 * i + -8 * invar0_1); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_547(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_547(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_547 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Aliasing unknown, we may use the predicate or multiversioning. public static Object test_547(MemorySegment container_0, int invar0_0, MemorySegment container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { double v = (double)container_0.get(ValueLayout.JAVA_BYTE, 29890L + -1L * i + 1L * invar0_0); container_1.set(ValueLayout.JAVA_DOUBLE_UNALIGNED, 52379L + 8L * i + -8L * invar0_1, v); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_547(MemorySegment container_0, int invar0_0, MemorySegment container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-1; i >= ivLo; i-=1) { double v = (double)container_0.get(ValueLayout.JAVA_BYTE, 29890L + -1L * i + 1L * invar0_0); container_1.set(ValueLayout.JAVA_DOUBLE_UNALIGNED, 52379L + 8L * i + -8L * invar0_1, v); } return new Object[] { container_0, container_1 }; } // --- test_547 end --- // --- test_581 start --- // invarRest fields: // Containers fields: private static MemorySegment original_container0_581 = MemorySegment.ofArray(new int[37182]); private static MemorySegment test_container0_581 = MemorySegment.ofArray(new int[37182]); private static MemorySegment reference_container0_581 = MemorySegment.ofArray(new int[37182]); private static MemorySegment original_container1_581 = MemorySegment.ofArray(new int[37182]); private static MemorySegment test_container1_581 = MemorySegment.ofArray(new int[37182]); private static MemorySegment reference_container1_581 = MemorySegment.ofArray(new int[37182]); // Index forms for the accesses: private static IndexForm index0_581 = new IndexForm(-6512, -3, -4, new int[] {}, 4); private static IndexForm index1_581 = new IndexForm(76370, -2, 8, new int[] {}, 8); // Count the run invocations. private static int iterations_581 = 0; @Run(test = "test_581") @Warmup(100) public static void run_581(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_581++; // Init containers from original data: test_container0_581.copyFrom(original_container0_581); reference_container0_581.copyFrom(original_container0_581); test_container1_581.copyFrom(original_container1_581); reference_container1_581.copyFrom(original_container1_581); // Container aliasing: var test_0 = (iterations_581 % 2 == 0) ? test_container0_581 : test_container0_581; var reference_0 = (iterations_581 % 2 == 0) ? reference_container0_581 : reference_container0_581; var test_1 = (iterations_581 % 2 == 0) ? test_container1_581 : test_container1_581; var reference_1 = (iterations_581 % 2 == 0) ? reference_container1_581 : reference_container1_581; // Generate ranges: int middle = RANDOM.nextInt(148728 / 3, 148728 * 2 / 3); int rnd = Math.min(256, 148728 / 10); int range = 148728 / 3 - RANDOM.nextInt(rnd); var r0 = new IndexForm.Range(middle - range, middle); var r1 = new IndexForm.Range(middle, middle + range); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 148728; int invar0_0 = index0_581.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_581.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_581.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_581.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 4000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(-6512 + -3 * i + -4 * invar0_0); int lo_1 = (int)(76370 + -2 * i + 8 * invar0_1); i = ivHi; int hi_0 = (int)(-6512 + -3 * i + -4 * invar0_0); int hi_1 = (int)(76370 + -2 * i + 8 * invar0_1); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_581(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_581(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_581 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Due to cases like JDK-8360204 and JDK-8365982, there can be issues // with RCE leading cases where we remove predicates and then unroll again // and then end up multiversioning. These cases seem relatively rare but // prevent us from asserting that there is never multiversioning in these cases. public static Object test_581(MemorySegment container_0, int invar0_0, MemorySegment container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivLo; i < ivHi; i+=4) { long v = (long)container_0.get(ValueLayout.JAVA_FLOAT_UNALIGNED, -6512L + -3L * i + -4L * invar0_0); container_1.set(ValueLayout.JAVA_LONG_UNALIGNED, 76370L + -2L * i + 8L * invar0_1, v); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_581(MemorySegment container_0, int invar0_0, MemorySegment container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivLo; i < ivHi; i+=4) { long v = (long)container_0.get(ValueLayout.JAVA_FLOAT_UNALIGNED, -6512L + -3L * i + -4L * invar0_0); container_1.set(ValueLayout.JAVA_LONG_UNALIGNED, 76370L + -2L * i + 8L * invar0_1, v); } return new Object[] { container_0, container_1 }; } // --- test_581 end --- // --- test_615 start --- // invarRest fields: private static int invar0_615 = 0; private static int invar1_615 = 0; private static int invar2_615 = 0; // Containers fields: private static MemorySegment original_container0_615 = Arena.ofAuto().allocate(78620); private static MemorySegment test_container0_615 = Arena.ofAuto().allocate(78620); private static MemorySegment reference_container0_615 = Arena.ofAuto().allocate(78620); private static MemorySegment original_container1_615 = Arena.ofAuto().allocate(78620); private static MemorySegment test_container1_615 = Arena.ofAuto().allocate(78620); private static MemorySegment reference_container1_615 = Arena.ofAuto().allocate(78620); // Index forms for the accesses: private static IndexForm index0_615 = new IndexForm(426, 1, -2, new int[] {-1, 1, 1}, 2); private static IndexForm index1_615 = new IndexForm(44392, 2, 4, new int[] {0, -1, -1}, 4); // Count the run invocations. private static int iterations_615 = 0; @Run(test = "test_615") @Warmup(100) public static void run_615(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_615++; // Init containers from original data: test_container0_615.copyFrom(original_container0_615); reference_container0_615.copyFrom(original_container0_615); test_container1_615.copyFrom(original_container1_615); reference_container1_615.copyFrom(original_container1_615); // Container aliasing: var test_0 = (iterations_615 % 2 == 0) ? test_container0_615 : test_container0_615; var reference_0 = (iterations_615 % 2 == 0) ? reference_container0_615 : reference_container0_615; var test_1 = (iterations_615 % 2 == 0) ? test_container1_615 : test_container0_615; var reference_1 = (iterations_615 % 2 == 0) ? reference_container1_615 : reference_container0_615; // Generate ranges: int middle = RANDOM.nextInt(78620 / 3, 78620 * 2 / 3); int rnd = Math.min(256, 78620 / 10); int range = 78620 / 3 - RANDOM.nextInt(rnd); var r0 = new IndexForm.Range(middle - range, middle); var r1 = new IndexForm.Range(middle, middle + range); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 78620; int invar0_0 = index0_615.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_615.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_615.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_615.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 2000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_615 = RANDOM.nextInt(-1, 2); invar1_615 = RANDOM.nextInt(-1, 2); invar2_615 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(426 + 1 * i + -2 * invar0_0 + -1 * invar0_615 + 1 * invar1_615 + 1 * invar2_615); int lo_1 = (int)(44392 + 2 * i + 4 * invar0_1 + 0 * invar0_615 + -1 * invar1_615 + -1 * invar2_615); i = ivHi; int hi_0 = (int)(426 + 1 * i + -2 * invar0_0 + -1 * invar0_615 + 1 * invar1_615 + 1 * invar2_615); int hi_1 = (int)(44392 + 2 * i + 4 * invar0_1 + 0 * invar0_615 + -1 * invar1_615 + -1 * invar2_615); // Bounds should not overlap. if (false || (lo_1 < lo_0 && lo_1 < hi_0 && hi_1 < lo_0 && hi_1 < hi_0) || (lo_1 > lo_0 && lo_1 > hi_0 && hi_1 > lo_0 && hi_1 > hi_0) ) { // pass } else { throw new RuntimeException("bounds overlap!"); } // Run test and compare with interpreter results. var result = test_615(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_615(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_615 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Due to cases like JDK-8360204 and JDK-8365982, there can be issues // with RCE leading cases where we remove predicates and then unroll again // and then end up multiversioning. These cases seem relatively rare but // prevent us from asserting that there is never multiversioning in these cases. public static Object test_615(MemorySegment container_0, int invar0_0, MemorySegment container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-2; i >= ivLo; i-=2) { container_0.set(ValueLayout.JAVA_SHORT_UNALIGNED, 426L + 1L * i + -2L * invar0_0 + -1L * invar0_615 + 1L * invar1_615 + 1L * invar2_615, (short)0x0102030405060708L); container_1.set(ValueLayout.JAVA_INT_UNALIGNED, 44392L + 2L * i + 4L * invar0_1 + 0L * invar0_615 + -1L * invar1_615 + -1L * invar2_615, (int)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_615(MemorySegment container_0, int invar0_0, MemorySegment container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivHi-2; i >= ivLo; i-=2) { container_0.set(ValueLayout.JAVA_SHORT_UNALIGNED, 426L + 1L * i + -2L * invar0_0 + -1L * invar0_615 + 1L * invar1_615 + 1L * invar2_615, (short)0x0102030405060708L); container_1.set(ValueLayout.JAVA_INT_UNALIGNED, 44392L + 2L * i + 4L * invar0_1 + 0L * invar0_615 + -1L * invar1_615 + -1L * invar2_615, (int)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } // --- test_615 end --- // --- test_649 start --- // invarRest fields: private static long invar0_649 = 0; private static long invar1_649 = 0; private static long invar2_649 = 0; private static long invar3_649 = 0; // Containers fields: private static MemorySegment original_container0_649 = MemorySegment.ofArray(new int[36358]); private static MemorySegment test_container0_649 = MemorySegment.ofArray(new int[36358]); private static MemorySegment reference_container0_649 = MemorySegment.ofArray(new int[36358]); private static MemorySegment original_container1_649 = MemorySegment.ofArray(new int[36358]); private static MemorySegment test_container1_649 = MemorySegment.ofArray(new int[36358]); private static MemorySegment reference_container1_649 = MemorySegment.ofArray(new int[36358]); // Index forms for the accesses: private static IndexForm index0_649 = new IndexForm(66625, 3, 4, new int[] {1, 0, 0, 1}, 4); private static IndexForm index1_649 = new IndexForm(33301, 8, -8, new int[] {-1, 1, -1, -1}, 8); // Count the run invocations. private static int iterations_649 = 0; @Run(test = "test_649") @Warmup(100) public static void run_649(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_649++; // Init containers from original data: test_container0_649.copyFrom(original_container0_649); reference_container0_649.copyFrom(original_container0_649); test_container1_649.copyFrom(original_container1_649); reference_container1_649.copyFrom(original_container1_649); // Container aliasing: var test_0 = (iterations_649 % 2 == 0) ? test_container0_649 : test_container0_649; var reference_0 = (iterations_649 % 2 == 0) ? reference_container0_649 : reference_container0_649; var test_1 = (iterations_649 % 2 == 0) ? test_container0_649 : test_container0_649; var reference_1 = (iterations_649 % 2 == 0) ? reference_container0_649 : reference_container0_649; // Generate ranges: var r0 = new IndexForm.Range(0, 145432); var r1 = new IndexForm.Range(0, 145432); // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 145432; int invar0_0 = index0_649.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_649.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_649.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_649.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 4000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_649 = RANDOM.nextInt(-1, 2); invar1_649 = RANDOM.nextInt(-1, 2); invar2_649 = RANDOM.nextInt(-1, 2); invar3_649 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(66625 + 3 * i + 4 * invar0_0 + 1 * invar0_649 + 0 * invar1_649 + 0 * invar2_649 + 1 * invar3_649); int lo_1 = (int)(33301 + 8 * i + -8 * invar0_1 + -1 * invar0_649 + 1 * invar1_649 + -1 * invar2_649 + -1 * invar3_649); i = ivHi; int hi_0 = (int)(66625 + 3 * i + 4 * invar0_0 + 1 * invar0_649 + 0 * invar1_649 + 0 * invar2_649 + 1 * invar3_649); int hi_1 = (int)(33301 + 8 * i + -8 * invar0_1 + -1 * invar0_649 + 1 * invar1_649 + -1 * invar2_649 + -1 * invar3_649); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_649(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_649(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_649 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Aliasing unknown, we may use the predicate or multiversioning. public static Object test_649(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivHi-4; i >= ivLo; i-=4) { container_0.set(ValueLayout.JAVA_FLOAT_UNALIGNED, 66625L + 3L * i + 4L * invar0_0 + 1L * invar0_649 + 0L * invar1_649 + 0L * invar2_649 + 1L * invar3_649, (float)0x0102030405060708L); container_1.set(ValueLayout.JAVA_LONG_UNALIGNED, 33301L + 8L * i + -8L * invar0_1 + -1L * invar0_649 + 1L * invar1_649 + -1L * invar2_649 + -1L * invar3_649, (long)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_649(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivHi-4; i >= ivLo; i-=4) { container_0.set(ValueLayout.JAVA_FLOAT_UNALIGNED, 66625L + 3L * i + 4L * invar0_0 + 1L * invar0_649 + 0L * invar1_649 + 0L * invar2_649 + 1L * invar3_649, (float)0x0102030405060708L); container_1.set(ValueLayout.JAVA_LONG_UNALIGNED, 33301L + 8L * i + -8L * invar0_1 + -1L * invar0_649 + 1L * invar1_649 + -1L * invar2_649 + -1L * invar3_649, (long)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } // --- test_649 end --- // --- test_683 start --- // invarRest fields: private static long invar0_683 = 0; private static long invar1_683 = 0; private static long invar2_683 = 0; private static long invar3_683 = 0; // Containers fields: private static MemorySegment original_container0_683 = MemorySegment.ofArray(new byte[155528]); private static MemorySegment test_container0_683 = MemorySegment.ofArray(new byte[155528]); private static MemorySegment reference_container0_683 = MemorySegment.ofArray(new byte[155528]); private static MemorySegment original_container1_683 = MemorySegment.ofArray(new byte[155528]); private static MemorySegment test_container1_683 = MemorySegment.ofArray(new byte[155528]); private static MemorySegment reference_container1_683 = MemorySegment.ofArray(new byte[155528]); // Index forms for the accesses: private static IndexForm index0_683 = new IndexForm(-87381, 4, 8, new int[] {0, 1, 1, -1}, 8); private static IndexForm index1_683 = new IndexForm(-77757, -1, 2, new int[] {-1, 1, 1, 0}, 2); // Count the run invocations. private static int iterations_683 = 0; @Run(test = "test_683") @Warmup(100) public static void run_683(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_683++; // Init containers from original data: test_container0_683.copyFrom(original_container0_683); reference_container0_683.copyFrom(original_container0_683); test_container1_683.copyFrom(original_container1_683); reference_container1_683.copyFrom(original_container1_683); // Container aliasing: var test_0 = (iterations_683 % 2 == 0) ? test_container0_683 : test_container0_683; var reference_0 = (iterations_683 % 2 == 0) ? reference_container0_683 : reference_container0_683; var test_1 = (iterations_683 % 2 == 0) ? test_container1_683 : test_container0_683; var reference_1 = (iterations_683 % 2 == 0) ? reference_container1_683 : reference_container0_683; // Generate ranges: int middle = RANDOM.nextInt(155528 / 3, 155528 * 2 / 3); int rnd = Math.min(256, 155528 / 10); int range = 155528 / 3 - RANDOM.nextInt(rnd); var r0 = new IndexForm.Range(0, middle); var r1 = new IndexForm.Range(middle, 155528); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 155528; int invar0_0 = index0_683.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_683.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_683.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_683.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 2000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_683 = RANDOM.nextInt(-1, 2); invar1_683 = RANDOM.nextInt(-1, 2); invar2_683 = RANDOM.nextInt(-1, 2); invar3_683 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(-87381 + 4 * i + 8 * invar0_0 + 0 * invar0_683 + 1 * invar1_683 + 1 * invar2_683 + -1 * invar3_683); int lo_1 = (int)(-77757 + -1 * i + 2 * invar0_1 + -1 * invar0_683 + 1 * invar1_683 + 1 * invar2_683 + 0 * invar3_683); i = ivHi; int hi_0 = (int)(-87381 + 4 * i + 8 * invar0_0 + 0 * invar0_683 + 1 * invar1_683 + 1 * invar2_683 + -1 * invar3_683); int hi_1 = (int)(-77757 + -1 * i + 2 * invar0_1 + -1 * invar0_683 + 1 * invar1_683 + 1 * invar2_683 + 0 * invar3_683); // Bounds should not overlap. if (false || (lo_1 < lo_0 && lo_1 < hi_0 && hi_1 < lo_0 && hi_1 < hi_0) || (lo_1 > lo_0 && lo_1 > hi_0 && hi_1 > lo_0 && hi_1 > hi_0) ) { // pass } else { throw new RuntimeException("bounds overlap!"); } // Run test and compare with interpreter results. var result = test_683(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_683(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_683 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Due to cases like JDK-8360204 and JDK-8365982, there can be issues // with RCE leading cases where we remove predicates and then unroll again // and then end up multiversioning. These cases seem relatively rare but // prevent us from asserting that there is never multiversioning in these cases. public static Object test_683(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivLo; i < ivHi; i+=2) { short v = (short)container_0.get(ValueLayout.JAVA_DOUBLE_UNALIGNED, -87381L + 4L * i + 8L * invar0_0 + 0L * invar0_683 + 1L * invar1_683 + 1L * invar2_683 + -1L * invar3_683); container_1.set(ValueLayout.JAVA_SHORT_UNALIGNED, -77757L + -1L * i + 2L * invar0_1 + -1L * invar0_683 + 1L * invar1_683 + 1L * invar2_683 + 0L * invar3_683, v); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_683(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivLo; i < ivHi; i+=2) { short v = (short)container_0.get(ValueLayout.JAVA_DOUBLE_UNALIGNED, -87381L + 4L * i + 8L * invar0_0 + 0L * invar0_683 + 1L * invar1_683 + 1L * invar2_683 + -1L * invar3_683); container_1.set(ValueLayout.JAVA_SHORT_UNALIGNED, -77757L + -1L * i + 2L * invar0_1 + -1L * invar0_683 + 1L * invar1_683 + 1L * invar2_683 + 0L * invar3_683, v); } return new Object[] { container_0, container_1 }; } // --- test_683 end --- // --- test_717 start --- // invarRest fields: // Containers fields: private static MemorySegment original_container0_717 = Arena.ofAuto().allocate(78396); private static MemorySegment test_container0_717 = Arena.ofAuto().allocate(78396); private static MemorySegment reference_container0_717 = Arena.ofAuto().allocate(78396); private static MemorySegment original_container1_717 = Arena.ofAuto().allocate(78396); private static MemorySegment test_container1_717 = Arena.ofAuto().allocate(78396); private static MemorySegment reference_container1_717 = Arena.ofAuto().allocate(78396); // Index forms for the accesses: private static IndexForm index0_717 = new IndexForm(48548, 2, -4, new int[] {}, 4); private static IndexForm index1_717 = new IndexForm(57014, 1, -2, new int[] {}, 2); // Count the run invocations. private static int iterations_717 = 0; @Run(test = "test_717") @Warmup(100) public static void run_717(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_717++; // Init containers from original data: test_container0_717.copyFrom(original_container0_717); reference_container0_717.copyFrom(original_container0_717); test_container1_717.copyFrom(original_container1_717); reference_container1_717.copyFrom(original_container1_717); // Container aliasing: var test_0 = (iterations_717 % 2 == 0) ? test_container0_717 : test_container0_717; var reference_0 = (iterations_717 % 2 == 0) ? reference_container0_717 : reference_container0_717; var test_1 = (iterations_717 % 2 == 0) ? test_container1_717 : test_container1_717; var reference_1 = (iterations_717 % 2 == 0) ? reference_container1_717 : reference_container1_717; // Generate ranges: int middle = RANDOM.nextInt(78396 / 3, 78396 * 2 / 3); int rnd = Math.min(256, 78396 / 10); int range = 78396 / 3 - RANDOM.nextInt(rnd); var r0 = new IndexForm.Range(middle - range, middle); var r1 = new IndexForm.Range(middle, middle + range); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 78396; int invar0_0 = index0_717.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_717.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_717.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_717.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 2000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(48548 + 2 * i + -4 * invar0_0); int lo_1 = (int)(57014 + 1 * i + -2 * invar0_1); i = ivHi; int hi_0 = (int)(48548 + 2 * i + -4 * invar0_0); int hi_1 = (int)(57014 + 1 * i + -2 * invar0_1); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_717(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_717(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_717 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Due to cases like JDK-8360204 and JDK-8365982, there can be issues // with RCE leading cases where we remove predicates and then unroll again // and then end up multiversioning. These cases seem relatively rare but // prevent us from asserting that there is never multiversioning in these cases. public static Object test_717(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivLo; i < ivHi; i+=2) { container_0.set(ValueLayout.JAVA_FLOAT_UNALIGNED, 48548L + 2L * i + -4L * invar0_0, (float)0x0102030405060708L); container_1.set(ValueLayout.JAVA_SHORT_UNALIGNED, 57014L + 1L * i + -2L * invar0_1, (short)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_717(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivLo; i < ivHi; i+=2) { container_0.set(ValueLayout.JAVA_FLOAT_UNALIGNED, 48548L + 2L * i + -4L * invar0_0, (float)0x0102030405060708L); container_1.set(ValueLayout.JAVA_SHORT_UNALIGNED, 57014L + 1L * i + -2L * invar0_1, (short)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } // --- test_717 end --- // --- test_751 start --- // invarRest fields: private static int invar0_751 = 0; private static int invar1_751 = 0; private static int invar2_751 = 0; private static int invar3_751 = 0; // Containers fields: private static MemorySegment original_container0_751 = MemorySegment.ofArray(new short[18377]); private static MemorySegment test_container0_751 = MemorySegment.ofArray(new short[18377]); private static MemorySegment reference_container0_751 = MemorySegment.ofArray(new short[18377]); private static MemorySegment original_container1_751 = MemorySegment.ofArray(new short[18377]); private static MemorySegment test_container1_751 = MemorySegment.ofArray(new short[18377]); private static MemorySegment reference_container1_751 = MemorySegment.ofArray(new short[18377]); // Index forms for the accesses: private static IndexForm index0_751 = new IndexForm(-33833, 1, 1, new int[] {-1, 1, 0, -1}, 1); private static IndexForm index1_751 = new IndexForm(1764, 1, -1, new int[] {0, -1, 1, 0}, 1); // Count the run invocations. private static int iterations_751 = 0; @Run(test = "test_751") @Warmup(100) public static void run_751(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_751++; // Init containers from original data: test_container0_751.copyFrom(original_container0_751); reference_container0_751.copyFrom(original_container0_751); test_container1_751.copyFrom(original_container1_751); reference_container1_751.copyFrom(original_container1_751); // Container aliasing: var test_0 = (iterations_751 % 2 == 0) ? test_container0_751 : test_container0_751; var reference_0 = (iterations_751 % 2 == 0) ? reference_container0_751 : reference_container0_751; var test_1 = (iterations_751 % 2 == 0) ? test_container1_751 : test_container1_751; var reference_1 = (iterations_751 % 2 == 0) ? reference_container1_751 : reference_container1_751; // Generate ranges: var r0 = new IndexForm.Range(0, 18377); var r1 = new IndexForm.Range(0, 18377); // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 36754; int invar0_0 = index0_751.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_751.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_751.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_751.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_751 = RANDOM.nextInt(-1, 2); invar1_751 = RANDOM.nextInt(-1, 2); invar2_751 = RANDOM.nextInt(-1, 2); invar3_751 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(-33833 + 1 * i + 1 * invar0_0 + -1 * invar0_751 + 1 * invar1_751 + 0 * invar2_751 + -1 * invar3_751); int lo_1 = (int)(1764 + 1 * i + -1 * invar0_1 + 0 * invar0_751 + -1 * invar1_751 + 1 * invar2_751 + 0 * invar3_751); i = ivHi; int hi_0 = (int)(-33833 + 1 * i + 1 * invar0_0 + -1 * invar0_751 + 1 * invar1_751 + 0 * invar2_751 + -1 * invar3_751); int hi_1 = (int)(1764 + 1 * i + -1 * invar0_1 + 0 * invar0_751 + -1 * invar1_751 + 1 * invar2_751 + 0 * invar3_751); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_751(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_751(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_751 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Due to cases like JDK-8360204 and JDK-8365982, there can be issues // with RCE leading cases where we remove predicates and then unroll again // and then end up multiversioning. These cases seem relatively rare but // prevent us from asserting that there is never multiversioning in these cases. public static Object test_751(MemorySegment container_0, int invar0_0, MemorySegment container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivLo; i < ivHi; i+=1) { container_0.setAtIndex(ValueLayout.JAVA_SHORT_UNALIGNED, -33833L + 1L * i + 1L * invar0_0 + -1L * invar0_751 + 1L * invar1_751 + 0L * invar2_751 + -1L * invar3_751, (short)0x0102030405060708L); container_1.setAtIndex(ValueLayout.JAVA_SHORT_UNALIGNED, 1764L + 1L * i + -1L * invar0_1 + 0L * invar0_751 + -1L * invar1_751 + 1L * invar2_751 + 0L * invar3_751, (short)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_751(MemorySegment container_0, int invar0_0, MemorySegment container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivLo; i < ivHi; i+=1) { container_0.setAtIndex(ValueLayout.JAVA_SHORT_UNALIGNED, -33833L + 1L * i + 1L * invar0_0 + -1L * invar0_751 + 1L * invar1_751 + 0L * invar2_751 + -1L * invar3_751, (short)0x0102030405060708L); container_1.setAtIndex(ValueLayout.JAVA_SHORT_UNALIGNED, 1764L + 1L * i + -1L * invar0_1 + 0L * invar0_751 + -1L * invar1_751 + 1L * invar2_751 + 0L * invar3_751, (short)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } // --- test_751 end --- // --- test_785 start --- // invarRest fields: private static long invar0_785 = 0; private static long invar1_785 = 0; private static long invar2_785 = 0; // Containers fields: private static MemorySegment original_container0_785 = MemorySegment.ofArray(new int[9928]); private static MemorySegment test_container0_785 = MemorySegment.ofArray(new int[9928]); private static MemorySegment reference_container0_785 = MemorySegment.ofArray(new int[9928]); private static MemorySegment original_container1_785 = MemorySegment.ofArray(new int[9928]); private static MemorySegment test_container1_785 = MemorySegment.ofArray(new int[9928]); private static MemorySegment reference_container1_785 = MemorySegment.ofArray(new int[9928]); // Index forms for the accesses: private static IndexForm index0_785 = new IndexForm(76132, -1, -1, new int[] {-1, 1, 0}, 1); private static IndexForm index1_785 = new IndexForm(58781, 1, 1, new int[] {0, 0, 1}, 1); // Count the run invocations. private static int iterations_785 = 0; @Run(test = "test_785") @Warmup(100) public static void run_785(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_785++; // Init containers from original data: test_container0_785.copyFrom(original_container0_785); reference_container0_785.copyFrom(original_container0_785); test_container1_785.copyFrom(original_container1_785); reference_container1_785.copyFrom(original_container1_785); // Container aliasing: var test_0 = (iterations_785 % 2 == 0) ? test_container0_785 : test_container0_785; var reference_0 = (iterations_785 % 2 == 0) ? reference_container0_785 : reference_container0_785; var test_1 = (iterations_785 % 2 == 0) ? test_container0_785 : test_container0_785; var reference_1 = (iterations_785 % 2 == 0) ? reference_container0_785 : reference_container0_785; // Generate ranges: int middle = RANDOM.nextInt(19856 / 3, 19856 * 2 / 3); int rnd = Math.min(256, 19856 / 10); int range = 19856 / 3 - RANDOM.nextInt(rnd); var r0 = new IndexForm.Range(0, middle); var r1 = new IndexForm.Range(middle, 19856); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 39712; int invar0_0 = index0_785.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_785.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_785.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_785.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_785 = RANDOM.nextInt(-1, 2); invar1_785 = RANDOM.nextInt(-1, 2); invar2_785 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(76132 + -1 * i + -1 * invar0_0 + -1 * invar0_785 + 1 * invar1_785 + 0 * invar2_785); int lo_1 = (int)(58781 + 1 * i + 1 * invar0_1 + 0 * invar0_785 + 0 * invar1_785 + 1 * invar2_785); i = ivHi; int hi_0 = (int)(76132 + -1 * i + -1 * invar0_0 + -1 * invar0_785 + 1 * invar1_785 + 0 * invar2_785); int hi_1 = (int)(58781 + 1 * i + 1 * invar0_1 + 0 * invar0_785 + 0 * invar1_785 + 1 * invar2_785); // Bounds should not overlap. if (false || (lo_1 < lo_0 && lo_1 < hi_0 && hi_1 < lo_0 && hi_1 < hi_0) || (lo_1 > lo_0 && lo_1 > hi_0 && hi_1 > lo_0 && hi_1 > hi_0) ) { // pass } else { throw new RuntimeException("bounds overlap!"); } // Run test and compare with interpreter results. var result = test_785(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_785(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_785 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Due to cases like JDK-8360204 and JDK-8365982, there can be issues // with RCE leading cases where we remove predicates and then unroll again // and then end up multiversioning. These cases seem relatively rare but // prevent us from asserting that there is never multiversioning in these cases. public static Object test_785(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivHi-1; i >= ivLo; i-=1) { var v = container_0.getAtIndex(ValueLayout.JAVA_SHORT_UNALIGNED, 76132L + -1L * i + -1L * invar0_0 + -1L * invar0_785 + 1L * invar1_785 + 0L * invar2_785); container_1.setAtIndex(ValueLayout.JAVA_SHORT_UNALIGNED, 58781L + 1L * i + 1L * invar0_1 + 0L * invar0_785 + 0L * invar1_785 + 1L * invar2_785, v); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_785(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivHi-1; i >= ivLo; i-=1) { var v = container_0.getAtIndex(ValueLayout.JAVA_SHORT_UNALIGNED, 76132L + -1L * i + -1L * invar0_0 + -1L * invar0_785 + 1L * invar1_785 + 0L * invar2_785); container_1.setAtIndex(ValueLayout.JAVA_SHORT_UNALIGNED, 58781L + 1L * i + 1L * invar0_1 + 0L * invar0_785 + 0L * invar1_785 + 1L * invar2_785, v); } return new Object[] { container_0, container_1 }; } // --- test_785 end --- // --- test_819 start --- // invarRest fields: private static long invar0_819 = 0; private static long invar1_819 = 0; private static long invar2_819 = 0; private static long invar3_819 = 0; // Containers fields: private static MemorySegment original_container0_819 = MemorySegment.ofArray(new char[78804]); private static MemorySegment test_container0_819 = MemorySegment.ofArray(new char[78804]); private static MemorySegment reference_container0_819 = MemorySegment.ofArray(new char[78804]); private static MemorySegment original_container1_819 = MemorySegment.ofArray(new char[78804]); private static MemorySegment test_container1_819 = MemorySegment.ofArray(new char[78804]); private static MemorySegment reference_container1_819 = MemorySegment.ofArray(new char[78804]); // Index forms for the accesses: private static IndexForm index0_819 = new IndexForm(-666, 1, -1, new int[] {0, -1, 1, 0}, 1); private static IndexForm index1_819 = new IndexForm(70716, -8, 8, new int[] {0, -1, 0, 0}, 8); // Count the run invocations. private static int iterations_819 = 0; @Run(test = "test_819") @Warmup(100) public static void run_819(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_819++; // Init containers from original data: test_container0_819.copyFrom(original_container0_819); reference_container0_819.copyFrom(original_container0_819); test_container1_819.copyFrom(original_container1_819); reference_container1_819.copyFrom(original_container1_819); // Container aliasing: var test_0 = (iterations_819 % 2 == 0) ? test_container0_819 : test_container0_819; var reference_0 = (iterations_819 % 2 == 0) ? reference_container0_819 : reference_container0_819; var test_1 = (iterations_819 % 2 == 0) ? test_container1_819 : test_container1_819; var reference_1 = (iterations_819 % 2 == 0) ? reference_container1_819 : reference_container1_819; // Generate ranges: int middle = RANDOM.nextInt(157608 / 3, 157608 * 2 / 3); int rnd = Math.min(256, 157608 / 10); int range = 157608 / 3 - RANDOM.nextInt(rnd); var r0 = new IndexForm.Range(0, middle); var r1 = new IndexForm.Range(middle, 157608); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 157608; int invar0_0 = index0_819.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_819.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_819.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_819.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_819 = RANDOM.nextInt(-1, 2); invar1_819 = RANDOM.nextInt(-1, 2); invar2_819 = RANDOM.nextInt(-1, 2); invar3_819 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(-666 + 1 * i + -1 * invar0_0 + 0 * invar0_819 + -1 * invar1_819 + 1 * invar2_819 + 0 * invar3_819); int lo_1 = (int)(70716 + -8 * i + 8 * invar0_1 + 0 * invar0_819 + -1 * invar1_819 + 0 * invar2_819 + 0 * invar3_819); i = ivHi; int hi_0 = (int)(-666 + 1 * i + -1 * invar0_0 + 0 * invar0_819 + -1 * invar1_819 + 1 * invar2_819 + 0 * invar3_819); int hi_1 = (int)(70716 + -8 * i + 8 * invar0_1 + 0 * invar0_819 + -1 * invar1_819 + 0 * invar2_819 + 0 * invar3_819); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_819(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_819(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_819 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Due to cases like JDK-8360204 and JDK-8365982, there can be issues // with RCE leading cases where we remove predicates and then unroll again // and then end up multiversioning. These cases seem relatively rare but // prevent us from asserting that there is never multiversioning in these cases. public static Object test_819(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivLo; i < ivHi; i+=1) { double v = (double)container_0.get(ValueLayout.JAVA_BYTE, -666L + 1L * i + -1L * invar0_0 + 0L * invar0_819 + -1L * invar1_819 + 1L * invar2_819 + 0L * invar3_819); container_1.set(ValueLayout.JAVA_DOUBLE_UNALIGNED, 70716L + -8L * i + 8L * invar0_1 + 0L * invar0_819 + -1L * invar1_819 + 0L * invar2_819 + 0L * invar3_819, v); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_819(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivLo; i < ivHi; i+=1) { double v = (double)container_0.get(ValueLayout.JAVA_BYTE, -666L + 1L * i + -1L * invar0_0 + 0L * invar0_819 + -1L * invar1_819 + 1L * invar2_819 + 0L * invar3_819); container_1.set(ValueLayout.JAVA_DOUBLE_UNALIGNED, 70716L + -8L * i + 8L * invar0_1 + 0L * invar0_819 + -1L * invar1_819 + 0L * invar2_819 + 0L * invar3_819, v); } return new Object[] { container_0, container_1 }; } // --- test_819 end --- // --- test_853 start --- // invarRest fields: private static int invar0_853 = 0; private static int invar1_853 = 0; private static int invar2_853 = 0; private static int invar3_853 = 0; // Containers fields: private static MemorySegment original_container0_853 = MemorySegment.ofArray(new float[38542]); private static MemorySegment test_container0_853 = MemorySegment.ofArray(new float[38542]); private static MemorySegment reference_container0_853 = MemorySegment.ofArray(new float[38542]); private static MemorySegment original_container1_853 = MemorySegment.ofArray(new float[38542]); private static MemorySegment test_container1_853 = MemorySegment.ofArray(new float[38542]); private static MemorySegment reference_container1_853 = MemorySegment.ofArray(new float[38542]); // Index forms for the accesses: private static IndexForm index0_853 = new IndexForm(35200, -2, -2, new int[] {-1, 1, 1, 1}, 2); private static IndexForm index1_853 = new IndexForm(32428, -8, -8, new int[] {0, 1, 0, 1}, 8); // Count the run invocations. private static int iterations_853 = 0; @Run(test = "test_853") @Warmup(100) public static void run_853(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_853++; // Init containers from original data: test_container0_853.copyFrom(original_container0_853); reference_container0_853.copyFrom(original_container0_853); test_container1_853.copyFrom(original_container1_853); reference_container1_853.copyFrom(original_container1_853); // Container aliasing: var test_0 = (iterations_853 % 2 == 0) ? test_container0_853 : test_container0_853; var reference_0 = (iterations_853 % 2 == 0) ? reference_container0_853 : reference_container0_853; var test_1 = (iterations_853 % 2 == 0) ? test_container1_853 : test_container1_853; var reference_1 = (iterations_853 % 2 == 0) ? reference_container1_853 : reference_container1_853; // Generate ranges: int lo0 = RANDOM.nextInt(0, 154168 * 3 / 4); int lo1 = RANDOM.nextInt(0, 154168 * 3 / 4); var r0 = new IndexForm.Range(lo0, lo0 + 154168 / 4); var r1 = new IndexForm.Range(lo1, lo1 + 154168 / 4); // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 154168; int invar0_0 = index0_853.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_853.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_853.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_853.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_853 = RANDOM.nextInt(-1, 2); invar1_853 = RANDOM.nextInt(-1, 2); invar2_853 = RANDOM.nextInt(-1, 2); invar3_853 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(35200 + -2 * i + -2 * invar0_0 + -1 * invar0_853 + 1 * invar1_853 + 1 * invar2_853 + 1 * invar3_853); int lo_1 = (int)(32428 + -8 * i + -8 * invar0_1 + 0 * invar0_853 + 1 * invar1_853 + 0 * invar2_853 + 1 * invar3_853); i = ivHi; int hi_0 = (int)(35200 + -2 * i + -2 * invar0_0 + -1 * invar0_853 + 1 * invar1_853 + 1 * invar2_853 + 1 * invar3_853); int hi_1 = (int)(32428 + -8 * i + -8 * invar0_1 + 0 * invar0_853 + 1 * invar1_853 + 0 * invar2_853 + 1 * invar3_853); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_853(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_853(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_853 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Due to cases like JDK-8360204 and JDK-8365982, there can be issues // with RCE leading cases where we remove predicates and then unroll again // and then end up multiversioning. These cases seem relatively rare but // prevent us from asserting that there is never multiversioning in these cases. public static Object test_853(MemorySegment container_0, int invar0_0, MemorySegment container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivLo; i < ivHi; i+=1) { container_0.set(ValueLayout.JAVA_CHAR_UNALIGNED, 35200L + -2L * i + -2L * invar0_0 + -1L * invar0_853 + 1L * invar1_853 + 1L * invar2_853 + 1L * invar3_853, (char)0x0102030405060708L); container_1.set(ValueLayout.JAVA_LONG_UNALIGNED, 32428L + -8L * i + -8L * invar0_1 + 0L * invar0_853 + 1L * invar1_853 + 0L * invar2_853 + 1L * invar3_853, (long)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_853(MemorySegment container_0, int invar0_0, MemorySegment container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivLo; i < ivHi; i+=1) { container_0.set(ValueLayout.JAVA_CHAR_UNALIGNED, 35200L + -2L * i + -2L * invar0_0 + -1L * invar0_853 + 1L * invar1_853 + 1L * invar2_853 + 1L * invar3_853, (char)0x0102030405060708L); container_1.set(ValueLayout.JAVA_LONG_UNALIGNED, 32428L + -8L * i + -8L * invar0_1 + 0L * invar0_853 + 1L * invar1_853 + 0L * invar2_853 + 1L * invar3_853, (long)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } // --- test_853 end --- // --- test_887 start --- // invarRest fields: private static long invar0_887 = 0; // Containers fields: private static MemorySegment original_container0_887 = MemorySegment.ofArray(new long[9547]); private static MemorySegment test_container0_887 = MemorySegment.ofArray(new long[9547]); private static MemorySegment reference_container0_887 = MemorySegment.ofArray(new long[9547]); private static MemorySegment original_container1_887 = MemorySegment.ofArray(new long[9547]); private static MemorySegment test_container1_887 = MemorySegment.ofArray(new long[9547]); private static MemorySegment reference_container1_887 = MemorySegment.ofArray(new long[9547]); // Index forms for the accesses: private static IndexForm index0_887 = new IndexForm(-97593, -1, 1, new int[] {0}, 1); private static IndexForm index1_887 = new IndexForm(85040, -1, -1, new int[] {1}, 1); // Count the run invocations. private static int iterations_887 = 0; @Run(test = "test_887") @Warmup(100) public static void run_887(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_887++; // Init containers from original data: test_container0_887.copyFrom(original_container0_887); reference_container0_887.copyFrom(original_container0_887); test_container1_887.copyFrom(original_container1_887); reference_container1_887.copyFrom(original_container1_887); // Container aliasing: var test_0 = (iterations_887 % 2 == 0) ? test_container0_887 : test_container0_887; var reference_0 = (iterations_887 % 2 == 0) ? reference_container0_887 : reference_container0_887; var test_1 = (iterations_887 % 2 == 0) ? test_container1_887 : test_container1_887; var reference_1 = (iterations_887 % 2 == 0) ? reference_container1_887 : reference_container1_887; // Generate ranges: int lo0 = RANDOM.nextInt(0, 19094 * 3 / 4); int lo1 = RANDOM.nextInt(0, 19094 * 3 / 4); var r0 = new IndexForm.Range(lo0, lo0 + 19094 / 4); var r1 = new IndexForm.Range(lo1, lo1 + 19094 / 4); // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 76376; int invar0_0 = index0_887.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_887.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_887.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_887.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_887 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(-97593 + -1 * i + 1 * invar0_0 + 0 * invar0_887); int lo_1 = (int)(85040 + -1 * i + -1 * invar0_1 + 1 * invar0_887); i = ivHi; int hi_0 = (int)(-97593 + -1 * i + 1 * invar0_0 + 0 * invar0_887); int hi_1 = (int)(85040 + -1 * i + -1 * invar0_1 + 1 * invar0_887); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_887(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_887(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_887 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Due to cases like JDK-8360204 and JDK-8365982, there can be issues // with RCE leading cases where we remove predicates and then unroll again // and then end up multiversioning. These cases seem relatively rare but // prevent us from asserting that there is never multiversioning in these cases. public static Object test_887(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivHi-1; i >= ivLo; i-=1) { var v = container_0.getAtIndex(ValueLayout.JAVA_INT_UNALIGNED, -97593L + -1L * i + 1L * invar0_0 + 0L * invar0_887); container_1.setAtIndex(ValueLayout.JAVA_INT_UNALIGNED, 85040L + -1L * i + -1L * invar0_1 + 1L * invar0_887, v); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_887(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivHi-1; i >= ivLo; i-=1) { var v = container_0.getAtIndex(ValueLayout.JAVA_INT_UNALIGNED, -97593L + -1L * i + 1L * invar0_0 + 0L * invar0_887); container_1.setAtIndex(ValueLayout.JAVA_INT_UNALIGNED, 85040L + -1L * i + -1L * invar0_1 + 1L * invar0_887, v); } return new Object[] { container_0, container_1 }; } // --- test_887 end --- // --- test_921 start --- // invarRest fields: private static int invar0_921 = 0; private static int invar1_921 = 0; // Containers fields: private static MemorySegment original_container0_921 = MemorySegment.ofArray(new char[74092]); private static MemorySegment test_container0_921 = MemorySegment.ofArray(new char[74092]); private static MemorySegment reference_container0_921 = MemorySegment.ofArray(new char[74092]); private static MemorySegment original_container1_921 = MemorySegment.ofArray(new char[74092]); private static MemorySegment test_container1_921 = MemorySegment.ofArray(new char[74092]); private static MemorySegment reference_container1_921 = MemorySegment.ofArray(new char[74092]); // Index forms for the accesses: private static IndexForm index0_921 = new IndexForm(77800, -1, 4, new int[] {-1, -1}, 4); private static IndexForm index1_921 = new IndexForm(87221, -2, -8, new int[] {1, 0}, 8); // Count the run invocations. private static int iterations_921 = 0; @Run(test = "test_921") @Warmup(100) public static void run_921(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_921++; // Init containers from original data: test_container0_921.copyFrom(original_container0_921); reference_container0_921.copyFrom(original_container0_921); test_container1_921.copyFrom(original_container1_921); reference_container1_921.copyFrom(original_container1_921); // Container aliasing: var test_0 = (iterations_921 % 2 == 0) ? test_container0_921 : test_container0_921; var reference_0 = (iterations_921 % 2 == 0) ? reference_container0_921 : reference_container0_921; var test_1 = (iterations_921 % 2 == 0) ? test_container1_921 : test_container0_921; var reference_1 = (iterations_921 % 2 == 0) ? reference_container1_921 : reference_container0_921; // Generate ranges: int middle = RANDOM.nextInt(148184 / 3, 148184 * 2 / 3); int rnd = Math.min(256, 148184 / 10); int range = 148184 / 3 - RANDOM.nextInt(rnd); var r0 = new IndexForm.Range(middle - range, middle); var r1 = new IndexForm.Range(middle, middle + range); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 148184; int invar0_0 = index0_921.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_921.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_921.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_921.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 4000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_921 = RANDOM.nextInt(-1, 2); invar1_921 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(77800 + -1 * i + 4 * invar0_0 + -1 * invar0_921 + -1 * invar1_921); int lo_1 = (int)(87221 + -2 * i + -8 * invar0_1 + 1 * invar0_921 + 0 * invar1_921); i = ivHi; int hi_0 = (int)(77800 + -1 * i + 4 * invar0_0 + -1 * invar0_921 + -1 * invar1_921); int hi_1 = (int)(87221 + -2 * i + -8 * invar0_1 + 1 * invar0_921 + 0 * invar1_921); // Bounds should not overlap. if (false || (lo_1 < lo_0 && lo_1 < hi_0 && hi_1 < lo_0 && hi_1 < hi_0) || (lo_1 > lo_0 && lo_1 > hi_0 && hi_1 > lo_0 && hi_1 > hi_0) ) { // pass } else { throw new RuntimeException("bounds overlap!"); } // Run test and compare with interpreter results. var result = test_921(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_921(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_921 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Due to cases like JDK-8360204 and JDK-8365982, there can be issues // with RCE leading cases where we remove predicates and then unroll again // and then end up multiversioning. These cases seem relatively rare but // prevent us from asserting that there is never multiversioning in these cases. public static Object test_921(MemorySegment container_0, int invar0_0, MemorySegment container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivLo; i < ivHi; i+=4) { container_0.set(ValueLayout.JAVA_FLOAT_UNALIGNED, 77800L + -1L * i + 4L * invar0_0 + -1L * invar0_921 + -1L * invar1_921, (float)0x0102030405060708L); container_1.set(ValueLayout.JAVA_LONG_UNALIGNED, 87221L + -2L * i + -8L * invar0_1 + 1L * invar0_921 + 0L * invar1_921, (long)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_921(MemorySegment container_0, int invar0_0, MemorySegment container_1, int invar0_1, int ivLo, int ivHi) { for (int i = ivLo; i < ivHi; i+=4) { container_0.set(ValueLayout.JAVA_FLOAT_UNALIGNED, 77800L + -1L * i + 4L * invar0_0 + -1L * invar0_921 + -1L * invar1_921, (float)0x0102030405060708L); container_1.set(ValueLayout.JAVA_LONG_UNALIGNED, 87221L + -2L * i + -8L * invar0_1 + 1L * invar0_921 + 0L * invar1_921, (long)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } // --- test_921 end --- // --- test_955 start --- // invarRest fields: private static long invar0_955 = 0; private static long invar1_955 = 0; private static long invar2_955 = 0; private static long invar3_955 = 0; // Containers fields: private static MemorySegment original_container0_955 = MemorySegment.ofArray(new short[37738]); private static MemorySegment test_container0_955 = MemorySegment.ofArray(new short[37738]); private static MemorySegment reference_container0_955 = MemorySegment.ofArray(new short[37738]); private static MemorySegment original_container1_955 = MemorySegment.ofArray(new short[37738]); private static MemorySegment test_container1_955 = MemorySegment.ofArray(new short[37738]); private static MemorySegment reference_container1_955 = MemorySegment.ofArray(new short[37738]); // Index forms for the accesses: private static IndexForm index0_955 = new IndexForm(-71852, 1, 1, new int[] {0, 0, 1, 1}, 1); private static IndexForm index1_955 = new IndexForm(-4318, -4, 4, new int[] {0, 1, 0, -1}, 4); // Count the run invocations. private static int iterations_955 = 0; @Run(test = "test_955") @Warmup(100) public static void run_955(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_955++; // Init containers from original data: test_container0_955.copyFrom(original_container0_955); reference_container0_955.copyFrom(original_container0_955); test_container1_955.copyFrom(original_container1_955); reference_container1_955.copyFrom(original_container1_955); // Container aliasing: var test_0 = (iterations_955 % 2 == 0) ? test_container0_955 : test_container0_955; var reference_0 = (iterations_955 % 2 == 0) ? reference_container0_955 : reference_container0_955; var test_1 = (iterations_955 % 2 == 0) ? test_container1_955 : test_container0_955; var reference_1 = (iterations_955 % 2 == 0) ? reference_container1_955 : reference_container0_955; // Generate ranges: int rnd = Math.min(256, 75476 / 10); int middle = 75476 / 2 + RANDOM.nextInt(-rnd, rnd); int range = 75476 / 3 - RANDOM.nextInt(rnd); int overlap = RANDOM.nextInt(-rnd, rnd); var r0 = new IndexForm.Range(middle - range + overlap, middle + overlap); var r1 = new IndexForm.Range(middle, middle + range); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 75476; int invar0_0 = index0_955.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_955.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_955.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_955.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 1000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_955 = RANDOM.nextInt(-1, 2); invar1_955 = RANDOM.nextInt(-1, 2); invar2_955 = RANDOM.nextInt(-1, 2); invar3_955 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(-71852 + 1 * i + 1 * invar0_0 + 0 * invar0_955 + 0 * invar1_955 + 1 * invar2_955 + 1 * invar3_955); int lo_1 = (int)(-4318 + -4 * i + 4 * invar0_1 + 0 * invar0_955 + 1 * invar1_955 + 0 * invar2_955 + -1 * invar3_955); i = ivHi; int hi_0 = (int)(-71852 + 1 * i + 1 * invar0_0 + 0 * invar0_955 + 0 * invar1_955 + 1 * invar2_955 + 1 * invar3_955); int hi_1 = (int)(-4318 + -4 * i + 4 * invar0_1 + 0 * invar0_955 + 1 * invar1_955 + 0 * invar2_955 + -1 * invar3_955); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_955(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_955(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_955 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Aliasing unknown, we may use the predicate or multiversioning. public static Object test_955(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivHi-1; i >= ivLo; i-=1) { container_0.set(ValueLayout.JAVA_BYTE, -71852L + 1L * i + 1L * invar0_0 + 0L * invar0_955 + 0L * invar1_955 + 1L * invar2_955 + 1L * invar3_955, (byte)0x0102030405060708L); container_1.set(ValueLayout.JAVA_FLOAT_UNALIGNED, -4318L + -4L * i + 4L * invar0_1 + 0L * invar0_955 + 1L * invar1_955 + 0L * invar2_955 + -1L * invar3_955, (float)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_955(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivHi-1; i >= ivLo; i-=1) { container_0.set(ValueLayout.JAVA_BYTE, -71852L + 1L * i + 1L * invar0_0 + 0L * invar0_955 + 0L * invar1_955 + 1L * invar2_955 + 1L * invar3_955, (byte)0x0102030405060708L); container_1.set(ValueLayout.JAVA_FLOAT_UNALIGNED, -4318L + -4L * i + 4L * invar0_1 + 0L * invar0_955 + 1L * invar1_955 + 0L * invar2_955 + -1L * invar3_955, (float)0x1112131415161718L); } return new Object[] { container_0, container_1 }; } // --- test_955 end --- // --- test_989 start --- // invarRest fields: private static long invar0_989 = 0; private static long invar1_989 = 0; private static long invar2_989 = 0; private static long invar3_989 = 0; // Containers fields: private static MemorySegment original_container0_989 = Arena.ofAuto().allocate(146096); private static MemorySegment test_container0_989 = Arena.ofAuto().allocate(146096); private static MemorySegment reference_container0_989 = Arena.ofAuto().allocate(146096); private static MemorySegment original_container1_989 = Arena.ofAuto().allocate(146096); private static MemorySegment test_container1_989 = Arena.ofAuto().allocate(146096); private static MemorySegment reference_container1_989 = Arena.ofAuto().allocate(146096); // Index forms for the accesses: private static IndexForm index0_989 = new IndexForm(45676, 4, -8, new int[] {1, -1, -1, -1}, 8); private static IndexForm index1_989 = new IndexForm(74324, -2, 2, new int[] {-1, 1, -1, 1}, 2); // Count the run invocations. private static int iterations_989 = 0; @Run(test = "test_989") @Warmup(100) public static void run_989(RunInfo info) { // Once warmup is over (100x), repeat 10x to get reasonable coverage of the // randomness in the tests. int reps = info.isWarmUp() ? 10 : 1; for (int r = 0; r < reps; r++) { iterations_989++; // Init containers from original data: test_container0_989.copyFrom(original_container0_989); reference_container0_989.copyFrom(original_container0_989); test_container1_989.copyFrom(original_container1_989); reference_container1_989.copyFrom(original_container1_989); // Container aliasing: var test_0 = (iterations_989 % 2 == 0) ? test_container0_989 : test_container0_989; var reference_0 = (iterations_989 % 2 == 0) ? reference_container0_989 : reference_container0_989; var test_1 = (iterations_989 % 2 == 0) ? test_container1_989 : test_container1_989; var reference_1 = (iterations_989 % 2 == 0) ? reference_container1_989 : reference_container1_989; // Generate ranges: int rnd = Math.min(256, 146096 / 10); int middle = 146096 / 2 + RANDOM.nextInt(-rnd, rnd); int range = 146096 / 3 - RANDOM.nextInt(rnd); int overlap = RANDOM.nextInt(-rnd, rnd); var r0 = new IndexForm.Range(middle - range + overlap, middle + overlap); var r1 = new IndexForm.Range(middle, middle + range); if (RANDOM.nextBoolean()) { var tmp = r0; r0 = r1; r1 = tmp; } // Compute loop bounds and loop invariants. int ivLo = RANDOM.nextInt(-1000, 1000); int ivHi = ivLo + 146096; int invar0_0 = index0_989.invar0ForIvLo(r0, ivLo); ivHi = Math.min(ivHi, index0_989.ivHiForInvar0(r0, invar0_0)); int invar0_1 = index1_989.invar0ForIvLo(r1, ivLo); ivHi = Math.min(ivHi, index1_989.ivHiForInvar0(r1, invar0_1)); // Let's check that the range is large enough, so that the vectorized // main loop can even be entered. if (ivLo + 2000 > ivHi) { throw new RuntimeException("iv range too small: " + ivLo + " " + ivHi); } invar0_989 = RANDOM.nextInt(-1, 2); invar1_989 = RANDOM.nextInt(-1, 2); invar2_989 = RANDOM.nextInt(-1, 2); invar3_989 = RANDOM.nextInt(-1, 2); // Verify the bounds we just created, just to be sure there is no unexpected aliasing! int i = ivLo; int lo_0 = (int)(45676 + 4 * i + -8 * invar0_0 + 1 * invar0_989 + -1 * invar1_989 + -1 * invar2_989 + -1 * invar3_989); int lo_1 = (int)(74324 + -2 * i + 2 * invar0_1 + -1 * invar0_989 + 1 * invar1_989 + -1 * invar2_989 + 1 * invar3_989); i = ivHi; int hi_0 = (int)(45676 + 4 * i + -8 * invar0_0 + 1 * invar0_989 + -1 * invar1_989 + -1 * invar2_989 + -1 * invar3_989); int hi_1 = (int)(74324 + -2 * i + 2 * invar0_1 + -1 * invar0_989 + 1 * invar1_989 + -1 * invar2_989 + 1 * invar3_989); // Aliasing unknown, cannot verify bounds. // Run test and compare with interpreter results. var result = test_989(test_0, invar0_0, test_1, invar0_1, ivLo, ivHi); var expected = reference_989(reference_0, invar0_0, reference_1, invar0_1, ivLo, ivHi); Verify.checkEQ(result, expected); } // end reps } // end run_989 @Test // Unfortunately, there are some issues that prevent RangeCheck elimination. // The cases are currently quite unpredictable, so we cannot create any IR // rules - sometimes there are vectors sometimes not. // Due to cases like JDK-8360204 and JDK-8365982, there can be issues // with RCE leading cases where we remove predicates and then unroll again // and then end up multiversioning. These cases seem relatively rare but // prevent us from asserting that there is never multiversioning in these cases. public static Object test_989(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivLo; i < ivHi; i+=2) { short v = (short)container_0.get(ValueLayout.JAVA_LONG_UNALIGNED, 45676L + 4L * i + -8L * invar0_0 + 1L * invar0_989 + -1L * invar1_989 + -1L * invar2_989 + -1L * invar3_989); container_1.set(ValueLayout.JAVA_SHORT_UNALIGNED, 74324L + -2L * i + 2L * invar0_1 + -1L * invar0_989 + 1L * invar1_989 + -1L * invar2_989 + 1L * invar3_989, v); } return new Object[] { container_0, container_1 }; } @DontCompile public static Object reference_989(MemorySegment container_0, long invar0_0, MemorySegment container_1, long invar0_1, long ivLo, long ivHi) { for (long i = ivLo; i < ivHi; i+=2) { short v = (short)container_0.get(ValueLayout.JAVA_LONG_UNALIGNED, 45676L + 4L * i + -8L * invar0_0 + 1L * invar0_989 + -1L * invar1_989 + -1L * invar2_989 + -1L * invar3_989); container_1.set(ValueLayout.JAVA_SHORT_UNALIGNED, 74324L + -2L * i + 2L * invar0_1 + -1L * invar0_989 + 1L * invar1_989 + -1L * invar2_989 + 1L * invar3_989, v); } return new Object[] { container_0, container_1 }; } // --- test_989 end --- // --- LIST OF TESTS end --- }