/*
 * Copyright (c) 2014, 2022, 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 8066103
 * @summary C2's range check smearing allows out of bound array accesses
 * @library /test/lib /
 * @modules java.base/jdk.internal.misc
 *          java.management
 * @build jdk.test.whitebox.WhiteBox
 * @requires vm.flavor == "server" & (vm.opt.TieredStopAtLevel == null | vm.opt.TieredStopAtLevel == 4)
 * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
 * @run main/othervm -ea -Xmixed -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
 *                   -XX:-BackgroundCompilation -XX:-UseOnStackReplacement
 *                   -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+EagerJVMCI
 *                   compiler.rangechecks.TestRangeCheckSmearing
 *
 */

package compiler.rangechecks;

import compiler.whitebox.CompilerWhiteBoxTest;
import compiler.testlibrary.CompilerUtils;
import jdk.test.lib.Platform;
import jdk.test.whitebox.WhiteBox;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.HashMap;

public class TestRangeCheckSmearing {
    private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();

    @Retention(RetentionPolicy.RUNTIME)
    @interface Args { int[] value(); }

    // first range check is i + max of all constants
    @Args({0, 8})
    static int m1(int[] array, int i, boolean allaccesses) {
        int res = 0;
        res += array[i+9];
        if (allaccesses) {
            res += array[i+8];
            res += array[i+7];
            res += array[i+6];
            res += array[i+5];
            res += array[i+4];
            res += array[i+3];
            res += array[i+2];
            res += array[i+1];
        }
        return res;
    }

    // first range check is i + min of all constants
    @Args({0, -9})
    static int m2(int[] array, int i, boolean allaccesses) {
        int res = 0;
        res += array[i+1];
        if (allaccesses) {
            res += array[i+2];
            res += array[i+3];
            res += array[i+4];
            res += array[i+5];
            res += array[i+6];
            res += array[i+7];
            res += array[i+8];
            res += array[i+9];
        }
        return res;
    }

    // first range check is not i + min/max of all constants
    @Args({0, 8})
    static int m3(int[] array, int i, boolean allaccesses) {
        int res = 0;
        res += array[i+3];
        if (allaccesses) {
            res += array[i+2];
            res += array[i+1];
            res += array[i+4];
            res += array[i+5];
            res += array[i+6];
            res += array[i+7];
            res += array[i+8];
            res += array[i+9];
        }
        return res;
    }

    @Args({0, -9})
    static int m4(int[] array, int i, boolean allaccesses) {
        int res = 0;
        res += array[i+3];
        if (allaccesses) {
            res += array[i+4];
            res += array[i+1];
            res += array[i+2];
            res += array[i+5];
            res += array[i+6];
            res += array[i+7];
            res += array[i+8];
            res += array[i+9];
        }
        return res;
    }

    @Args({0, -3})
    static int m5(int[] array, int i, boolean allaccesses) {
        int res = 0;
        res += array[i+3];
        res += array[i+2];
        if (allaccesses) {
            res += array[i+1];
            res += array[i+4];
            res += array[i+5];
            res += array[i+6];
            res += array[i+7];
            res += array[i+8];
            res += array[i+9];
        }
        return res;
    }

    @Args({0, 6})
    static int m6(int[] array, int i, boolean allaccesses) {
        int res = 0;
        res += array[i+3];
        res += array[i+4];
        if (allaccesses) {
            res += array[i+2];
            res += array[i+1];
            res += array[i+5];
            res += array[i+6];
            res += array[i+7];
            res += array[i+8];
            res += array[i+9];
        }
        return res;
    }

    @Args({0, 6})
    static int m7(int[] array, int i, boolean allaccesses) {
        int res = 0;
        res += array[i+3];
        res += array[i+2];
        res += array[i+4];
        if (allaccesses) {
            res += array[i+1];
            res += array[i+5];
            res += array[i+6];
            res += array[i+7];
            res += array[i+8];
            res += array[i+9];
        }
        return res;
    }

    @Args({0, -3})
    static int m8(int[] array, int i, boolean allaccesses) {
        int res = 0;
        res += array[i+3];
        res += array[i+4];
        res += array[i+2];
        if (allaccesses) {
            res += array[i+1];
            res += array[i+5];
            res += array[i+6];
            res += array[i+7];
            res += array[i+8];
            res += array[i+9];
        }
        return res;
    }

    @Args({6, 15})
    static int m9(int[] array, int i, boolean allaccesses) {
        int res = 0;
        res += array[i+3];
        if (allaccesses) {
            res += array[i-2];
            res += array[i-1];
            res += array[i-4];
            res += array[i-5];
            res += array[i-6];
        }
        return res;
    }

    @Args({3, 12})
    static int m10(int[] array, int i, boolean allaccesses) {
        int res = 0;
        res += array[i+3];
        if (allaccesses) {
            res += array[i-2];
            res += array[i-1];
            res += array[i-3];
            res += array[i+4];
            res += array[i+5];
            res += array[i+6];
        }
        return res;
    }

    @Args({3, -3})
    static int m11(int[] array, int i, boolean allaccesses) {
        int res = 0;
        res += array[i+3];
        res += array[i-2];
        if (allaccesses) {
            res += array[i+5];
            res += array[i+6];
        }
        return res;
    }

    @Args({3, 6})
    static int m12(int[] array, int i, boolean allaccesses) {
        int res = 0;
        res += array[i+3];
        res += array[i+6];
        if (allaccesses) {
            res += array[i-2];
            res += array[i-3];
        }
        return res;
    }

    // check that identical range check is replaced by dominating one
    // only when correct
    @Args({0})
    static int m13(int[] array, int i, boolean ignore) {
        int res = 0;
        res += array[i+3];
        res += array[i+3];
        return res;
    }

    @Args({2, 0})
    static int m14(int[] array, int i, boolean ignore) {
        int res = 0;

        res += array[i];
        res += array[i-2];
        res += array[i]; // If range check below were to be removed first this cannot be considered identical to first range check
        res += array[i-1]; // range check removed so i-1 array access depends on previous check

        return res;
    }

    static int[] m15_dummy = new int[10];
    @Args({2, 0})
    static int m15(int[] array, int i, boolean ignore) {
        int res = 0;
        res += array[i];

        // When the loop is optimized out we don't want the
        // array[i-1] access which is dependent on array[i]'s
        // range check to become dependent on the identical range
        // check above.

        int[] array2 = m15_dummy;
        int j = 0;
        for (; j < 10; j++);
        if (j == 10) {
            array2 = array;
        }

        res += array2[i-2];
        res += array2[i];
        res += array2[i-1]; // range check removed so i-1 array access depends on previous check

        return res;
    }

    @Args({2, 0})
    static int m16(int[] array, int i, boolean ignore) {
        int res = 0;

        res += array[i];
        res += array[i-1];
        res += array[i-1];
        res += array[i-2];

        return res;
    }

    @Args({2, 0})
    static int m17(int[] array, int i, boolean ignore) {
        int res = 0;

        res += array[i];
        res += array[i-2];
        res += array[i-2];
        res += array[i+2];
        res += array[i+2];
        res += array[i-1];
        res += array[i-1];

        return res;
    }

    static public void main(String[] args) {
        if (WHITE_BOX.getBooleanVMFlag("BackgroundCompilation")) {
            throw new AssertionError("Background compilation enabled");
        }
        new TestRangeCheckSmearing().doTests();
    }
    boolean success = true;
    boolean exception = false;
    final int[] array = new int[10];
    final HashMap<String,Method> tests = new HashMap<>();
    {
        final Class<?> TEST_PARAM_TYPES[] = { int[].class, int.class, boolean.class };
        for (Method m : this.getClass().getDeclaredMethods()) {
            if (m.getName().matches("m[0-9]+")) {
                assert(Modifier.isStatic(m.getModifiers())) : m;
                assert(m.getReturnType() == int.class) : m;
                assert(Arrays.equals(m.getParameterTypes(), TEST_PARAM_TYPES)) : m;
                tests.put(m.getName(), m);
            }
        }
    }

    void invokeTest(Method m, int[] array, int index, boolean z) {
        try {
            m.invoke(null, array, index, z);
        } catch (ReflectiveOperationException roe) {
            Throwable ex = roe.getCause();
            if (ex instanceof ArrayIndexOutOfBoundsException)
                throw (ArrayIndexOutOfBoundsException) ex;
            throw new AssertionError(roe);
        }
    }

    void doTest(String name) {
        Method m = tests.get(name);
        tests.remove(name);
        int[] args = m.getAnnotation(Args.class).value();
        int index0 = args[0], index1;
        boolean exceptionRequired = true;
        if (args.length == 2) {
            index1 = args[1];
        } else {
            // no negative test for this one
            assert(args.length == 1);
            assert(name.equals("m13"));
            exceptionRequired = false;
            index1 = index0;
        }
        // Get the method compiled.
        if (!WHITE_BOX.isMethodCompiled(m)) {
            // If not, try to compile it with C2
            if(!WHITE_BOX.enqueueMethodForCompilation(m, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION)) {
                // C2 compiler not available, try to compile with C1
                WHITE_BOX.enqueueMethodForCompilation(m, CompilerWhiteBoxTest.COMP_LEVEL_SIMPLE);
            }
        }
        if (!WHITE_BOX.isMethodCompiled(m)) {
            throw new RuntimeException(m + " not compiled");
        }

        // valid access
        invokeTest(m, array, index0, true);

        if (!WHITE_BOX.isMethodCompiled(m)) {
            throw new RuntimeException(m + " deoptimized on valid array access");
        }

        exception = false;
        boolean test_success = true;
        try {
            invokeTest(m, array, index1, false);
        } catch(ArrayIndexOutOfBoundsException aioob) {
            exception = true;
            System.out.println("ArrayIndexOutOfBoundsException thrown in "+name);
        }
        if (!exception) {
            System.out.println("ArrayIndexOutOfBoundsException was not thrown in "+name);
        }

        if (CompilerUtils.getMaxCompilationLevel() == CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION) {
            if (exceptionRequired == WHITE_BOX.isMethodCompiled(m)) {
                System.out.println((exceptionRequired?"Didn't deoptimized":"deoptimized") + " in "+name);
                test_success = false;
            }
        }

        if (exception != exceptionRequired) {
            System.out.println((exceptionRequired?"exception required but not thrown":"not exception required but thrown") + " in "+name);
            test_success = false;
        }

        if (!test_success) {
            success = false;
            System.out.println("TEST FAILED: "+name);
        }

    }
    void doTests() {
        doTest("m1");
        doTest("m2");
        doTest("m3");
        doTest("m4");
        doTest("m5");
        doTest("m6");
        doTest("m7");
        doTest("m8");
        doTest("m9");
        doTest("m10");
        doTest("m11");
        doTest("m12");
        doTest("m13");
        doTest("m14");
        doTest("m15");
        doTest("m16");
        doTest("m17");
        if (!success) {
            throw new RuntimeException("Some tests failed");
        }
        assert(tests.isEmpty()) : tests;
    }
}