content: /*
   * 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.
   */
  
  public class Main {
  
    // A dummy value to defeat inlining of these routines.
    static boolean doThrow = false;
  
    public static void assertIntEquals(int expected, int result) {
      if (expected != result) {
        throw new Error("Expected: " + expected + ", found: " + result);
      }
    }
  
    public static void assertLongEquals(long expected, long result) {
      if (expected != result) {
        throw new Error("Expected: " + expected + ", found: " + result);
      }
    }
  
    /**
     * Test merging of `NOT+AND` into `BIC`.
     */
  
    /// CHECK-START-ARM64: int Main.$opt$noinline$notAnd(int, int) instruction_simplifier_arm64 (before)
    /// CHECK:       <<Base:i\d+>>        ParameterValue
    /// CHECK:       <<Mask:i\d+>>        ParameterValue
    /// CHECK:       <<Not:i\d+>>         Not [<<Mask>>]
    /// CHECK:       <<Op:i\d+>>          And [<<Base>>,<<Not>>]
    /// CHECK:                            Return [<<Op>>]
  
    /// CHECK-START-ARM64: int Main.$opt$noinline$notAnd(int, int) instruction_simplifier_arm64 (after)
    /// CHECK:       <<Base:i\d+>>        ParameterValue
    /// CHECK:       <<Mask:i\d+>>        ParameterValue
    /// CHECK:       <<NegOp:i\d+>>       BitwiseNegatedRight [<<Base>>,<<Mask>>] kind:And
    /// CHECK:                            Return [<<NegOp>>]
  
    /// CHECK-START-ARM64: int Main.$opt$noinline$notAnd(int, int) instruction_simplifier_arm64 (after)
    /// CHECK-NOT:                        Not
    /// CHECK-NOT:                        And
  
    /// CHECK-START-ARM64: int Main.$opt$noinline$notAnd(int, int) disassembly (after)
    /// CHECK:                            bic w{{\d+}}, w{{\d+}}, w{{\d+}}
  
  
    /// CHECK-START-ARM:   int Main.$opt$noinline$notAnd(int, int) instruction_simplifier_arm (before)
    /// CHECK:       <<Base:i\d+>>        ParameterValue
    /// CHECK:       <<Mask:i\d+>>        ParameterValue
    /// CHECK:       <<Not:i\d+>>         Not [<<Mask>>]
    /// CHECK:       <<Op:i\d+>>          And [<<Base>>,<<Not>>]
    /// CHECK:                            Return [<<Op>>]
  
    /// CHECK-START-ARM:   int Main.$opt$noinline$notAnd(int, int) instruction_simplifier_arm (after)
    /// CHECK:       <<Base:i\d+>>        ParameterValue
    /// CHECK:       <<Mask:i\d+>>        ParameterValue
    /// CHECK:       <<NegOp:i\d+>>       BitwiseNegatedRight [<<Base>>,<<Mask>>] kind:And
    /// CHECK:                            Return [<<NegOp>>]
  
    /// CHECK-START-ARM:   int Main.$opt$noinline$notAnd(int, int) instruction_simplifier_arm (after)
    /// CHECK-NOT:                        Not
    /// CHECK-NOT:                        And
  
    /// CHECK-START-ARM:   int Main.$opt$noinline$notAnd(int, int) disassembly (after)
    /// CHECK:                            bic.w r{{\d+}}, r{{\d+}}, r{{\d+}}
  
    public static int $opt$noinline$notAnd(int base, int mask) {
      if (doThrow) throw new Error();
      return base & ~mask;
    }
  
    /**
     * Test merging of `NOT+ORR` into `ORN`.
     */
  
    /// CHECK-START-ARM64: long Main.$opt$noinline$notOr(long, long) instruction_simplifier_arm64 (before)
    /// CHECK:       <<Base:j\d+>>        ParameterValue
    /// CHECK:       <<Mask:j\d+>>        ParameterValue
    /// CHECK:       <<Not:j\d+>>         Not [<<Mask>>]
    /// CHECK:       <<Op:j\d+>>          Or [<<Base>>,<<Not>>]
    /// CHECK:                            Return [<<Op>>]
  
    /// CHECK-START-ARM64: long Main.$opt$noinline$notOr(long, long) instruction_simplifier_arm64 (after)
    /// CHECK:       <<Base:j\d+>>        ParameterValue
    /// CHECK:       <<Mask:j\d+>>        ParameterValue
    /// CHECK:       <<NegOp:j\d+>>       BitwiseNegatedRight [<<Base>>,<<Mask>>] kind:Or
    /// CHECK:                            Return [<<NegOp>>]
  
    /// CHECK-START-ARM64: long Main.$opt$noinline$notOr(long, long) instruction_simplifier_arm64 (after)
    /// CHECK-NOT:                        Not
    /// CHECK-NOT:                        Or
  
    /// CHECK-START-ARM64: long Main.$opt$noinline$notOr(long, long) disassembly (after)
    /// CHECK:                            orn x{{\d+}}, x{{\d+}}, x{{\d+}}
  
  
    /// CHECK-START-ARM:   long Main.$opt$noinline$notOr(long, long) instruction_simplifier_arm (before)
    /// CHECK:       <<Base:j\d+>>        ParameterValue
    /// CHECK:       <<Mask:j\d+>>        ParameterValue
    /// CHECK:       <<Not:j\d+>>         Not [<<Mask>>]
    /// CHECK:       <<Op:j\d+>>          Or [<<Base>>,<<Not>>]
    /// CHECK:                            Return [<<Op>>]
  
    /// CHECK-START-ARM:   long Main.$opt$noinline$notOr(long, long) instruction_simplifier_arm (after)
    /// CHECK:       <<Base:j\d+>>        ParameterValue
    /// CHECK:       <<Mask:j\d+>>        ParameterValue
    /// CHECK:       <<NegOp:j\d+>>       BitwiseNegatedRight [<<Base>>,<<Mask>>] kind:Or
    /// CHECK:                            Return [<<NegOp>>]
  
    /// CHECK-START-ARM:   long Main.$opt$noinline$notOr(long, long) instruction_simplifier_arm (after)
    /// CHECK-NOT:                        Not
    /// CHECK-NOT:                        Or
  
    /// CHECK-START-ARM:   long Main.$opt$noinline$notOr(long, long) disassembly (after)
    /// CHECK:                            orn.w r{{\d+}}, r{{\d+}}, r{{\d+}}
  
    public static long $opt$noinline$notOr(long base, long mask) {
      if (doThrow) throw new Error();
      return base | ~mask;
    }
  
    /**
     * Test merging of `NOT+EOR` into `EON`.
     */
  
    /// CHECK-START-ARM64: int Main.$opt$noinline$notXor(int, int) instruction_simplifier_arm64 (before)
    /// CHECK:       <<Base:i\d+>>        ParameterValue
    /// CHECK:       <<Mask:i\d+>>        ParameterValue
    /// CHECK:       <<Not:i\d+>>         Not [<<Mask>>]
    /// CHECK:       <<Op:i\d+>>          Xor [<<Base>>,<<Not>>]
    /// CHECK:                            Return [<<Op>>]
  
    /// CHECK-START-ARM64: int Main.$opt$noinline$notXor(int, int) instruction_simplifier_arm64 (after)
    /// CHECK:       <<Base:i\d+>>        ParameterValue
    /// CHECK:       <<Mask:i\d+>>        ParameterValue
    /// CHECK:       <<NegOp:i\d+>>       BitwiseNegatedRight [<<Base>>,<<Mask>>] kind:Xor
    /// CHECK:                            Return [<<NegOp>>]
  
    /// CHECK-START-ARM64: int Main.$opt$noinline$notXor(int, int) instruction_simplifier_arm64 (after)
    /// CHECK-NOT:                        Not
    /// CHECK-NOT:                        Xor
  
    /// CHECK-START-ARM64: int Main.$opt$noinline$notXor(int, int) disassembly (after)
    /// CHECK:                            eon w{{\d+}}, w{{\d+}}, w{{\d+}}
  
  
    /// CHECK-START-ARM:   int Main.$opt$noinline$notXor(int, int) instruction_simplifier_arm (before)
    /// CHECK:       <<Base:i\d+>>        ParameterValue
    /// CHECK:       <<Mask:i\d+>>        ParameterValue
    /// CHECK:       <<Not:i\d+>>         Not [<<Mask>>]
    /// CHECK:       <<Op:i\d+>>          Xor [<<Base>>,<<Not>>]
    /// CHECK:                            Return [<<Op>>]
  
    /// CHECK-START-ARM:   int Main.$opt$noinline$notXor(int, int) instruction_simplifier_arm (after)
    /// CHECK:       <<Base:i\d+>>        ParameterValue
    /// CHECK:       <<Mask:i\d+>>        ParameterValue
    /// CHECK:       <<Not:i\d+>>         Not [<<Mask>>]
    /// CHECK:       <<Op:i\d+>>          Xor [<<Base>>,<<Not>>]
    /// CHECK:                            Return [<<Op>>]
  
    /// CHECK-START-ARM:   int Main.$opt$noinline$notXor(int, int) instruction_simplifier_arm (after)
    /// CHECK-NOT:                        BitwiseNegatedRight
  
    public static int $opt$noinline$notXor(int base, int mask) {
      if (doThrow) throw new Error();
      return base ^ ~mask;
    }
  
    /**
     * Check that transformation is done when the argument is a constant.
     */
  
    /// CHECK-START-ARM64: int Main.$opt$noinline$notAndConstant(int) instruction_simplifier_arm64 (before)
    /// CHECK:       <<Base:i\d+>>        ParameterValue
    /// CHECK:       <<Constant:i\d+>>    IntConstant
    /// CHECK:       <<Not:i\d+>>         Not [<<Base>>]
    /// CHECK:       <<Op:i\d+>>          And [<<Not>>,<<Constant>>]
    /// CHECK:                            Return [<<Op>>]
  
    /// CHECK-START-ARM64: int Main.$opt$noinline$notAndConstant(int) instruction_simplifier_arm64 (after)
    /// CHECK:       <<Base:i\d+>>        ParameterValue
    /// CHECK:       <<Constant:i\d+>>    IntConstant
    /// CHECK:       <<NegOp:i\d+>>       BitwiseNegatedRight [<<Constant>>,<<Base>>] kind:And
    /// CHECK:                            Return [<<NegOp>>]
  
  
    /// CHECK-START-ARM:   int Main.$opt$noinline$notAndConstant(int) instruction_simplifier_arm (before)
    /// CHECK:       <<Base:i\d+>>        ParameterValue
    /// CHECK:       <<Constant:i\d+>>    IntConstant
    /// CHECK:       <<Not:i\d+>>         Not [<<Base>>]
    /// CHECK:       <<Op:i\d+>>          And [<<Not>>,<<Constant>>]
    /// CHECK:                            Return [<<Op>>]
  
    /// CHECK-START-ARM:   int Main.$opt$noinline$notAndConstant(int) instruction_simplifier_arm (after)
    /// CHECK:       <<Base:i\d+>>        ParameterValue
    /// CHECK:       <<Constant:i\d+>>    IntConstant
    /// CHECK:       <<NegOp:i\d+>>       BitwiseNegatedRight [<<Constant>>,<<Base>>] kind:And
    /// CHECK:                            Return [<<NegOp>>]
  
    public static int $opt$noinline$notAndConstant(int mask) {
      if (doThrow) throw new Error();
      return 0xf & ~mask;
    }
  
    /**
     * Check that no transformation is done when Not has multiple uses.
     */
  
    /// CHECK-START-ARM64: int Main.$opt$noinline$notAndMultipleUses(int, int) instruction_simplifier_arm64 (before)
    /// CHECK:       <<Base:i\d+>>        ParameterValue
    /// CHECK:       <<Mask:i\d+>>        ParameterValue
    /// CHECK:       <<One:i\d+>>         IntConstant
    /// CHECK:       <<Not:i\d+>>         Not [<<Mask>>]
    /// CHECK:       <<Op1:i\d+>>         And [<<Not>>,<<One>>]
    /// CHECK:       <<Op2:i\d+>>         And [<<Base>>,<<Not>>]
    /// CHECK:       <<Add:i\d+>>         Add [<<Op1>>,<<Op2>>]
    /// CHECK:                            Return [<<Add>>]
  
    /// CHECK-START-ARM64: int Main.$opt$noinline$notAndMultipleUses(int, int) instruction_simplifier_arm64 (after)
    /// CHECK:       <<Base:i\d+>>        ParameterValue
    /// CHECK:       <<Mask:i\d+>>        ParameterValue
    /// CHECK:       <<One:i\d+>>         IntConstant
    /// CHECK:       <<Not:i\d+>>         Not [<<Mask>>]
    /// CHECK:       <<Op1:i\d+>>         And [<<Not>>,<<One>>]
    /// CHECK:       <<Op2:i\d+>>         And [<<Base>>,<<Not>>]
    /// CHECK:       <<Add:i\d+>>         Add [<<Op1>>,<<Op2>>]
    /// CHECK:                            Return [<<Add>>]
  
    /// CHECK-START-ARM64: int Main.$opt$noinline$notAndMultipleUses(int, int) instruction_simplifier_arm64 (after)
    /// CHECK-NOT:                        BitwiseNegatedRight
  
  
    /// CHECK-START-ARM:   int Main.$opt$noinline$notAndMultipleUses(int, int) instruction_simplifier_arm (before)
    /// CHECK:       <<Base:i\d+>>        ParameterValue
    /// CHECK:       <<Mask:i\d+>>        ParameterValue
    /// CHECK:       <<One:i\d+>>         IntConstant
    /// CHECK:       <<Not:i\d+>>         Not [<<Mask>>]
    /// CHECK:       <<Op1:i\d+>>         And [<<Not>>,<<One>>]
    /// CHECK:       <<Op2:i\d+>>         And [<<Base>>,<<Not>>]
    /// CHECK:       <<Add:i\d+>>         Add [<<Op1>>,<<Op2>>]
    /// CHECK:                            Return [<<Add>>]
  
    /// CHECK-START-ARM:   int Main.$opt$noinline$notAndMultipleUses(int, int) instruction_simplifier_arm (after)
    /// CHECK:       <<Base:i\d+>>        ParameterValue
    /// CHECK:       <<Mask:i\d+>>        ParameterValue
    /// CHECK:       <<One:i\d+>>         IntConstant
    /// CHECK:       <<Not:i\d+>>         Not [<<Mask>>]
    /// CHECK:       <<Op1:i\d+>>         And [<<Not>>,<<One>>]
    /// CHECK:       <<Op2:i\d+>>         And [<<Base>>,<<Not>>]
    /// CHECK:       <<Add:i\d+>>         Add [<<Op1>>,<<Op2>>]
    /// CHECK:                            Return [<<Add>>]
  
    /// CHECK-START-ARM:   int Main.$opt$noinline$notAndMultipleUses(int, int) instruction_simplifier_arm (after)
    /// CHECK-NOT:                        BitwiseNegatedRight
  
    public static int $opt$noinline$notAndMultipleUses(int base, int mask) {
      if (doThrow) throw new Error();
      int tmp = ~mask;
      return (tmp & 0x1) + (base & tmp);
    }
  
    /**
     * Check that no transformation is done when both inputs are Not's.
     */
  
    // We don't check the instructions before the pass, since if De Morgan's laws
    // have been applied then Not/Not/Or is replaced by And/Not.
  
    /// CHECK-START-ARM64: int Main.$opt$noinline$deMorganOr(int, int) instruction_simplifier_arm64 (after)
    /// CHECK-NOT:                        BitwiseNegatedRight
  
    /// CHECK-START-ARM:   int Main.$opt$noinline$deMorganOr(int, int) instruction_simplifier_arm (after)
    /// CHECK-NOT:                        BitwiseNegatedRight
  
    public static int $opt$noinline$deMorganOr(int a, int b) {
      if (doThrow) throw new Error();
      return ~a | ~b;
    }
  
    public static void main(String[] args) {
      assertIntEquals(0xe,   $opt$noinline$notAnd(0xf, 0x1));
      assertLongEquals(~0x0, $opt$noinline$notOr(0xf, 0x1));
      assertIntEquals(~0xe,  $opt$noinline$notXor(0xf, 0x1));
      assertIntEquals(0xe,  $opt$noinline$notAndConstant(0x1));
      assertIntEquals(0xe,   $opt$noinline$notAndMultipleUses(0xf, 0x1));
      assertIntEquals(~0x1,  $opt$noinline$deMorganOr(0x3, 0x1));
    }
  }
  