/*

 * Copyright (c) 2015, 2019, 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.

 */

package org.graalvm.compiler.core.test;

import static org.graalvm.compiler.nodeinfo.NodeCycles.CYCLES_IGNORED;

import static org.graalvm.compiler.nodeinfo.NodeSize.SIZE_IGNORED;

import org.graalvm.compiler.api.directives.GraalDirectives;

import org.graalvm.compiler.graph.NodeClass;

import org.graalvm.compiler.loop.InductionVariable;

import org.graalvm.compiler.loop.LoopsData;

import org.graalvm.compiler.nodeinfo.NodeInfo;

import org.graalvm.compiler.nodes.ConstantNode;

import org.graalvm.compiler.nodes.NodeView;

import org.graalvm.compiler.nodes.StructuredGraph;

import org.graalvm.compiler.nodes.ValueNode;

import org.graalvm.compiler.nodes.calc.FloatingNode;

import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderContext;

import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugin;

import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugins;

import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugins.Registration;

import org.graalvm.compiler.nodes.spi.LIRLowerable;

import org.graalvm.compiler.nodes.spi.NodeLIRBuilderTool;

import org.graalvm.compiler.phases.OptimisticOptimizations;

import org.graalvm.compiler.phases.tiers.HighTierContext;

import org.junit.Test;

import jdk.vm.ci.meta.JavaKind;

import jdk.vm.ci.meta.ResolvedJavaMethod;

public class CountedLoopTest extends GraalCompilerTest {

    @FunctionalInterface

    private interface IVProperty {

        ValueNode get(InductionVariable iv);

    }

    @FunctionalInterface

    private interface StaticIVProperty {

        long get(InductionVariable iv);

    }

    @FunctionalInterface

    private interface IVPredicate {

        boolean test(InductionVariable iv);

    }

    /**

     * Get a property of an induction variable.

     */

    @SuppressWarnings("unused")

    private static int get(IVProperty property, StaticIVProperty staticProperty, IVPredicate constantCheck, int iv) {

        return iv;

    }

    @SuppressWarnings("unused")

    private static int get(IVProperty property, int iv) {

        return iv;

    }

    @SuppressWarnings("unused")

    private static long get(IVProperty property, StaticIVProperty staticProperty, IVPredicate constantCheck,

                    long iv) {

        return iv;

    }

    @SuppressWarnings("unused")

    private static long get(IVProperty property, long iv) {

        return iv;

    }

    private static class Result {

        public long extremum;

        public long exitValue;

        @Override

        public int hashCode() {

            final int prime = 31;

            int result = 1;

            result = prime * result + Long.hashCode(exitValue);

            result = prime * result + Long.hashCode(extremum);

            return result;

        }

        @Override

        public boolean equals(Object obj) {

            if (!(obj instanceof Result)) {

                return false;

            }

            Result other = (Result) obj;

            return extremum == other.extremum && exitValue == other.exitValue;

        }

        @Override

        public String toString() {

            return String.format("extremum = %d, exitValue = %d", extremum, exitValue);

        }

    }

    public static Result incrementSnippet(int start, int limit, int step) {

        int i;

        int inc = ((step - 1) & 0xFFFF) + 1; // make sure this value is always strictly positive

        Result ret = new Result();

        for (i = start; i < limit; i += inc) {

            GraalDirectives.controlFlowAnchor();

            ret.extremum = get(InductionVariable::extremumNode, InductionVariable::constantExtremum, InductionVariable::isConstantExtremum, i);

        }

        ret.exitValue = get(InductionVariable::exitValueNode, i);

        return ret;

    }

    @Test

    public void increment1() {

        testCounted("incrementSnippet", 0, 256, 1);

    }

    @Test

    public void increment2() {

        testCounted("incrementSnippet", 0, 256, 2);

    }

    @Test

    public void increment3() {

        testCounted("incrementSnippet", 0, 256, 3);

    }

    @Test

    public void increment4() {

        testCounted("incrementSnippet", -10, 1, Integer.MAX_VALUE);

    }

    @Test

    public void increment5() {

        testRemovableCounted("incrementSnippet", 256, 256, 1);

    }

    @Test

    public void increment6() {

        testRemovableCounted("incrementSnippet", 257, 256, 1);

    }

    @Test

    public void increment7() {

        testCounted("incrementSnippet", -10, Integer.MAX_VALUE, 1);

    }

    @Test

    public void increment8() {

        testCounted("incrementSnippet", -10, Integer.MAX_VALUE - 1, 2);

    }

    public static Result incrementEqSnippet(int start, int limit, int step) {

        int i;

        int inc = ((step - 1) & 0xFFFF) + 1; // make sure this value is always strictly positive

        Result ret = new Result();

        for (i = start; i <= limit; i += inc) {

            GraalDirectives.controlFlowAnchor();

            ret.extremum = get(InductionVariable::extremumNode, InductionVariable::constantExtremum, InductionVariable::isConstantExtremum, i);

        }

        ret.exitValue = get(InductionVariable::exitValueNode, i);

        return ret;

    }

    @Test

    public void incrementEq1() {

        testCounted("incrementEqSnippet", 0, 256, 1);

    }

    @Test

    public void incrementEq2() {

        testCounted("incrementEqSnippet", 0, 256, 2);

    }

    @Test

    public void incrementEq3() {

        testCounted("incrementEqSnippet", 0, 256, 3);

    }

    @Test

    public void incrementEq4() {

        testCounted("incrementEqSnippet", -10, 0, Integer.MAX_VALUE);

    }

    @Test

    public void incrementEq5() {

        testCounted("incrementEqSnippet", 256, 256, 1);

    }

    @Test

    public void incrementEq6() {

        testRemovableCounted("incrementEqSnippet", 257, 256, 1);

    }

    @Test

    public void incrementEq7() {

        testCounted("incrementEqSnippet", -10, Integer.MAX_VALUE - 1, 1);

    }

    @Test

    public void incrementEq8() {

        testCounted("incrementEqSnippet", -10, Integer.MAX_VALUE - 2, 2);

    }

    @Test

    public void incrementEq9() {

        testCounted("incrementEqSnippet", 0, 0, 1);

    }

    @Test

    public void incrementEq10() {

        testCounted("incrementEqSnippet", 0, 0, 3);

    }

    public static Result decrementSnippet(int start, int limit, int step) {

        int i;

        int dec = ((step - 1) & 0xFFFF) + 1; // make sure this value is always strictly positive

        Result ret = new Result();

        for (i = start; i > limit; i -= dec) {

            GraalDirectives.controlFlowAnchor();

            ret.extremum = get(InductionVariable::extremumNode, InductionVariable::constantExtremum, InductionVariable::isConstantExtremum, i);

        }

        ret.exitValue = get(InductionVariable::exitValueNode, i);

        return ret;

    }

    @Test

    public void decrement1() {

        testCounted("decrementSnippet", 256, 0, 1);

    }

    @Test

    public void decrement2() {

        testCounted("decrementSnippet", 256, 0, 2);

    }

    @Test

    public void decrement3() {

        testCounted("decrementSnippet", 256, 0, 3);

    }

    @Test

    public void decrement4() {

        testCounted("decrementSnippet", Integer.MAX_VALUE, -10, 1);

    }

    @Test

    public void decrement5() {

        testCounted("decrementSnippet", Integer.MAX_VALUE, -10, 2);

    }

    public static Result decrementEqSnippet(int start, int limit, int step) {

        int i;

        int dec = ((step - 1) & 0xFFFF) + 1; // make sure this value is always strictly positive

        Result ret = new Result();

        for (i = start; i >= limit; i -= dec) {

            GraalDirectives.controlFlowAnchor();

            ret.extremum = get(InductionVariable::extremumNode, InductionVariable::constantExtremum, InductionVariable::isConstantExtremum, i);

        }

        ret.exitValue = get(InductionVariable::exitValueNode, i);

        return ret;

    }

    @Test

    public void decrementEq1() {

        testCounted("decrementEqSnippet", 256, 0, 1);

    }

    @Test

    public void decrementEq2() {

        testCounted("decrementEqSnippet", 256, 0, 2);

    }

    @Test

    public void decrementEq3() {

        testCounted("decrementEqSnippet", 256, 0, 3);

    }

    @Test

    public void decrementEq4() {

        testRemovableCounted("decrementEqSnippet", -10, 0, Integer.MAX_VALUE);

    }

    @Test

    public void decrementEq5() {

        testCounted("decrementEqSnippet", Integer.MAX_VALUE, -10, 1);

    }

    @Test

    public void decrementEq6() {

        testCounted("decrementEqSnippet", Integer.MAX_VALUE, -10, 2);

    }

    @Test

    public void decrementEq7() {

        testCounted("decrementEqSnippet", 10, 10, 1);

    }

    @Test

    public void decrementEq8() {

        testCounted("decrementEqSnippet", 10, 10, 3);

    }

    public static Result twoVariablesSnippet() {

        Result ret = new Result();

        int j = 0;

        for (int i = 0; i < 1024; i++) {

            j += 5;

            GraalDirectives.controlFlowAnchor();

            ret.extremum = get(InductionVariable::extremumNode, InductionVariable::constantExtremum, InductionVariable::isConstantExtremum, j);

        }

        ret.exitValue = get(InductionVariable::exitValueNode, j);

        return ret;

    }

    @Test

    public void testTwoVariables() {

        testCounted("twoVariablesSnippet");

    }

    public static Result incrementNeqSnippet(int limit) {

        int i;

        int posLimit = ((limit - 1) & 0xFFFF) + 1; // make sure limit is always strictly positive

        Result ret = new Result();

        for (i = 0; i != posLimit; i++) {

            GraalDirectives.controlFlowAnchor();

            ret.extremum = get(InductionVariable::extremumNode, InductionVariable::constantExtremum, InductionVariable::isConstantExtremum, i);

        }

        ret.exitValue = get(InductionVariable::exitValueNode, i);

        return ret;

    }

    @Test

    public void decrementNeq() {

        testCounted("decrementNeqSnippet", 256);

    }

    public static Result decrementNeqSnippet(int limit) {

        int i;

        int posLimit = ((limit - 1) & 0xFFFF) + 1; // make sure limit is always strictly positive

        Result ret = new Result();

        for (i = posLimit; i != 0; i--) {

            GraalDirectives.controlFlowAnchor();

            ret.extremum = get(InductionVariable::extremumNode, InductionVariable::constantExtremum, InductionVariable::isConstantExtremum, i);

        }

        ret.exitValue = get(InductionVariable::exitValueNode, i);

        return ret;

    }

    @Test

    public void incrementNeq() {

        testCounted("incrementNeqSnippet", 256);

    }

    public static Result incrementLongSnippet(long start, long limit, long step) {

        long i;

        long inc = ((step - 1) & 0xFFFF) + 1; // make sure this value is always strictly positive

        Result ret = new Result();

        for (i = start; i < limit; i += inc) {

            GraalDirectives.controlFlowAnchor();

            ret.extremum = get(InductionVariable::extremumNode, InductionVariable::constantExtremum, InductionVariable::isConstantExtremum, i);

        }

        ret.exitValue = get(InductionVariable::exitValueNode, i);

        return ret;

    }

    @Test

    public void incrementLong1() {

        testCounted("incrementLongSnippet", 0L, 256L, 1L);

    }

    @Test

    public void incrementLong2() {

        testCounted("incrementLongSnippet", 0L, 256L, 2L);

    }

    @Test

    public void incrementLong3() {

        testCounted("incrementLongSnippet", 0L, 256L, 3L);

    }

    @Test

    public void incrementLong4() {

        testCounted("incrementLongSnippet", -10L, 1L, Long.MAX_VALUE);

    }

    @Test

    public void incrementLong5() {

        testRemovableCounted("incrementLongSnippet", 256L, 256L, 1L);

    }

    @Test

    public void incrementLong6() {

        testRemovableCounted("incrementLongSnippet", 257L, 256L, 1L);

    }

    public static Result incrementUnsignedSnippet(int start, int limit, int step) {

        int i;

        int inc = ((step - 1) & 0xFFFF) + 1; // make sure this value is always strictly positive

        Result ret = new Result();

        for (i = start; Integer.compareUnsigned(i, limit) < 0; i += inc) {

            GraalDirectives.controlFlowAnchor();

            ret.extremum = get(InductionVariable::extremumNode, InductionVariable::constantExtremum, InductionVariable::isConstantExtremum, i);

        }

        ret.exitValue = get(InductionVariable::exitValueNode, i);

        return ret;

    }

    @Test

    public void incrementUnsigned1() {

        testCounted("incrementUnsignedSnippet", 0, 256, 1);

    }

    @Test

    public void incrementUnsigned2() {

        testCounted("incrementUnsignedSnippet", 0, 256, 2);

    }

    @Test

    public void incrementUnsigned3() {

        testCounted("incrementUnsignedSnippet", 0, 256, 3);

    }

    @Test

    public void incrementUnsigned4() {

        testCounted("incrementUnsignedSnippet", 1, Integer.MAX_VALUE + 10, Integer.MAX_VALUE);

    }

    @Test

    public void incrementUnsigned5() {

        testRemovableCounted("incrementUnsignedSnippet", 256, 256, 1);

    }

    @Test

    public void incrementUnsigned6() {

        testRemovableCounted("incrementUnsignedSnippet", 257, 256, 1);

    }

    @Test

    public void incrementUnsigned7() {

        testCounted("incrementUnsignedSnippet", 0, Integer.MAX_VALUE + 10, 1);

    }

    @Test

    public void incrementUnsigned8a() {

        testCounted("incrementUnsignedSnippet", 0, Integer.MAX_VALUE + 11, 2);

    }

    @Test

    public void incrementUnsigned8b() {

        testCounted("incrementUnsignedSnippet", 0, Integer.MAX_VALUE + 10, 2);

    }

    @Test

    public void incrementUnsigned9() {

        testCounted("incrementUnsignedSnippet", Integer.MAX_VALUE - 1, Integer.MAX_VALUE + 10, 1);

    }

    @Test

    public void incrementUnsigned10() {

        testCounted("incrementUnsignedSnippet", Integer.MAX_VALUE - 1, Integer.MAX_VALUE + 10, 2);

    }

    public static Result decrementUnsignedSnippet(int start, int limit, int step) {

        int dec = ((step - 1) & 0xFFFF) + 1; // make sure this value is always strictly positive

        Result ret = new Result();

        int i;

        for (i = start; Integer.compareUnsigned(i, limit) > 0; i -= dec) {

            GraalDirectives.controlFlowAnchor();

            ret.extremum = get(InductionVariable::extremumNode, InductionVariable::constantExtremum, InductionVariable::isConstantExtremum, i);

        }

        ret.exitValue = get(InductionVariable::exitValueNode, i);

        return ret;

    }

    @Test

    public void decrementUnsigned1() {

        testCounted("decrementUnsignedSnippet", 256, 0, 1);

    }