/*
* Copyright (C) 2015 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.
*/

public class Main {

  // Note #1: `javac` flips the conditions of If statements.
  // Note #2: In the optimizing compiler, the first input of Phi is always
  //          the fall-through path, i.e. the false branch.

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

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

  /*
   * Elementary test negating a boolean. Verifies that blocks are merged and
   * empty branches removed.
   */

  // CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (before)
  // CHECK-DAG:     <<Param:z\d+>>    ParameterValue
  // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
  // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
  // CHECK-DAG:                       If [<<Param>>]
  // CHECK-DAG:     <<Phi:i\d+>>      Phi [<<Const1>>,<<Const0>>]
  // CHECK-DAG:                       Return [<<Phi>>]

  // CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (before)
  // CHECK:                           Goto
  // CHECK:                           Goto
  // CHECK:                           Goto
  // CHECK-NOT:                       Goto

  // CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (after)
  // CHECK-DAG:     <<Param:z\d+>>    ParameterValue
  // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
  // CHECK-DAG:     <<NotParam:z\d+>> BooleanNot [<<Param>>]
  // CHECK-DAG:                       Return [<<NotParam>>]

  // CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (after)
  // CHECK-NOT:                       If
  // CHECK-NOT:                       Phi

  // CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (after)
  // CHECK:                           Goto
  // CHECK-NOT:                       Goto

  public static boolean BooleanNot(boolean x) {
    return !x;
  }

  /*
   * Program which only delegates the condition, i.e. returns 1 when True
   * and 0 when False.
   */

  // CHECK-START: boolean Main.GreaterThan(int, int) boolean_simplifier (before)
  // CHECK-DAG:     <<ParamX:i\d+>>   ParameterValue
  // CHECK-DAG:     <<ParamY:i\d+>>   ParameterValue
  // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
  // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
  // CHECK-DAG:     <<Cond:z\d+>>     GreaterThan [<<ParamX>>,<<ParamY>>]
  // CHECK-DAG:                       If [<<Cond>>]
  // CHECK-DAG:     <<Phi:i\d+>>      Phi [<<Const0>>,<<Const1>>]
  // CHECK-DAG:                       Return [<<Phi>>]

  // CHECK-START: boolean Main.GreaterThan(int, int) boolean_simplifier (after)
  // CHECK-DAG:     <<ParamX:i\d+>>   ParameterValue
  // CHECK-DAG:     <<ParamY:i\d+>>   ParameterValue
  // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
  // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
  // CHECK-DAG:     <<Cond:z\d+>>     GreaterThan [<<ParamX>>,<<ParamY>>]
  // CHECK-DAG:                       Return [<<Cond>>]

  public static boolean GreaterThan(int x, int y) {
    return (x <= y) ? false : true;
  }

  /*
   * Program which negates a condition, i.e. returns 0 when True
   * and 1 when False.
   */

  // CHECK-START: boolean Main.LessThan(int, int) boolean_simplifier (before)
  // CHECK-DAG:     <<ParamX:i\d+>>   ParameterValue
  // CHECK-DAG:     <<ParamY:i\d+>>   ParameterValue
  // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
  // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
  // CHECK-DAG:     <<Cond:z\d+>>     GreaterThanOrEqual [<<ParamX>>,<<ParamY>>]
  // CHECK-DAG:                       If [<<Cond>>]
  // CHECK-DAG:     <<Phi:i\d+>>      Phi [<<Const1>>,<<Const0>>]
  // CHECK-DAG:                       Return [<<Phi>>]

  // CHECK-START: boolean Main.LessThan(int, int) boolean_simplifier (after)
  // CHECK-DAG:     <<ParamX:i\d+>>   ParameterValue
  // CHECK-DAG:     <<ParamY:i\d+>>   ParameterValue
  // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
  // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
  // CHECK-DAG:     <<Cond:z\d+>>     LessThan [<<ParamX>>,<<ParamY>>]
  // CHECK-DAG:                       Return [<<Cond>>]

  // CHECK-START: boolean Main.LessThan(int, int) boolean_simplifier (after)
  // CHECK-NOT:                       GreaterThanOrEqual

  public static boolean LessThan(int x, int y) {
    return (x < y) ? true : false;
  }

  /*
   * Program which further uses negated conditions.
   * Note that Phis are discovered retrospectively.
   */

  // CHECK-START: boolean Main.ValuesOrdered(int, int, int) boolean_simplifier (before)
  // CHECK-DAG:     <<ParamX:i\d+>>   ParameterValue
  // CHECK-DAG:     <<ParamY:i\d+>>   ParameterValue
  // CHECK-DAG:     <<ParamZ:i\d+>>   ParameterValue
  // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
  // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
  // CHECK-DAG:     <<CondXY:z\d+>>   GreaterThan [<<ParamX>>,<<ParamY>>]
  // CHECK-DAG:                       If [<<CondXY>>]
  // CHECK-DAG:     <<CondYZ:z\d+>>   GreaterThan [<<ParamY>>,<<ParamZ>>]
  // CHECK-DAG:                       If [<<CondYZ>>]
  // CHECK-DAG:     <<CondXYZ:z\d+>>  NotEqual [<<PhiXY:i\d+>>,<<PhiYZ:i\d+>>]
  // CHECK-DAG:                       If [<<CondXYZ>>]
  // CHECK-DAG:                       Return [<<PhiXYZ:i\d+>>]
  // CHECK-DAG:     <<PhiXY>>         Phi [<<Const1>>,<<Const0>>]
  // CHECK-DAG:     <<PhiYZ>>         Phi [<<Const1>>,<<Const0>>]
  // CHECK-DAG:     <<PhiXYZ>>        Phi [<<Const1>>,<<Const0>>]

  // CHECK-START: boolean Main.ValuesOrdered(int, int, int) boolean_simplifier (after)
  // CHECK-DAG:     <<ParamX:i\d+>>   ParameterValue
  // CHECK-DAG:     <<ParamY:i\d+>>   ParameterValue
  // CHECK-DAG:     <<ParamZ:i\d+>>   ParameterValue
  // CHECK-DAG:     <<CmpXY:z\d+>>    LessThanOrEqual [<<ParamX>>,<<ParamY>>]
  // CHECK-DAG:     <<CmpYZ:z\d+>>    LessThanOrEqual [<<ParamY>>,<<ParamZ>>]
  // CHECK-DAG:     <<CmpXYZ:z\d+>>   Equal [<<CmpXY>>,<<CmpYZ>>]
  // CHECK-DAG:                       Return [<<CmpXYZ>>]

  public static boolean ValuesOrdered(int x, int y, int z) {
    return (x <= y) == (y <= z);
  }

  // CHECK-START: int Main.NegatedCondition(boolean) boolean_simplifier (before)
  // CHECK-DAG:     <<Param:z\d+>>    ParameterValue
  // CHECK-DAG:     <<Const42:i\d+>>  IntConstant 42
  // CHECK-DAG:     <<Const43:i\d+>>  IntConstant 43
  // CHECK-DAG:     <<NotParam:z\d+>> BooleanNot [<<Param>>]
  // CHECK-DAG:                       If [<<NotParam>>]
  // CHECK-DAG:     <<Phi:i\d+>>      Phi [<<Const42>>,<<Const43>>]
  // CHECK-DAG:                       Return [<<Phi>>]

  // CHECK-START: int Main.NegatedCondition(boolean) boolean_simplifier (after)
  // CHECK-DAG:     <<Param:z\d+>>    ParameterValue
  // CHECK-DAG:     <<Const42:i\d+>>  IntConstant 42
  // CHECK-DAG:     <<Const43:i\d+>>  IntConstant 43
  // CHECK-DAG:                       If [<<Param>>]
  // CHECK-DAG:     <<Phi:i\d+>>      Phi [<<Const42>>,<<Const43>>]
  // CHECK-DAG:                       Return [<<Phi>>]

  // Note: The fact that branches are swapped is verified by running the test.

  // CHECK-START: int Main.NegatedCondition(boolean) boolean_simplifier (after)
  // CHECK-NOT:                       BooleanNot

  public static int NegatedCondition(boolean x) {
    if (x != false) {
      return 42;
    } else {
      return 43;
    }
  }

  public static void main(String[] args) {
    assertBoolEquals(false, BooleanNot(true));
    assertBoolEquals(true, BooleanNot(false));
    assertBoolEquals(true, GreaterThan(10, 5));
    assertBoolEquals(false, GreaterThan(10, 10));
    assertBoolEquals(false, GreaterThan(5, 10));
    assertBoolEquals(true, LessThan(5, 10));
    assertBoolEquals(false, LessThan(10, 10));
    assertBoolEquals(false, LessThan(10, 5));
    assertBoolEquals(true, ValuesOrdered(1, 3, 5));
    assertBoolEquals(true, ValuesOrdered(5, 3, 1));
    assertBoolEquals(false, ValuesOrdered(1, 3, 2));
    assertBoolEquals(false, ValuesOrdered(2, 3, 1));
    assertBoolEquals(true, ValuesOrdered(3, 3, 3));
    assertBoolEquals(true, ValuesOrdered(3, 3, 5));
    assertBoolEquals(false, ValuesOrdered(5, 5, 3));
    assertIntEquals(42, NegatedCondition(true));
    assertIntEquals(43, NegatedCondition(false));
  }
}