xref: /aosp_15_r20/art/test/510-checker-try-catch/src/Main.java (revision 795d594fd825385562da6b089ea9b2033f3abf5a)

/*
 * 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.
 */

import java.lang.reflect.Method;

public class Main {
  public enum TestPath {
    ExceptionalFlow1(true, false, 3),
    ExceptionalFlow2(false, true, 8),
    NormalFlow(false, false, 42);

    TestPath(boolean arg1, boolean arg2, int expected) {
      this.arg1 = arg1;
      this.arg2 = arg2;
      this.expected = expected;
    }

    public boolean arg1;
    public boolean arg2;
    public int expected;
  }

  // Test that IntermediateAddress instruction is not alive across BoundsCheck which can throw to
  // a catch block.
  //
  /// CHECK-START-{ARM,ARM64}: void Main.boundsCheckAndCatch(int, int[], int[]) GVN$after_arch (before)
  /// CHECK-DAG: <<Const0:i\d+>>       IntConstant 0
  /// CHECK-DAG: <<Const1:i\d+>>       IntConstant 1
  /// CHECK-DAG: <<Const2:i\d+>>       IntConstant 2
  /// CHECK-DAG: <<Offset:i\d+>>       IntConstant 12
  /// CHECK-DAG: <<IndexParam:i\d+>>   ParameterValue
  /// CHECK-DAG: <<ArrayA:l\d+>>       ParameterValue
  /// CHECK-DAG: <<ArrayB:l\d+>>       ParameterValue
  //
  /// CHECK-DAG: <<NullCh1:l\d+>>      NullCheck [<<ArrayA>>]
  /// CHECK-DAG: <<LengthA:i\d+>>      ArrayLength
  /// CHECK-DAG: <<BoundsCh1:i\d+>>    BoundsCheck [<<IndexParam>>,<<LengthA>>]
  /// CHECK-DAG:                       TryBoundary
  //
  /// CHECK-DAG: <<IntAddr1:i\d+>>     IntermediateAddress [<<NullCh1>>,<<Offset>>]
  /// CHECK-DAG:                       ArraySet [<<IntAddr1>>,<<BoundsCh1>>,<<Const2>>]
  /// CHECK-DAG: <<NullChB:l\d+>>      NullCheck [<<ArrayB>>]
  /// CHECK-DAG: <<LengthB:i\d+>>      ArrayLength
  /// CHECK-DAG: <<BoundsChB:i\d+>>    BoundsCheck [<<Const0>>,<<LengthB>>]
  /// CHECK-DAG: <<GetB:i\d+>>         ArrayGet [<<NullChB>>,<<BoundsChB>>]
  /// CHECK-DAG: <<ZeroCheck:i\d+>>    DivZeroCheck [<<IndexParam>>]
  /// CHECK-DAG: <<Div:i\d+>>          Div [<<GetB>>,<<ZeroCheck>>]
  /// CHECK-DAG: <<Xplus1:i\d+>>       Add [<<IndexParam>>,<<Const1>>]
  /// CHECK-DAG: <<BoundsCh2:i\d+>>    BoundsCheck [<<Xplus1>>,<<LengthA>>]
  /// CHECK-DAG: <<IntAddr2:i\d+>>     IntermediateAddress [<<NullCh1>>,<<Offset>>]
  /// CHECK-DAG:                       ArraySet [<<IntAddr2>>,<<BoundsCh2>>,<<Div>>]
  /// CHECK-DAG:                       TryBoundary
  //
  /// CHECK-DAG:                       ClearException
  /// CHECK-DAG: <<IntAddr3:i\d+>>     IntermediateAddress [<<NullCh1>>,<<Offset>>]
  /// CHECK-DAG:                       ArraySet [<<IntAddr3>>,<<BoundsCh1>>,<<Const1>>]
  //
  /// CHECK-NOT:                       NullCheck
  /// CHECK-NOT:                       IntermediateAddress

  /// CHECK-START-{ARM,ARM64}: void Main.boundsCheckAndCatch(int, int[], int[]) GVN$after_arch (after)
  /// CHECK-DAG: <<Const0:i\d+>>       IntConstant 0
  /// CHECK-DAG: <<Const1:i\d+>>       IntConstant 1
  /// CHECK-DAG: <<Const2:i\d+>>       IntConstant 2
  /// CHECK-DAG: <<Offset:i\d+>>       IntConstant 12
  /// CHECK-DAG: <<IndexParam:i\d+>>   ParameterValue
  /// CHECK-DAG: <<ArrayA:l\d+>>       ParameterValue
  /// CHECK-DAG: <<ArrayB:l\d+>>       ParameterValue
  //
  /// CHECK-DAG: <<NullCh1:l\d+>>      NullCheck [<<ArrayA>>]
  /// CHECK-DAG: <<LengthA:i\d+>>      ArrayLength
  /// CHECK-DAG: <<BoundsCh1:i\d+>>    BoundsCheck [<<IndexParam>>,<<LengthA>>]
  /// CHECK-DAG:                       TryBoundary
  //
  /// CHECK-DAG: <<IntAddr1:i\d+>>     IntermediateAddress [<<NullCh1>>,<<Offset>>]
  /// CHECK-DAG:                       ArraySet [<<IntAddr1>>,<<BoundsCh1>>,<<Const2>>]
  /// CHECK-DAG: <<NullChB:l\d+>>      NullCheck [<<ArrayB>>]
  /// CHECK-DAG: <<LengthB:i\d+>>      ArrayLength
  /// CHECK-DAG: <<BoundsChB:i\d+>>    BoundsCheck [<<Const0>>,<<LengthB>>]
  /// CHECK-DAG: <<GetB:i\d+>>         ArrayGet [<<NullChB>>,<<BoundsChB>>]
  /// CHECK-DAG: <<ZeroCheck:i\d+>>    DivZeroCheck [<<IndexParam>>]
  /// CHECK-DAG: <<Div:i\d+>>          Div [<<GetB>>,<<ZeroCheck>>]
  /// CHECK-DAG: <<Xplus1:i\d+>>       Add [<<IndexParam>>,<<Const1>>]
  /// CHECK-DAG: <<BoundsCh2:i\d+>>    BoundsCheck [<<Xplus1>>,<<LengthA>>]
  /// CHECK-DAG:                       ArraySet [<<IntAddr1>>,<<BoundsCh2>>,<<Div>>]
  /// CHECK-DAG:                       TryBoundary
  //
  /// CHECK-DAG:                       ClearException
  /// CHECK-DAG: <<IntAddr3:i\d+>>     IntermediateAddress [<<NullCh1>>,<<Offset>>]
  /// CHECK-DAG:                       ArraySet [<<IntAddr3>>,<<BoundsCh1>>,<<Const1>>]
  //
  /// CHECK-NOT:                       NullCheck
  /// CHECK-NOT:                       IntermediateAddress

  //  Make sure that BoundsCheck, DivZeroCheck and NullCheck don't stop IntermediateAddress sharing.
  public static void boundsCheckAndCatch(int x, int[] a, int[] b) {
    // This a[x] = 1 will be eliminated by LSE, but its related instructions (e.g. NullCheck and
    // BoundsCheck) will remain.
    a[x] = 1;
    try {
      a[x] = 2;
      a[x + 1] = b[0] / x;
    } catch (Exception e) {
      a[x] = 1;
    }
  }

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

  public final static int ARRAY_SIZE = 128;

  public static void testBoundsCheckAndCatch() {
    int[] a = new int[ARRAY_SIZE];
    int[] b = new int[ARRAY_SIZE];

    int index = ARRAY_SIZE - 2;
    boundsCheckAndCatch(index, a, b);
    expectEquals(2, a[index]);

    index = ARRAY_SIZE - 1;
    boundsCheckAndCatch(index, a, b);
    expectEquals(1, a[index]);
  }

  public static void testMethod(String method) throws Exception {
    Class<?> c = Class.forName("Runtime");
    Method m = c.getMethod(method, boolean.class, boolean.class);

    for (TestPath path : TestPath.values()) {
      Object[] arguments = new Object[] { path.arg1, path.arg2 };
      int actual = (Integer) m.invoke(null, arguments);

      if (actual != path.expected) {
        throw new Error("Method: \"" + method + "\", path: " + path + ", " +
                        "expected: " + path.expected + ", actual: " + actual);
      }
    }
  }

  public static void testIntAddressCatch()  throws Exception {
    int[] a = new int[3];

    Class<?> c = Class.forName("Runtime");
    Method m = c.getMethod("testIntAddressCatch", int.class,  Class.forName("[I"));
    m.invoke(null, 0, a);
  }

  public static void main(String[] args) throws Exception {
    testMethod("testUseAfterCatch_int");
    testMethod("testUseAfterCatch_long");
    testMethod("testUseAfterCatch_float");
    testMethod("testUseAfterCatch_double");
    testMethod("testCatchPhi_const");
    testMethod("testCatchPhi_int");
    testMethod("testCatchPhi_long");
    testMethod("testCatchPhi_float");
    testMethod("testCatchPhi_double");
    testMethod("testCatchPhi_singleSlot");
    testMethod("testCatchPhi_doubleSlot");

    testBoundsCheckAndCatch();
    testIntAddressCatch();
  }
}