/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Tests on loop optimizations related to induction.
 */
public class Main {

    static int[] a = new int[10];

    static int[] novec = new int[20];  // to prevent vectorization

    /// CHECK-START: void Main.deadSingleLoop() loop_optimization (before)
    /// CHECK-DAG: Phi loop:{{B\d+}} outer_loop:none
    //
    /// CHECK-START: void Main.deadSingleLoop() loop_optimization (after)
    /// CHECK-NOT: Phi
    static void deadSingleLoop() {
        for (int i = 0; i < 4; i++) {
        }
    }

    /// CHECK-START: void Main.deadSingleLoop() loop_optimization (before)
    /// CHECK-DAG: Phi loop:{{B\d+}} outer_loop:none
    //
    /// CHECK-START: void Main.deadSingleLoop() loop_optimization (after)
    /// CHECK-NOT: Phi
    static void deadSingleLoopN(int n) {
        for (int i = 0; i < n; i++) {
        }
    }

    /// CHECK-START: void Main.potentialInfiniteLoop(int) loop_optimization (before)
    /// CHECK-DAG: Phi loop:{{B\d+}} outer_loop:none
    //
    /// CHECK-START: void Main.potentialInfiniteLoop(int) loop_optimization (after)
    /// CHECK-DAG: Phi loop:{{B\d+}} outer_loop:none
    static void potentialInfiniteLoop(int n) {
        for (int i = 0; i <= n; i++) {  // loops forever when n = MAX_INT
        }
    }

    /// CHECK-START: void Main.deadNestedLoops() loop_optimization (before)
    /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: Phi loop:{{B\d+}}      outer_loop:<<Loop>>
    //
    /// CHECK-START: void Main.deadNestedLoops() loop_optimization (after)
    /// CHECK-NOT: Phi
    static void deadNestedLoops() {
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
            }
        }
    }

    /// CHECK-START: void Main.deadNestedAndFollowingLoops() loop_optimization (before)
    /// CHECK-DAG: Phi loop:<<Loop1:B\d+>> outer_loop:none
    /// CHECK-DAG: Phi loop:<<Loop2:B\d+>> outer_loop:<<Loop1>>
    /// CHECK-DAG: Phi loop:{{B\d+}}       outer_loop:<<Loop2>>
    /// CHECK-DAG: Phi loop:{{B\d+}}       outer_loop:<<Loop2>>
    /// CHECK-DAG: Phi loop:<<Loop3:B\d+>> outer_loop:<<Loop1>>
    /// CHECK-DAG: Phi loop:{{B\d+}}       outer_loop:<<Loop3>>
    /// CHECK-DAG: Phi loop:{{B\d+}}       outer_loop:none
    //
    /// CHECK-START: void Main.deadNestedAndFollowingLoops() loop_optimization (after)
    /// CHECK-NOT: Phi
    static void deadNestedAndFollowingLoops() {
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                for (int k = 0; k < 4; k++) {
                }
                for (int k = 0; k < 4; k++) {
                }
            }
            for (int j = 0; j < 4; j++) {
                for (int k = 0; k < 4; k++) {
                }
            }
        }
        for (int i = 0; i < 4; i++) {
        }
    }

    /// CHECK-START: void Main.deadConditional(int) loop_optimization (before)
    /// CHECK-DAG: Phi loop:{{B\d+}} outer_loop:none
    //
    /// CHECK-START: void Main.deadConditional(int) loop_optimization (after)
    /// CHECK-NOT: Phi
    public static void deadConditional(int n) {
        int k = 0;
        int m = 0;
        for (int i = 0; i < n; i++) {
            if (i == 3)
                k = i;
            else
                m = i;
        }
    }

    /// CHECK-START: void Main.deadConditionalCycle(int) loop_optimization (before)
    /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
    //
    /// CHECK-START: void Main.deadConditionalCycle(int) loop_optimization (after)
    /// CHECK-NOT: Phi
    public static void deadConditionalCycle(int n) {
        int k = 0;
        int m = 0;
        for (int i = 0; i < n; i++) {
            if (i == 3)
                k--;
            else
                m++;
        }
    }


    /// CHECK-START: void Main.deadInduction() loop_optimization (before)
    /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: Phi      loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
    //
    /// CHECK-START: void Main.deadInduction() loop_optimization (after)
    /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-NOT: Phi      loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
    static void deadInduction() {
        int dead = 0;
        for (int i = 0; i < a.length; i++) {
            a[i] = novec[2 * i] + 1;
            dead += 5;
        }
    }

    /// CHECK-START: void Main.deadManyInduction() loop_optimization (before)
    /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: Phi      loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: Phi      loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: Phi      loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
    //
    /// CHECK-START: void Main.deadManyInduction() loop_optimization (after)
    /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-NOT: Phi      loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
    static void deadManyInduction() {
        int dead1 = 0, dead2 = 1, dead3 = 3;
        for (int i = 0; i < a.length; i++) {
            dead1 += 5;
            a[i] = novec[2 * i] + 2;
            dead2 += 10;
            dead3 += 100;
        }
    }

    /// CHECK-START: void Main.deadSequence() loop_optimization (before)
    /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: Phi      loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
    //
    /// CHECK-START: void Main.deadSequence() loop_optimization (after)
    /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-NOT: Phi      loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
    static void deadSequence() {
        int dead = 0;
        for (int i = 0; i < a.length; i++) {
            a[i] = novec[2 * i] + 3;
            // Increment value defined inside loop,
            // but sequence itself not used anywhere.
            dead += i;
        }
    }

    /// CHECK-START: void Main.deadCycleWithException(int) loop_optimization (before)
    /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: Phi      loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
    /// CHECK-NOT: BoundsCheck
    //
    /// CHECK-START: void Main.deadCycleWithException(int) loop_optimization (after)
    /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-NOT: Phi      loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
    /// CHECK-NOT: ArrayGet loop:<<Loop>>      outer_loop:none
    static void deadCycleWithException(int k) {
        int dead = 0;
        for (int i = 0; i < a.length; i++) {
            a[i] = novec[2 * i] + 4;
            // Increment value of dead cycle may throw exception. Dynamic
            // BCE takes care of the bounds check though, which enables
            // removing the ArrayGet after removing the dead cycle.
            dead += a[k];
        }
    }

    /// CHECK-START: int Main.closedFormInductionUp() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    //
    /// CHECK-START: int Main.closedFormInductionUp() loop_optimization (after)
    /// CHECK-NOT:               Phi
    //
    /// CHECK-START: int Main.closedFormInductionUp() instruction_simplifier$before_codegen (after)
    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 12395 loop:none
    /// CHECK-DAG:               Return [<<Int>>]  loop:none
    static int closedFormInductionUp() {
        int closed = 12345;
        for (int i = 0; i < 10; i++) {
            closed += 5;
        }
        return closed;  // only needs last value
    }

    /// CHECK-START: int Main.closedFormInductionInAndDown(int) loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi2>>] loop:none
    //
    /// CHECK-START: int Main.closedFormInductionInAndDown(int) loop_optimization (after)
    /// CHECK-NOT:               Phi
    //
    /// CHECK-START: int Main.closedFormInductionInAndDown(int) instruction_simplifier$before_codegen (after)
    /// CHECK-DAG: <<Par:i\d+>>  ParameterValue        loop:none
    /// CHECK-DAG: <<Int:i\d+>>  IntConstant -50       loop:none
    /// CHECK-DAG: <<Add:i\d+>>  Add [<<Int>>,<<Par>>] loop:none
    /// CHECK-DAG:               Return [<<Add>>]      loop:none
    static int closedFormInductionInAndDown(int closed) {
        for (int i = 0; i < 10; i++) {
            closed -= 5;
        }
        return closed;  // only needs last value
    }

    /// CHECK-START: int Main.closedFormInductionTrivialIf() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Select            loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    //
    /// CHECK-START: int Main.closedFormInductionTrivialIf() loop_optimization (after)
    /// CHECK-NOT:               Phi
    /// CHECK-NOT:               Select
    //
    /// CHECK-START: int Main.closedFormInductionTrivialIf() instruction_simplifier$before_codegen (after)
    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 81    loop:none
    /// CHECK-DAG:               Return [<<Int>>]  loop:none
    static int closedFormInductionTrivialIf() {
        int closed = 11;
        for (int i = 0; i < 10; i++) {
            // Trivial if becomes trivial select at HIR level.
            // Make sure this is still recognized as induction.
            if (i < 5) {
                closed += 7;
            } else {
                closed += 7;
            }
        }
        return closed;  // only needs last value
    }

    /// CHECK-START: int Main.closedFormNested() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop1:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop1>>      outer_loop:none
    /// CHECK-DAG: <<Phi3:i\d+>> Phi               loop:<<Loop2:B\d+>> outer_loop:<<Loop1>>
    /// CHECK-DAG: <<Phi4:i\d+>> Phi               loop:<<Loop2>>      outer_loop:<<Loop1>>
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    //
    /// CHECK-START: int Main.closedFormNested() loop_optimization (after)
    /// CHECK-NOT:               Phi
    //
    /// CHECK-START: int Main.closedFormNested() instruction_simplifier$before_codegen (after)
    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 100  loop:none
    /// CHECK-DAG:               Return [<<Int>>] loop:none
    static int closedFormNested() {
        int closed = 0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                closed++;
            }
        }
        return closed;  // only needs last-value
    }

    /// CHECK-START: int Main.closedFormNestedAlt() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop1:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop1>>      outer_loop:none
    /// CHECK-DAG: <<Phi3:i\d+>> Phi               loop:<<Loop2:B\d+>> outer_loop:<<Loop1>>
    /// CHECK-DAG: <<Phi4:i\d+>> Phi               loop:<<Loop2>>      outer_loop:<<Loop1>>
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    //
    /// CHECK-START: int Main.closedFormNestedAlt() loop_optimization (after)
    /// CHECK-NOT:               Phi
    //
    /// CHECK-START: int Main.closedFormNestedAlt() instruction_simplifier$before_codegen (after)
    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 15082 loop:none
    /// CHECK-DAG:               Return [<<Int>>]  loop:none
    static int closedFormNestedAlt() {
        int closed = 12345;
        for (int i = 0; i < 17; i++) {
            for (int j = 0; j < 23; j++) {
                closed += 7;
            }
        }
        return closed;  // only needs last-value
    }

    // closedFormInductionUpN turns into `if n < 0 then 12345 else 12345 + n * 5`.

    /// CHECK-START: int Main.closedFormInductionUpN(int) loop_optimization (before)
    /// CHECK:                       Phi
    /// CHECK:                       Phi
    /// CHECK-NOT:                   Phi
    //
    /// CHECK-START: int Main.closedFormInductionUpN(int) loop_optimization (after)
    /// CHECK-NOT:                   Phi
    //
    /// CHECK-START: int Main.closedFormInductionUpN(int) loop_optimization (after)
    /// CHECK-DAG: <<N:i\d+>>        ParameterValue
    /// CHECK-DAG: <<Int5:i\d+>>     IntConstant 5
    /// CHECK-DAG: <<Int12345:i\d+>> IntConstant 12345
    /// CHECK-DAG: <<Int0:i\d+>>     IntConstant 0
    /// CHECK-DAG: <<Mul:i\d+>>      Mul [<<Int5>>,<<N>>]
    /// CHECK-DAG: <<Add:i\d+>>      Add [<<Mul>>,<<Int12345>>]
    /// CHECK-DAG: <<LT:z\d+>>       LessThan [<<Int0>>,<<N>>]
    /// CHECK-DAG: <<Sel:i\d+>>      Select [<<Int12345>>,<<Add>>,<<LT>>]
    /// CHECK-DAG:                   Return [<<Sel>>]
    static int closedFormInductionUpN(int n) {
        int closed = 12345;
        for (int i = 0; i < n; i++) {
            closed += 5;
        }
        return closed;  // only needs last value
    }

    // closedFormInductionInAndDownN turns into `if n < 0 then closed else closed - n * 5`.

    /// CHECK-START: int Main.closedFormInductionInAndDownN(int, int) loop_optimization (before)
    /// CHECK:                       Phi
    /// CHECK:                       Phi
    /// CHECK-NOT:                   Phi
    //
    /// CHECK-START: int Main.closedFormInductionInAndDownN(int, int) loop_optimization (after)
    /// CHECK-NOT:                   Phi
    //
    /// CHECK-START: int Main.closedFormInductionInAndDownN(int, int) loop_optimization (after)
    /// CHECK-DAG: <<Closed:i\d+>>   ParameterValue
    /// CHECK-DAG: <<N:i\d+>>        ParameterValue
    /// CHECK-DAG: <<IntNeg5:i\d+>>  IntConstant -5
    /// CHECK-DAG: <<Int0:i\d+>>     IntConstant 0
    /// CHECK-DAG: <<Mul:i\d+>>      Mul [<<IntNeg5>>,<<N>>]
    /// CHECK-DAG: <<Add:i\d+>>      Add [<<Mul>>,<<Closed>>]
    /// CHECK-DAG: <<LT:z\d+>>       LessThan [<<Int0>>,<<N>>]
    /// CHECK-DAG: <<Sel:i\d+>>      Select [<<Closed>>,<<Add>>,<<LT>>]
    /// CHECK-DAG:                   Return [<<Sel>>]
    static int closedFormInductionInAndDownN(int closed, int n) {
        for (int i = 0; i < n; i++) {
            closed -= 5;
        }
        return closed;  // only needs last value
    }

    // closedFormNestedN turns into `if (n < 0) then 0 else n * 10`

    /// CHECK-START: int Main.closedFormNestedN(int) loop_optimization (before)
    /// CHECK:                       Phi
    /// CHECK:                       Phi
    /// CHECK:                       Phi
    /// CHECK:                       Phi
    /// CHECK-NOT:                   Phi
    //
    /// CHECK-START: int Main.closedFormNestedN(int) loop_optimization (after)
    /// CHECK-NOT:                   Phi
    //
    /// CHECK-START: int Main.closedFormNestedN(int) loop_optimization (after)
    /// CHECK-DAG: <<N:i\d+>>        ParameterValue
    /// CHECK-DAG: <<Int10:i\d+>>    IntConstant 10
    /// CHECK-DAG: <<Int0:i\d+>>     IntConstant 0
    /// CHECK-DAG: <<Mul:i\d+>>      Mul [<<Int10>>,<<N>>]
    /// CHECK-DAG: <<Add:i\d+>>      Add [<<Mul>>,<<Int0>>]
    /// CHECK-DAG: <<LT:z\d+>>       LessThan [<<Int0>>,<<N>>]
    /// CHECK-DAG: <<Sel:i\d+>>      Select [<<Int0>>,<<Add>>,<<LT>>]
    /// CHECK-DAG:                   Return [<<Sel>>]
    static int closedFormNestedN(int n) {
        int closed = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < 10; j++) {
                closed++;
            }
        }
        return closed;  // only needs last-value
    }

    // closedFormNestedNAlt turns into `if (n < 0) then 12345 else 12345 + n * 161`

    /// CHECK-START: int Main.closedFormNestedNAlt(int) loop_optimization (before)
    /// CHECK:                       Phi
    /// CHECK:                       Phi
    /// CHECK:                       Phi
    /// CHECK:                       Phi
    /// CHECK-NOT:                   Phi
    //
    /// CHECK-START: int Main.closedFormNestedNAlt(int) loop_optimization (after)
    /// CHECK-NOT:                   Phi
    //
    /// CHECK-START: int Main.closedFormNestedNAlt(int) loop_optimization (after)
    /// CHECK-DAG: <<N:i\d+>>        ParameterValue
    /// CHECK-DAG: <<Int161:i\d+>>   IntConstant 161
    /// CHECK-DAG: <<Int12345:i\d+>> IntConstant 12345
    /// CHECK-DAG: <<Int0:i\d+>>     IntConstant 0
    /// CHECK-DAG: <<Mul:i\d+>>      Mul [<<Int161>>,<<N>>]
    /// CHECK-DAG: <<Add:i\d+>>      Add [<<Mul>>,<<Int12345>>]
    /// CHECK-DAG: <<LT:z\d+>>       LessThan [<<Int0>>,<<N>>]
    /// CHECK-DAG: <<Sel:i\d+>>      Select [<<Int12345>>,<<Add>>,<<LT>>]
    /// CHECK-DAG:                   Return [<<Sel>>]
    static int closedFormNestedNAlt(int n) {
        int closed = 12345;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < 23; j++) {
                closed += 7;
            }
        }
        return closed;  // only needs last-value
    }

    // We optimize only the inner loop. It turns into `if (n < 0) then closed else closed + n`.
    // Potentially we can also update the outer loop turning into if (m < 0) then 0 else if (n < 0)
    // then 0 else m * n`.
    /// CHECK-START: int Main.closedFormNestedMN(int, int) loop_optimization (before)
    /// CHECK:                       Phi
    /// CHECK:                       Phi
    /// CHECK:                       Phi
    /// CHECK:                       Phi
    /// CHECK-NOT:                   Phi
    //
    /// CHECK-START: int Main.closedFormNestedMN(int, int) loop_optimization (after)
    /// CHECK:                       Phi
    /// CHECK:                       Phi
    /// CHECK-NOT:                   Phi
    //
    // Inner loop optimization
    /// CHECK-START: int Main.closedFormNestedMN(int, int) loop_optimization (after)
    /// CHECK-DAG: <<M:i\d+>>        ParameterValue
    /// CHECK-DAG: <<N:i\d+>>        ParameterValue
    /// CHECK-DAG: <<Int0:i\d+>>     IntConstant 0
    /// CHECK-DAG: <<Phi:i\d+>>      Phi
    /// CHECK-DAG: <<Add:i\d+>>      Add [<<N>>,<<Phi>>]
    /// CHECK-DAG: <<LT:z\d+>>       LessThan [<<Int0>>,<<N>>]
    /// CHECK-DAG: <<Sel:i\d+>>      Select [<<Phi>>,<<Add>>,<<LT>>]
    static int closedFormNestedMN(int m, int n) {
        int closed = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                closed++;
            }
        }
        return closed;  // only needs last-value
    }

    // We optimize only the inner loop. It turns into `if (n < 0) then closed else closed + n * 7`.
    // Potentially we can also update the outer loop turning into if (m < 0) then 0 else if (n < 0)
    // then 1245 else 12345 + m * n * 7`.
    /// CHECK-START: int Main.closedFormNestedMNAlt(int, int) loop_optimization (before)
    /// CHECK:                       Phi
    /// CHECK:                       Phi
    /// CHECK:                       Phi
    /// CHECK:                       Phi
    /// CHECK-NOT:                   Phi
    //
    /// CHECK-START: int Main.closedFormNestedMNAlt(int, int) loop_optimization (after)
    /// CHECK:                       Phi
    /// CHECK:                       Phi
    /// CHECK-NOT:                   Phi
    //
    // Inner loop optimization
    /// CHECK-START: int Main.closedFormNestedMNAlt(int, int) loop_optimization (after)
    /// CHECK-DAG: <<M:i\d+>>        ParameterValue
    /// CHECK-DAG: <<N:i\d+>>        ParameterValue
    /// CHECK-DAG: <<Int7:i\d+>>     IntConstant 7
    /// CHECK-DAG: <<Int0:i\d+>>     IntConstant 0
    /// CHECK-DAG: <<Phi:i\d+>>      Phi
    /// CHECK-DAG: <<Mul:i\d+>>      Mul [<<Int7>>,<<N>>]
    /// CHECK-DAG: <<Add:i\d+>>      Add [<<Mul>>,<<Phi>>]
    /// CHECK-DAG: <<LT:z\d+>>       LessThan [<<Int0>>,<<N>>]
    /// CHECK-DAG: <<Sel:i\d+>>      Select [<<Phi>>,<<Add>>,<<LT>>]
    static int closedFormNestedMNAlt(int m, int n) {
        int closed = 12345;
        for (int i = 0; i < m; i++) {
            // if n < 0 then closed else closed + n * 7
            for (int j = 0; j < n; j++) {
                closed += 7;
            }
        }
        return closed;  // only needs last-value
    }

    /// CHECK-START: int Main.mainIndexReturned() loop_optimization (before)
    /// CHECK-DAG: <<Phi:i\d+>> Phi              loop:{{B\d+}} outer_loop:none
    /// CHECK-DAG:              Return [<<Phi>>] loop:none
    //
    /// CHECK-START: int Main.mainIndexReturned() loop_optimization (after)
    /// CHECK-NOT:              Phi
    //
    /// CHECK-START: int Main.mainIndexReturned() instruction_simplifier$before_codegen (after)
    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 10   loop:none
    /// CHECK-DAG:               Return [<<Int>>] loop:none
    static int mainIndexReturned() {
        int i;
        for (i = 0; i < 10; i++);
        return i;
    }

    /// CHECK-START: int Main.periodicReturned9() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    //
    /// CHECK-START: int Main.periodicReturned9() loop_optimization (after)
    /// CHECK-NOT:               Phi
    //
    /// CHECK-START: int Main.periodicReturned9() instruction_simplifier$before_codegen (after)
    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 1    loop:none
    /// CHECK-DAG:               Return [<<Int>>] loop:none
    static int periodicReturned9() {
        int k = 0;
        for (int i = 0; i < 9; i++) {
            k = 1 - k;
        }
        return k;
    }

    /// CHECK-START: int Main.periodicReturned10() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    //
    /// CHECK-START: int Main.periodicReturned10() loop_optimization (after)
    /// CHECK-NOT:               Phi
    //
    /// CHECK-START: int Main.periodicReturned10() instruction_simplifier$before_codegen (after)
    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 0    loop:none
    /// CHECK-DAG:               Return [<<Int>>] loop:none
    static int periodicReturned10() {
        int k = 0;
        for (int i = 0; i < 10; i++) {
            k = 1 - k;
        }
        return k;
    }

    /// CHECK-START: int Main.getSum21() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: <<Phi3:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi2>>] loop:none
    //
    /// CHECK-START: int Main.getSum21() loop_optimization (after)
    /// CHECK-NOT:               Phi
    //
    /// CHECK-START: int Main.getSum21() instruction_simplifier$before_codegen (after)
    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 21   loop:none
    /// CHECK-DAG:               Return [<<Int>>] loop:none
    private static int getSum21() {
        int k = 0;
        int sum = 0;
        for (int i = 0; i < 6; i++) {
            k++;
            sum += k;
        }
        return sum;
    }

    // Ensure double induction does not "overshoot" the subscript range.
    private static int getIncr2(int[] arr) {
        for (int i = 0; i < 12; ) {
            arr[i++] = 30;
            arr[i++] = 29;
        }
        int sum = 0;
        for (int i = 0; i < 12; i++) {
            sum += arr[i];
        }
        return sum;
    }

    // We can generate a select, which then DCE detects it is redundant. Therefore, we eliminate
    // these loops.

    /// CHECK-START: int Main.mainIndexReturnedN(int) loop_optimization (before)
    /// CHECK:     Phi
    /// CHECK-NOT: Phi
    //
    /// CHECK-START: int Main.mainIndexReturnedN(int) loop_optimization (after)
    /// CHECK-NOT: Phi
    //
    /// CHECK-START: int Main.mainIndexReturnedN(int) loop_optimization (after)
    /// CHECK: Select
    static int mainIndexReturnedN(int n) {
        int i;
        for (i = 0; i < n; i++);
        return i;
    }

    /// CHECK-START: int Main.mainIndexShort1(short) loop_optimization (before)
    /// CHECK:     Phi
    /// CHECK-NOT: Phi
    //
    /// CHECK-START: int Main.mainIndexShort1(short) loop_optimization (after)
    /// CHECK-NOT: Phi
    //
    /// CHECK-START: int Main.mainIndexShort1(short) loop_optimization (after)
    /// CHECK: Select
    static int mainIndexShort1(short s) {
        int i = 0;
        for (i = 0; i < s; i++) { }
        return i;
    }

    /// CHECK-START: int Main.mainIndexShort2(short) loop_optimization (before)
    /// CHECK:     Phi
    /// CHECK-NOT: Phi
    //
    /// CHECK-START: int Main.mainIndexShort2(short) loop_optimization (after)
    /// CHECK-NOT: Phi
    //
    /// CHECK-START: int Main.mainIndexShort2(short) loop_optimization (after)
    /// CHECK: Select
    static int mainIndexShort2(short s) {
        int i = 0;
        for (i = 0; s > i; i++) { }
        return i;
    }

    /// CHECK-START: int Main.periodicReturnedN(int) loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    //
    /// CHECK-START: int Main.periodicReturnedN(int) loop_optimization (after)
    /// CHECK-NOT:               Phi
    static int periodicReturnedN(int n) {
        int k = 0;
        for (int i = 0; i < n; i++) {
            k = 1 - k;
        }
        return k;
    }

    /// CHECK-START: int Main.periodicOverflowTripCountNotOptimized() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: {{i\d+}}      Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    //
    /// CHECK-START: int Main.periodicOverflowTripCountNotOptimized() loop_optimization (after)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: {{i\d+}}      Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    static int periodicOverflowTripCountNotOptimized() {
        int k = 0;
        for (int i = Integer.MIN_VALUE; i < Integer.MAX_VALUE - 81; i += 80) {
            k = 1 - k;
        }
        return k;
    }

    /// CHECK-START: int Main.periodicCouldOverflowTripCountNotOptimized(int) loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: {{i\d+}}      Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    //
    /// CHECK-START: int Main.periodicCouldOverflowTripCountNotOptimized(int) loop_optimization (after)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: {{i\d+}}      Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    static int periodicCouldOverflowTripCountNotOptimized(int start) {
        int k = 0;
        for (int i = start; i < Integer.MAX_VALUE - 81; i += 80) {
            k = 1 - k;
        }
        return k;
    }

    // If ever replaced by closed form, last value should be correct!
    private static int getSumN(int n) {
        int k = 0;
        int sum = 0;
        for (int i = 0; i < n; i++) {
            k++;
            sum += k;
        }
        return sum;
    }

    // If ever replaced by closed form, last value should be correct!
    private static int closedTwice() {
        int closed = 0;
        for (int i = 0; i < 10; i++) {
            closed++;
        }
        // Closed form of first loop defines trip count of second loop.
        int other_closed = 0;
        for (int i = 0; i < closed; i++) {
            other_closed++;
        }
        return other_closed;
    }

    /// CHECK-START: int Main.closedFeed() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop1:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop1>>      outer_loop:none
    /// CHECK-DAG: <<Phi3:i\d+>> Phi               loop:<<Loop2:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi4:i\d+>> Phi               loop:<<Loop2>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi3>>] loop:none
    /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>"
    //
    /// CHECK-START: int Main.closedFeed() loop_optimization (after)
    /// CHECK-NOT:               Phi
    //
    /// CHECK-START: int Main.closedFeed() instruction_simplifier$before_codegen (after)
    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 20   loop:none
    /// CHECK-DAG:               Return [<<Int>>] loop:none
    private static int closedFeed() {
        int closed = 0;
        for (int i = 0; i < 10; i++) {
            closed++;
        }
        // Closed form of first loop feeds into initial value of second loop,
        // used when generating closed form for the latter.
        for (int i = 0; i < 10; i++) {
            closed++;
        }
        return closed;
    }

    /// CHECK-START: int Main.closedLargeUp() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    //
    /// CHECK-START: int Main.closedLargeUp() loop_optimization (after)
    /// CHECK-NOT:               Phi
    //
    /// CHECK-START: int Main.closedLargeUp() instruction_simplifier$before_codegen (after)
    /// CHECK-DAG: <<Int:i\d+>>  IntConstant -10  loop:none
    /// CHECK-DAG:               Return [<<Int>>] loop:none
    private static int closedLargeUp() {
        int closed = 0;
        for (int i = 0; i < 10; i++) {
            closed += 0x7fffffff;
        }
        return closed;
    }

    /// CHECK-START: int Main.closedLargeDown() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    //
    /// CHECK-START: int Main.closedLargeDown() loop_optimization (after)
    /// CHECK-NOT:               Phi
    //
    /// CHECK-START: int Main.closedLargeDown() instruction_simplifier$before_codegen (after)
    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 10   loop:none
    /// CHECK-DAG:               Return [<<Int>>] loop:none
    private static int closedLargeDown() {
        int closed = 0;
        for (int i = 0; i < 10; i++) {
            closed -= 0x7fffffff;
        }
        return closed;
    }

    // Checks that we do not loop optimize if the calculation of the trip count would overflow.
    /// CHECK-START: int Main.closedLinearStepOverflow() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    //
    /// CHECK-START: int Main.closedLinearStepOverflow() loop_optimization (after)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    private static int closedLinearStepOverflow() {
        int closed = 0;
        // Note that this isn't a "one-off" error.
        // We are using MIN and MAX to make sure we overflow.
        for (int i = Integer.MIN_VALUE; i < (Integer.MAX_VALUE - 80); i += 79) {
            closed++;
        }
        return closed;
    }

    // Since we cannot guarantee that the start/end wouldn't overflow we do not perform loop
    // optimization.
    /// CHECK-START: int Main.$inline$closedByParameters(int, int) loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    //
    /// CHECK-START: int Main.$inline$closedByParameters(int, int) loop_optimization (after)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    private static int $inline$closedByParameters(int start, int end) {
        int closed = 0;
        for (int i = start; i < end; i++) {
            closed++;
        }
        return closed;
    }

    // Since we are inlining `closedByParameters` we know that the parameters are fixed and
    // therefore we can perform loop optimization.
    /// CHECK-START: int Main.closedByParametersWithInline() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    //
    /// CHECK-START: int Main.closedByParametersWithInline() loop_optimization (after)
    /// CHECK-NOT:               Phi
    //
    /// CHECK-START: int Main.closedByParametersWithInline() instruction_simplifier$before_codegen (after)
    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 10   loop:none
    /// CHECK-DAG:               Return [<<Int>>] loop:none
    private static int closedByParametersWithInline() {
        return $inline$closedByParameters(0, 10);
    }

    /// CHECK-START: int Main.waterFall() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop1:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop2:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi3:i\d+>> Phi               loop:<<Loop3:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi4:i\d+>> Phi               loop:<<Loop4:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi5:i\d+>> Phi               loop:<<Loop5:B\d+>> outer_loop:none
    /// CHECK-DAG:               Return [<<Phi5>>] loop:none
    //
    /// CHECK-START: int Main.waterFall() loop_optimization (after)
    /// CHECK-NOT:               Phi
    //
    /// CHECK-START: int Main.waterFall() instruction_simplifier$before_codegen (after)
    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 50   loop:none
    /// CHECK-DAG:               Return [<<Int>>] loop:none
    private static int waterFall() {
        int i = 0;
        for (; i < 10; i++);
        for (; i < 20; i++);
        for (; i < 30; i++);
        for (; i < 40; i++);
        for (; i < 50; i++);
        return i;  // this should become just 50
    }

    /// CHECK-START: boolean Main.periodicBoolIdiom1() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    //
    /// CHECK-START: boolean Main.periodicBoolIdiom1() loop_optimization (after)
    /// CHECK-NOT:               Phi
    //
    /// CHECK-START: boolean Main.periodicBoolIdiom1() instruction_simplifier$before_codegen (after)
    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 0    loop:none
    /// CHECK-DAG:               Return [<<Int>>] loop:none
    private static boolean periodicBoolIdiom1() {
        boolean x = true;
        for (int i = 0; i < 7; i++) {
            x = !x;
        }
        return x;
    }

    /// CHECK-START: boolean Main.periodicBoolIdiom2() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    //
    /// CHECK-START: boolean Main.periodicBoolIdiom2() loop_optimization (after)
    /// CHECK-NOT:               Phi
    //
    /// CHECK-START: boolean Main.periodicBoolIdiom2() instruction_simplifier$before_codegen (after)
    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 0    loop:none
    /// CHECK-DAG:               Return [<<Int>>] loop:none
    private static boolean periodicBoolIdiom2() {
        boolean x = true;
        for (int i = 0; i < 7; i++) {
            x = (x != true);
        }
        return x;
    }

    /// CHECK-START: boolean Main.periodicBoolIdiom3() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
    //
    /// CHECK-START: boolean Main.periodicBoolIdiom3() loop_optimization (after)
    /// CHECK-NOT:               Phi
    //
    /// CHECK-START: boolean Main.periodicBoolIdiom3() instruction_simplifier$before_codegen (after)
    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 0    loop:none
    /// CHECK-DAG:               Return [<<Int>>] loop:none
    private static boolean periodicBoolIdiom3() {
        boolean x = true;
        for (int i = 0; i < 7; i++) {
            x = (x == false);
        }
        return x;
    }

    /// CHECK-START: boolean Main.periodicBoolIdiom1N(boolean, int) loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi2>>] loop:none
    //
    /// CHECK-START: boolean Main.periodicBoolIdiom1N(boolean, int) loop_optimization (after)
    /// CHECK-NOT:               Phi
    private static boolean periodicBoolIdiom1N(boolean x, int n) {
        for (int i = 0; i < n; i++) {
            x = !x;
        }
        return x;
    }

    /// CHECK-START: boolean Main.periodicBoolIdiom2N(boolean, int) loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi2>>] loop:none
    //
    /// CHECK-START: boolean Main.periodicBoolIdiom2N(boolean, int) loop_optimization (after)
    /// CHECK-NOT:               Phi
    private static boolean periodicBoolIdiom2N(boolean x, int n) {
        for (int i = 0; i < n; i++) {
            x = (x != true);
        }
        return x;
    }

    /// CHECK-START: boolean Main.periodicBoolIdiom3N(boolean, int) loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi2>>] loop:none
    //
    /// CHECK-START: boolean Main.periodicBoolIdiom3N(boolean, int) loop_optimization (after)
    /// CHECK-NOT:               Phi
    private static boolean periodicBoolIdiom3N(boolean x, int n) {
        for (int i = 0; i < n; i++) {
            x = (x == false);
        }
        return x;
    }

    /// CHECK-START: float Main.periodicFloat10() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: <<Phi3:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: <<Phi4:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi2>>] loop:none
    //
    /// CHECK-START: float Main.periodicFloat10() loop_optimization (after)
    /// CHECK-NOT: Phi
    //
    /// CHECK-START: float Main.periodicFloat10() loop_optimization (after)
    /// CHECK-DAG: <<Float:f\d+>>  FloatConstant 2    loop:none
    /// CHECK-DAG:                 Return [<<Float>>] loop:none
    private static float periodicFloat10() {
        float r = 4.5f;
        float s = 2.0f;
        float t = -1.0f;
        for (int i = 0; i < 10; i++) {
            float tmp = t;
            t = r;
            r = s;
            s = tmp;
        }
        return r;
    }

    /// CHECK-START: float Main.periodicFloat11() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: <<Phi3:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: <<Phi4:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi2>>] loop:none
    //
    /// CHECK-START: float Main.periodicFloat11() loop_optimization (after)
    /// CHECK-NOT: Phi
    //
    /// CHECK-START: float Main.periodicFloat11() loop_optimization (after)
    /// CHECK-DAG: <<Float:f\d+>>  FloatConstant -1   loop:none
    /// CHECK-DAG:                 Return [<<Float>>] loop:none
    private static float periodicFloat11() {
        float r = 4.5f;
        float s = 2.0f;
        float t = -1.0f;
        for (int i = 0; i < 11; i++) {
            float tmp = t;
            t = r;
            r = s;
            s = tmp;
        }
        return r;
    }

    /// CHECK-START: float Main.periodicFloat12() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: <<Phi3:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG: <<Phi4:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
    /// CHECK-DAG:               Return [<<Phi2>>] loop:none
    //
    /// CHECK-START: float Main.periodicFloat12() loop_optimization (after)
    /// CHECK-NOT: Phi
    //
    /// CHECK-START: float Main.periodicFloat12() loop_optimization (after)
    /// CHECK-DAG: <<Float:f\d+>>  FloatConstant 4.5  loop:none
    /// CHECK-DAG:                 Return [<<Float>>] loop:none
    private static float periodicFloat12() {
        float r = 4.5f;
        float s = 2.0f;
        float t = -1.0f;
        for (int i = 0; i < 12; i++) {
            float tmp = t;
            t = r;
            r = s;
            s = tmp;
        }
        return r;
    }

    private static int exceptionExitBeforeAdd() {
        int k = 0;
        try {
            for (int i = 0; i < 10; i++) {
                a[i] = 0;
                k += 10;  // increment last
            }
        } catch (Exception e) {
            // Flag error by returning current
            // value of k negated.
            return -k - 1;
        }
        return k;
    }

    private static int exceptionExitAfterAdd() {
        int k = 0;
        try {
            for (int i = 0; i < 10; i++) {
                k += 10;  // increment first
                a[i] = 0;
            }
        } catch (Exception e) {
            // Flag error by returning current
            // value of k negated.
            return -k - 1;
        }
        return k;
    }

    /// CHECK-START: long Main.closedLinearInductionUnmatchedTypesNotOptimized() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:j\d+>> Phi               loop:<<Loop>>      outer_loop:none
    //
    /// CHECK-START: long Main.closedLinearInductionUnmatchedTypesNotOptimized() loop_optimization (after)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    /// CHECK-DAG: <<Phi2:j\d+>> Phi               loop:<<Loop>>      outer_loop:none
    private static long closedLinearInductionUnmatchedTypesNotOptimized() {
        long sum = 0;
        for (int i = 0; i < 10; ++i) {
            ++sum;
        }
        return sum;
    }

    /// CHECK-START: short Main.closedLinearInductionNarrowingNotOptimized() loop_optimization (before)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    //
    /// CHECK-START: short Main.closedLinearInductionNarrowingNotOptimized() loop_optimization (after)
    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
    private static short closedLinearInductionNarrowingNotOptimized() {
        short i = 0;
        for (; i < 10; ++i);
        return i;
    }

    public static void main(String[] args) {
        deadSingleLoop();
        deadSingleLoopN(4);
        potentialInfiniteLoop(4);
        deadNestedLoops();
        deadNestedAndFollowingLoops();
        deadConditional(4);
        deadConditionalCycle(4);

        deadInduction();
        for (int i = 0; i < a.length; i++) {
            expectEquals(1, a[i]);
        }
        deadManyInduction();
        for (int i = 0; i < a.length; i++) {
            expectEquals(2, a[i]);
        }
        deadSequence();
        for (int i = 0; i < a.length; i++) {
            expectEquals(3, a[i]);
        }
        try {
            deadCycleWithException(-1);
            throw new Error("Expected: IOOB exception");
        } catch (IndexOutOfBoundsException e) {
        }
        for (int i = 0; i < a.length; i++) {
            expectEquals(i == 0 ? 4 : 3, a[i]);
        }
        deadCycleWithException(0);
        for (int i = 0; i < a.length; i++) {
            expectEquals(4, a[i]);
        }

        expectEquals(12395, closedFormInductionUp());
        expectEquals(12295, closedFormInductionInAndDown(12345));
        expectEquals(81, closedFormInductionTrivialIf());
        expectEquals(10 * 10, closedFormNested());
        expectEquals(12345 + 17 * 23 * 7, closedFormNestedAlt());
        for (int n = -4; n < 10; n++) {
            int tc = (n <= 0) ? 0 : n;
            expectEquals(12345 + tc * 5, closedFormInductionUpN(n));
            expectEquals(12345 - tc * 5, closedFormInductionInAndDownN(12345, n));
            expectEquals(tc * 10, closedFormNestedN(n));
            expectEquals(12345 + tc * 23 * 7, closedFormNestedNAlt(n));
            expectEquals(tc * (tc + 1), closedFormNestedMN(n, n + 1));
            expectEquals(12345 + tc * (tc + 1) * 7, closedFormNestedMNAlt(n, n + 1));
        }

        expectEquals(10, mainIndexReturned());
        expectEquals(1, periodicReturned9());
        expectEquals(0, periodicReturned10());
        expectEquals(21, getSum21());
        expectEquals(354, getIncr2(new int[12]));
        for (int n = -4; n < 4; n++) {
            int tc = (n <= 0) ? 0 : n;
            expectEquals(tc, mainIndexReturnedN(n));
            expectEquals(tc, mainIndexShort1((short) n));
            expectEquals(tc, mainIndexShort2((short) n));
            expectEquals(tc & 1, periodicReturnedN(n));
            expectEquals((tc * (tc + 1)) / 2, getSumN(n));
        }

        expectEquals(1, periodicOverflowTripCountNotOptimized());
        expectEquals(1, periodicCouldOverflowTripCountNotOptimized(Integer.MIN_VALUE));

        expectEquals(10, closedTwice());
        expectEquals(20, closedFeed());
        expectEquals(-10, closedLargeUp());
        expectEquals(10, closedLargeDown());
        expectEquals(54366674, closedLinearStepOverflow());
        expectEquals(10, $inline$closedByParameters(0, 10));
        expectEquals(10, closedByParametersWithInline());
        expectEquals(50, waterFall());

        expectEquals(false, periodicBoolIdiom1());
        expectEquals(false, periodicBoolIdiom2());
        expectEquals(false, periodicBoolIdiom3());
        for (int n = -4; n < 10; n++) {
            int tc = (n <= 0) ? 0 : n;
            boolean even = (tc & 1) == 0;
            expectEquals(even, periodicBoolIdiom1N(true, n));
            expectEquals(!even, periodicBoolIdiom1N(false, n));
            expectEquals(even, periodicBoolIdiom2N(true, n));
            expectEquals(!even, periodicBoolIdiom2N(false, n));
            expectEquals(even, periodicBoolIdiom3N(true, n));
            expectEquals(!even, periodicBoolIdiom3N(false, n));
        }

        expectEquals( 2.0f, periodicFloat10());
        expectEquals(-1.0f, periodicFloat11());
        expectEquals( 4.5f, periodicFloat12());

        expectEquals(100, exceptionExitBeforeAdd());
        expectEquals(100, exceptionExitAfterAdd());
        a = null;
        expectEquals(-1, exceptionExitBeforeAdd());
        expectEquals(-11, exceptionExitAfterAdd());
        a = new int[4];
        expectEquals(-41, exceptionExitBeforeAdd());
        expectEquals(-51, exceptionExitAfterAdd());

        expectEquals(10, closedLinearInductionUnmatchedTypesNotOptimized());
        expectEquals(10, closedLinearInductionNarrowingNotOptimized());

        System.out.println("passed");
    }

    private static void expectEquals(float expected, float result) {
        if (expected != result) {
            throw new Error("Expected: " + expected + ", found: " + result);
        }
    }

    private static void expectEquals(int expected, int result) {
        if (expected != result) {
            throw new Error("Expected: " + expected + ", found: " + result);
        }
    }

    private static void expectEquals(boolean expected, boolean result) {
        if (expected != result) {
            throw new Error("Expected: " + expected + ", found: " + result);
        }
    }
}