Quelle  Main.java

/*
 * Copyright (C) 2018 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 for detecting throwing methods for code sinking.
 */
public class Main {

  //
  // Some "runtime library" methods.
  //

  static private void doThrow(String par) {
    throw new Error("you are null: " + par);
  }

  static private void checkNotNullDirect(Object obj, String par) {
    if (obj == null)
      throw new Error("you are null: " + par);
  }

  static private void checkNotNullSplit(Object obj, String par) {
    if (obj == null)
      doThrow(par);
  }

  static private void checkNotNullSplitAlt(Object obj, String par) {
    if (obj != null)
      return;
    doThrow(par);
  }

  //
  // Various ways of enforcing non-null parameter.
  // In all cases, par should be subject to code sinking.
  //

  /// CHECK-START: void Main.doit1(int[]) code_sinking (before)
  /// CHECK: begin_block
  /// CHECK:   <<Str:l\d+>> LoadString
  /// CHECK:   <<Tst:z\d+>> Equal
  /// CHECK:                If [<<Tst>>]
  /// CHECK: end_block
  /// CHECK: begin_block
  /// CHECK:                InvokeStaticOrDirect [{{l\d+}},<<Str>>] method_name:java.lang.StringBuilder.append
  /// CHECK:                Throw
  /// CHECK: end_block
  //
  /// CHECK-START: void Main.doit1(int[]) code_sinking (after)
  /// CHECK: begin_block
  /// CHECK:   <<Tst:z\d+>> Equal
  /// CHECK:                If [<<Tst>>]
  /// CHECK: end_block
  /// CHECK: begin_block
  /// CHECK:   <<Str:l\d+>> LoadString
  /// CHECK:                InvokeStaticOrDirect [{{l\d+}},<<Str>>] method_name:java.lang.StringBuilder.append
  /// CHECK:                Throw
  /// CHECK: end_block
  static public void doit1(int[] a) {
    // Being in the boot image means we know the load string cannot throw. Create one that is
    // unlikely to be there to ensure we handle that case.
    String par = "stringUnlikelyToBeInBootImage";
    if (a == null)
      throw new Error("you are null: " + par);
    for (int i = 0; i < a.length; i++) {
      a[i] = 1;
    }
  }

  /// CHECK-START: void Main.doit2(int[]) code_sinking (before)
  /// CHECK: begin_block
  /// CHECK:   <<Str:l\d+>> LoadString
  /// CHECK:   <<Tst:z\d+>> NotEqual
  /// CHECK:                If [<<Tst>>]
  /// CHECK: end_block
  /// CHECK: begin_block
  /// CHECK:                InvokeStaticOrDirect [<<Str>>] method_name:Main.doThrow
  /// CHECK: end_block
  //
  /// CHECK-START: void Main.doit2(int[]) code_sinking (after)
  /// CHECK: begin_block
  /// CHECK:   <<Tst:z\d+>> NotEqual
  /// CHECK:                If [<<Tst>>]
  /// CHECK: end_block
  /// CHECK: begin_block
  /// CHECK:   <<Str:l\d+>> LoadString
  /// CHECK:                InvokeStaticOrDirect [<<Str>>] method_name:Main.doThrow
  /// CHECK: end_block
  static public void doit2(int[] a) {
    // Being in the boot image means we know the load string cannot throw. Create one that is
    // unlikely to be there to ensure we handle that case.
    String par = "stringUnlikelyToBeInBootImage";
    if (a == null)
      doThrow(par);
    for (int i = 0; i < a.length; i++) {
      a[i] = 2;
    }
  }

  /// CHECK-START: void Main.doit3(int[]) code_sinking (before)
  /// CHECK: begin_block
  /// CHECK:   <<Str:l\d+>> LoadString
  /// CHECK:   <<Tst:z\d+>> Equal
  /// CHECK:                If [<<Tst>>]
  /// CHECK: end_block
  /// CHECK: begin_block
  /// CHECK:                InvokeStaticOrDirect [{{l\d+}},<<Str>>] method_name:java.lang.StringBuilder.append
  /// CHECK:                Throw
  /// CHECK: end_block
  //
  /// CHECK-START: void Main.doit3(int[]) code_sinking (after)
  /// CHECK: begin_block
  /// CHECK:   <<Tst:z\d+>> Equal
  /// CHECK:                If [<<Tst>>]
  /// CHECK: end_block
  /// CHECK: begin_block
  /// CHECK:   <<Str:l\d+>> LoadString
  /// CHECK:                InvokeStaticOrDirect [{{l\d+}},<<Str>>] method_name:java.lang.StringBuilder.append
  /// CHECK:                Throw
  /// CHECK: end_block
  static public void doit3(int[] a) {
    // Being in the boot image means we know the load string cannot throw. Create one that is
    // unlikely to be there to ensure we handle that case.
    String par = "stringUnlikelyToBeInBootImage";
    checkNotNullDirect(a, par);
    for (int i = 0; i < a.length; i++) {
      a[i] = 3;
    }
  }

  /// CHECK-START: void Main.doit4(int[]) code_sinking (before)
  /// CHECK: begin_block
  /// CHECK:   <<Str:l\d+>> LoadString
  /// CHECK:   <<Tst:z\d+>> NotEqual
  /// CHECK:                If [<<Tst>>]
  /// CHECK: end_block
  /// CHECK: begin_block
  /// CHECK:                InvokeStaticOrDirect [<<Str>>] method_name:Main.doThrow
  /// CHECK: end_block
  //
  /// CHECK-START: void Main.doit4(int[]) code_sinking (after)
  /// CHECK: begin_block
  /// CHECK:   <<Tst:z\d+>> NotEqual
  /// CHECK:                If [<<Tst>>]
  /// CHECK: end_block
  /// CHECK: begin_block
  /// CHECK:   <<Str:l\d+>> LoadString
  /// CHECK:                InvokeStaticOrDirect [<<Str>>] method_name:Main.doThrow
  /// CHECK: end_block
  static public void doit4(int[] a) {
    // Being in the boot image means we know the load string cannot throw. Create one that is
    // unlikely to be there to ensure we handle that case.
    String par = "stringUnlikelyToBeInBootImage";
    checkNotNullSplit(a, par);  // resembles Kotlin runtime lib
                                // (test is lined, doThrow is not)
    for (int i = 0; i < a.length; i++) {
      a[i] = 4;
    }
  }

  // Ensures Phi values are merged properly.
  static public int doit5(int[] a) {
    int t = 100;
    // Being in the boot image means we know the load string cannot throw. Create one that is
    // unlikely to be there to ensure we handle that case.
    String par = "stringUnlikelyToBeInBootImage";
    if (a == null) {
      doThrow(par);
    } else {
      t = 1000;
    }
    for (int i = 0; i < a.length; i++) {
      a[i] = 5;
    }
    // Phi on t, even though doThrow never reaches.
    return t;
  }

  //
  // Various ways of exploiting non-null parameter.
  // In all cases, implicit null checks are redundant.
  //

  /// CHECK-START: int Main.deleteNullCheck(int[]) dead_code_elimination$after_inlining (before)
  /// CHECK:   <<Par:l\d+>>   ParameterValue
  /// CHECK:   <<Zero:i\d+>>  IntConstant 0
  /// CHECK:   <<Null:l\d+>>  NullCheck [<<Par>>]
  /// CHECK:   <<Len:i\d+>>   ArrayLength [<<Null>>]
  /// CHECK:   <<Check:i\d+>> BoundsCheck [<<Zero>>,<<Len>>]
  /// CHECK:   <<Get:i\d+>>   ArrayGet [<<Null>>,<<Check>>]
  /// CHECK:                  Return [<<Get>>]
  //
  /// CHECK-START: int Main.deleteNullCheck(int[]) dead_code_elimination$after_inlining (after)
  /// CHECK:   <<Par:l\d+>>   ParameterValue
  /// CHECK:   <<Zero:i\d+>>  IntConstant 0
  /// CHECK:   <<BT:l\d+>>    BoundType [<<Par>>]
  /// CHECK:   <<Len:i\d+>>   ArrayLength [<<BT>>]
  /// CHECK:   <<Check:i\d+>> BoundsCheck [<<Zero>>,<<Len>>]
  /// CHECK:   <<Get:i\d+>>   ArrayGet [<<BT>>,<<Check>>]
  /// CHECK:                  Return [<<Get>>]
  //
  /// CHECK-START: int Main.deleteNullCheck(int[]) dead_code_elimination$after_inlining (after)
  /// CHECK-NOT:              NullCheck
  static public int deleteNullCheck(int[] a) {
    checkNotNullSplit(a, "stringUnlikelyToBeInBootImage");
    return a[0];
  }

  /// CHECK-START: int Main.deleteNullCheckAlt(int[]) dead_code_elimination$after_inlining (before)
  /// CHECK:     NullCheck
  //
  /// CHECK-START: int Main.deleteNullCheckAlt(int[]) dead_code_elimination$after_inlining (after)
  /// CHECK-NOT: NullCheck
  static public int deleteNullCheckAlt(int[] a) {
    checkNotNullSplitAlt(a, "stringUnlikelyToBeInBootImage");
    return a[0];
  }

  /// CHECK-START: int Main.deleteNullChecks3(int[], int[], int[]) dead_code_elimination$after_inlining (before)
  /// CHECK:     NullCheck
  /// CHECK:     NullCheck
  /// CHECK:     NullCheck
  //
  /// CHECK-START: int Main.deleteNullChecks3(int[], int[], int[]) dead_code_elimination$after_inlining (after)
  /// CHECK-NOT: NullCheck
  static public int deleteNullChecks3(int[] a, int[] b, int[] c) {
    checkNotNullSplit(a, "stringUnlikelytoBeInBootImage1");
    checkNotNullSplit(b, "stringUnlikelytoBeInBootImage2");
    checkNotNullSplit(c, "stringUnlikelytoBeInBootImage3");
    return a[0] + b[0] + c[0];
  }

  //
  // Test driver.
  //

  static public void main(String[] args) {
    int[] a = new int[100];
    for (int i = 0; i < 100; i++) {
      a[i] = 0;
    }

    try {
      doit1(null);
      System.out.println("should not reach this!");
    } catch (Error e) {
      doit1(a);
    }
    for (int i = 0; i < 100; i++) {
      expectEquals(1, a[i]);
    }

    try {
      doit2(null);
      System.out.println("should not reach this!");
    } catch (Error e) {
      doit2(a);
    }
    for (int i = 0; i < 100; i++) {
      expectEquals(2, a[i]);
    }

    try {
      doit3(null);
      System.out.println("should not reach this!");
    } catch (Error e) {
      doit3(a);
    }
    for (int i = 0; i < 100; i++) {
      expectEquals(3, a[i]);
    }

    try {
      doit4(null);
      System.out.println("should not reach this!");
    } catch (Error e) {
      doit4(a);
    }
    for (int i = 0; i < 100; i++) {
      expectEquals(4, a[i]);
    }

    try {
      doit5(null);
      System.out.println("should not reach this!");
    } catch (Error e) {
      expectEquals(1000, doit5(a));
    }
    for (int i = 0; i < 100; i++) {
      expectEquals(5, a[i]);
    }

    int[] x = { 11 } ;
    expectEquals(11, deleteNullCheck(x));
    int[] y = { 55 } ;
    int[] z = { 22 } ;
    expectEquals(88, deleteNullChecks3(x, y, z));

    try {
      deleteNullCheck(null);
      System.out.println("should not reach this!");
    } catch (Error e) {
    }

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

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