Merge "test: Fix 4 checker tests to pass with javac/dx"
diff --git a/test/442-checker-constant-folding/build b/test/442-checker-constant-folding/build
new file mode 100755
index 0000000..49292c9
--- /dev/null
+++ b/test/442-checker-constant-folding/build
@@ -0,0 +1,23 @@
+#!/bin/bash
+#
+# Copyright 2017 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.
+
+# This checker test is incompatible with jack bytecode output,
+# so force it to use javac/dx.
+export USE_JACK=false
+# Also disable desugar because it is missing in jack platform builds.
+export DESUGAR=false
+
+./default-build "$@"
diff --git a/test/442-checker-constant-folding/src/Main.java b/test/442-checker-constant-folding/src/Main.java
index 64180d5..eba5137 100644
--- a/test/442-checker-constant-folding/src/Main.java
+++ b/test/442-checker-constant-folding/src/Main.java
@@ -27,12 +27,6 @@
}
}
- public static void assertTrue(boolean condition) {
- if (!condition) {
- throw new Error();
- }
- }
-
public static void assertIntEquals(int expected, int result) {
if (expected != result) {
throw new Error("Expected: " + expected + ", found: " + result);
@@ -57,21 +51,6 @@
}
}
- private static int $inline$int(int x) {
- return x;
- }
-
- private static long $inline$long(long x) {
- return x;
- }
-
- private static float $inline$float(float x) {
- return x;
- }
-
- private static double $inline$double(double x) {
- return x;
- }
// Wrappers around methods located in file TestCmp.smali.
@@ -215,119 +194,121 @@
return y;
}
+
/**
* Exercise constant folding on addition.
*/
- /// CHECK-START: int Main.IntAddition1() constant_folding$after_inlining (before)
+ /// CHECK-START: int Main.IntAddition1() constant_folding (before)
/// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: <<Add:i\d+>> Add [<<Const1>>,<<Const2>>]
/// CHECK-DAG: Return [<<Add>>]
- /// CHECK-START: int Main.IntAddition1() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.IntAddition1() constant_folding (after)
/// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
/// CHECK-DAG: Return [<<Const3>>]
- /// CHECK-START: int Main.IntAddition1() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.IntAddition1() constant_folding (after)
/// CHECK-NOT: Add
public static int IntAddition1() {
int a, b, c;
- a = $inline$int(1);
- b = $inline$int(2);
+ a = 1;
+ b = 2;
c = a + b;
return c;
}
- /// CHECK-START: int Main.IntAddition2() constant_folding$after_inlining (before)
+ /// CHECK-START: int Main.IntAddition2() constant_folding (before)
/// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: <<Const5:i\d+>> IntConstant 5
/// CHECK-DAG: <<Const6:i\d+>> IntConstant 6
+ /// CHECK-DAG: <<Const11:i\d+>> IntConstant 11
/// CHECK-DAG: <<Add1:i\d+>> Add [<<Const1>>,<<Const2>>]
- /// CHECK-DAG: <<Add2:i\d+>> Add [<<Const5>>,<<Const6>>]
- /// CHECK-DAG: <<Add3:i\d+>> Add [<<Add1>>,<<Add2>>]
+ /// CHECK-DAG: Add [<<Const5>>,<<Const6>>]
+ /// CHECK-DAG: <<Add3:i\d+>> Add [<<Add1>>,<<Const11>>]
/// CHECK-DAG: Return [<<Add3>>]
- /// CHECK-START: int Main.IntAddition2() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.IntAddition2() constant_folding (after)
/// CHECK-DAG: <<Const14:i\d+>> IntConstant 14
/// CHECK-DAG: Return [<<Const14>>]
- /// CHECK-START: int Main.IntAddition2() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.IntAddition2() constant_folding (after)
/// CHECK-NOT: Add
public static int IntAddition2() {
int a, b, c;
- a = $inline$int(1);
- b = $inline$int(2);
+ a = 1;
+ b = 2;
a += b;
- b = $inline$int(5);
- c = $inline$int(6);
+ b = 5;
+ c = 6;
b += c;
c = a + b;
return c;
}
- /// CHECK-START: long Main.LongAddition() constant_folding$after_inlining (before)
+ /// CHECK-START: long Main.LongAddition() constant_folding (before)
/// CHECK-DAG: <<Const1:j\d+>> LongConstant 1
/// CHECK-DAG: <<Const2:j\d+>> LongConstant 2
/// CHECK-DAG: <<Add:j\d+>> Add [<<Const1>>,<<Const2>>]
/// CHECK-DAG: Return [<<Add>>]
- /// CHECK-START: long Main.LongAddition() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.LongAddition() constant_folding (after)
/// CHECK-DAG: <<Const3:j\d+>> LongConstant 3
/// CHECK-DAG: Return [<<Const3>>]
- /// CHECK-START: long Main.LongAddition() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.LongAddition() constant_folding (after)
/// CHECK-NOT: Add
public static long LongAddition() {
long a, b, c;
- a = $inline$long(1L);
- b = $inline$long(2L);
+ a = 1L;
+ b = 2L;
c = a + b;
return c;
}
- /// CHECK-START: float Main.FloatAddition() constant_folding$after_inlining (before)
+ /// CHECK-START: float Main.FloatAddition() constant_folding (before)
/// CHECK-DAG: <<Const1:f\d+>> FloatConstant 1
/// CHECK-DAG: <<Const2:f\d+>> FloatConstant 2
/// CHECK-DAG: <<Add:f\d+>> Add [<<Const1>>,<<Const2>>]
/// CHECK-DAG: Return [<<Add>>]
- /// CHECK-START: float Main.FloatAddition() constant_folding$after_inlining (after)
+ /// CHECK-START: float Main.FloatAddition() constant_folding (after)
/// CHECK-DAG: <<Const3:f\d+>> FloatConstant 3
/// CHECK-DAG: Return [<<Const3>>]
- /// CHECK-START: float Main.FloatAddition() constant_folding$after_inlining (after)
+ /// CHECK-START: float Main.FloatAddition() constant_folding (after)
/// CHECK-NOT: Add
public static float FloatAddition() {
float a, b, c;
- a = $inline$float(1F);
- b = $inline$float(2F);
+ a = 1F;
+ b = 2F;
c = a + b;
return c;
}
- /// CHECK-START: double Main.DoubleAddition() constant_folding$after_inlining (before)
+ /// CHECK-START: double Main.DoubleAddition() constant_folding (before)
/// CHECK-DAG: <<Const1:d\d+>> DoubleConstant 1
/// CHECK-DAG: <<Const2:d\d+>> DoubleConstant 2
/// CHECK-DAG: <<Add:d\d+>> Add [<<Const1>>,<<Const2>>]
/// CHECK-DAG: Return [<<Add>>]
- /// CHECK-START: double Main.DoubleAddition() constant_folding$after_inlining (after)
+ /// CHECK-START: double Main.DoubleAddition() constant_folding (after)
/// CHECK-DAG: <<Const3:d\d+>> DoubleConstant 3
/// CHECK-DAG: Return [<<Const3>>]
- /// CHECK-START: double Main.DoubleAddition() constant_folding$after_inlining (after)
+ /// CHECK-START: double Main.DoubleAddition() constant_folding (after)
/// CHECK-NOT: Add
public static double DoubleAddition() {
double a, b, c;
- a = $inline$double(1D);
- b = $inline$double(2D);
+ a = 1D;
+ b = 2D;
c = a + b;
return c;
}
@@ -337,86 +318,86 @@
* Exercise constant folding on subtraction.
*/
- /// CHECK-START: int Main.IntSubtraction() constant_folding$after_inlining (before)
+ /// CHECK-START: int Main.IntSubtraction() constant_folding (before)
/// CHECK-DAG: <<Const6:i\d+>> IntConstant 6
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const6>>,<<Const2>>]
/// CHECK-DAG: Return [<<Sub>>]
- /// CHECK-START: int Main.IntSubtraction() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.IntSubtraction() constant_folding (after)
/// CHECK-DAG: <<Const4:i\d+>> IntConstant 4
/// CHECK-DAG: Return [<<Const4>>]
- /// CHECK-START: int Main.IntSubtraction() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.IntSubtraction() constant_folding (after)
/// CHECK-NOT: Sub
public static int IntSubtraction() {
int a, b, c;
- a = $inline$int(6);
- b = $inline$int(2);
+ a = 6;
+ b = 2;
c = a - b;
return c;
}
- /// CHECK-START: long Main.LongSubtraction() constant_folding$after_inlining (before)
+ /// CHECK-START: long Main.LongSubtraction() constant_folding (before)
/// CHECK-DAG: <<Const6:j\d+>> LongConstant 6
/// CHECK-DAG: <<Const2:j\d+>> LongConstant 2
/// CHECK-DAG: <<Sub:j\d+>> Sub [<<Const6>>,<<Const2>>]
/// CHECK-DAG: Return [<<Sub>>]
- /// CHECK-START: long Main.LongSubtraction() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.LongSubtraction() constant_folding (after)
/// CHECK-DAG: <<Const4:j\d+>> LongConstant 4
/// CHECK-DAG: Return [<<Const4>>]
- /// CHECK-START: long Main.LongSubtraction() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.LongSubtraction() constant_folding (after)
/// CHECK-NOT: Sub
public static long LongSubtraction() {
long a, b, c;
- a = $inline$long(6L);
- b = $inline$long(2L);
+ a = 6L;
+ b = 2L;
c = a - b;
return c;
}
- /// CHECK-START: float Main.FloatSubtraction() constant_folding$after_inlining (before)
+ /// CHECK-START: float Main.FloatSubtraction() constant_folding (before)
/// CHECK-DAG: <<Const6:f\d+>> FloatConstant 6
/// CHECK-DAG: <<Const2:f\d+>> FloatConstant 2
/// CHECK-DAG: <<Sub:f\d+>> Sub [<<Const6>>,<<Const2>>]
/// CHECK-DAG: Return [<<Sub>>]
- /// CHECK-START: float Main.FloatSubtraction() constant_folding$after_inlining (after)
+ /// CHECK-START: float Main.FloatSubtraction() constant_folding (after)
/// CHECK-DAG: <<Const4:f\d+>> FloatConstant 4
/// CHECK-DAG: Return [<<Const4>>]
- /// CHECK-START: float Main.FloatSubtraction() constant_folding$after_inlining (after)
+ /// CHECK-START: float Main.FloatSubtraction() constant_folding (after)
/// CHECK-NOT: Sub
public static float FloatSubtraction() {
float a, b, c;
- a = $inline$float(6F);
- b = $inline$float(2F);
+ a = 6F;
+ b = 2F;
c = a - b;
return c;
}
- /// CHECK-START: double Main.DoubleSubtraction() constant_folding$after_inlining (before)
+ /// CHECK-START: double Main.DoubleSubtraction() constant_folding (before)
/// CHECK-DAG: <<Const6:d\d+>> DoubleConstant 6
/// CHECK-DAG: <<Const2:d\d+>> DoubleConstant 2
/// CHECK-DAG: <<Sub:d\d+>> Sub [<<Const6>>,<<Const2>>]
/// CHECK-DAG: Return [<<Sub>>]
- /// CHECK-START: double Main.DoubleSubtraction() constant_folding$after_inlining (after)
+ /// CHECK-START: double Main.DoubleSubtraction() constant_folding (after)
/// CHECK-DAG: <<Const4:d\d+>> DoubleConstant 4
/// CHECK-DAG: Return [<<Const4>>]
- /// CHECK-START: double Main.DoubleSubtraction() constant_folding$after_inlining (after)
+ /// CHECK-START: double Main.DoubleSubtraction() constant_folding (after)
/// CHECK-NOT: Sub
public static double DoubleSubtraction() {
double a, b, c;
- a = $inline$double(6D);
- b = $inline$double(2D);
+ a = 6D;
+ b = 2D;
c = a - b;
return c;
}
@@ -426,86 +407,86 @@
* Exercise constant folding on multiplication.
*/
- /// CHECK-START: int Main.IntMultiplication() constant_folding$after_inlining (before)
+ /// CHECK-START: int Main.IntMultiplication() constant_folding (before)
/// CHECK-DAG: <<Const7:i\d+>> IntConstant 7
/// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
/// CHECK-DAG: <<Mul:i\d+>> Mul [<<Const7>>,<<Const3>>]
/// CHECK-DAG: Return [<<Mul>>]
- /// CHECK-START: int Main.IntMultiplication() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.IntMultiplication() constant_folding (after)
/// CHECK-DAG: <<Const21:i\d+>> IntConstant 21
/// CHECK-DAG: Return [<<Const21>>]
- /// CHECK-START: int Main.IntMultiplication() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.IntMultiplication() constant_folding (after)
/// CHECK-NOT: Mul
public static int IntMultiplication() {
int a, b, c;
- a = $inline$int(7);
- b = $inline$int(3);
+ a = 7;
+ b = 3;
c = a * b;
return c;
}
- /// CHECK-START: long Main.LongMultiplication() constant_folding$after_inlining (before)
+ /// CHECK-START: long Main.LongMultiplication() constant_folding (before)
/// CHECK-DAG: <<Const7:j\d+>> LongConstant 7
/// CHECK-DAG: <<Const3:j\d+>> LongConstant 3
/// CHECK-DAG: <<Mul:j\d+>> Mul [<<Const7>>,<<Const3>>]
/// CHECK-DAG: Return [<<Mul>>]
- /// CHECK-START: long Main.LongMultiplication() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.LongMultiplication() constant_folding (after)
/// CHECK-DAG: <<Const21:j\d+>> LongConstant 21
/// CHECK-DAG: Return [<<Const21>>]
- /// CHECK-START: long Main.LongMultiplication() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.LongMultiplication() constant_folding (after)
/// CHECK-NOT: Mul
public static long LongMultiplication() {
long a, b, c;
- a = $inline$long(7L);
- b = $inline$long(3L);
+ a = 7L;
+ b = 3L;
c = a * b;
return c;
}
- /// CHECK-START: float Main.FloatMultiplication() constant_folding$after_inlining (before)
+ /// CHECK-START: float Main.FloatMultiplication() constant_folding (before)
/// CHECK-DAG: <<Const7:f\d+>> FloatConstant 7
/// CHECK-DAG: <<Const3:f\d+>> FloatConstant 3
/// CHECK-DAG: <<Mul:f\d+>> Mul [<<Const7>>,<<Const3>>]
/// CHECK-DAG: Return [<<Mul>>]
- /// CHECK-START: float Main.FloatMultiplication() constant_folding$after_inlining (after)
+ /// CHECK-START: float Main.FloatMultiplication() constant_folding (after)
/// CHECK-DAG: <<Const21:f\d+>> FloatConstant 21
/// CHECK-DAG: Return [<<Const21>>]
- /// CHECK-START: float Main.FloatMultiplication() constant_folding$after_inlining (after)
+ /// CHECK-START: float Main.FloatMultiplication() constant_folding (after)
/// CHECK-NOT: Mul
public static float FloatMultiplication() {
float a, b, c;
- a = $inline$float(7F);
- b = $inline$float(3F);
+ a = 7F;
+ b = 3F;
c = a * b;
return c;
}
- /// CHECK-START: double Main.DoubleMultiplication() constant_folding$after_inlining (before)
+ /// CHECK-START: double Main.DoubleMultiplication() constant_folding (before)
/// CHECK-DAG: <<Const7:d\d+>> DoubleConstant 7
/// CHECK-DAG: <<Const3:d\d+>> DoubleConstant 3
/// CHECK-DAG: <<Mul:d\d+>> Mul [<<Const7>>,<<Const3>>]
/// CHECK-DAG: Return [<<Mul>>]
- /// CHECK-START: double Main.DoubleMultiplication() constant_folding$after_inlining (after)
+ /// CHECK-START: double Main.DoubleMultiplication() constant_folding (after)
/// CHECK-DAG: <<Const21:d\d+>> DoubleConstant 21
/// CHECK-DAG: Return [<<Const21>>]
- /// CHECK-START: double Main.DoubleMultiplication() constant_folding$after_inlining (after)
+ /// CHECK-START: double Main.DoubleMultiplication() constant_folding (after)
/// CHECK-NOT: Mul
public static double DoubleMultiplication() {
double a, b, c;
- a = $inline$double(7D);
- b = $inline$double(3D);
+ a = 7D;
+ b = 3D;
c = a * b;
return c;
}
@@ -515,90 +496,90 @@
* Exercise constant folding on division.
*/
- /// CHECK-START: int Main.IntDivision() constant_folding$after_inlining (before)
+ /// CHECK-START: int Main.IntDivision() constant_folding (before)
/// CHECK-DAG: <<Const8:i\d+>> IntConstant 8
/// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
/// CHECK-DAG: <<Div0Chk:i\d+>> DivZeroCheck [<<Const3>>]
/// CHECK-DAG: <<Div:i\d+>> Div [<<Const8>>,<<Div0Chk>>]
/// CHECK-DAG: Return [<<Div>>]
- /// CHECK-START: int Main.IntDivision() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.IntDivision() constant_folding (after)
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: Return [<<Const2>>]
- /// CHECK-START: int Main.IntDivision() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.IntDivision() constant_folding (after)
/// CHECK-NOT: DivZeroCheck
/// CHECK-NOT: Div
public static int IntDivision() {
int a, b, c;
- a = $inline$int(8);
- b = $inline$int(3);
+ a = 8;
+ b = 3;
c = a / b;
return c;
}
- /// CHECK-START: long Main.LongDivision() constant_folding$after_inlining (before)
+ /// CHECK-START: long Main.LongDivision() constant_folding (before)
/// CHECK-DAG: <<Const8:j\d+>> LongConstant 8
/// CHECK-DAG: <<Const3:j\d+>> LongConstant 3
/// CHECK-DAG: <<Div0Chk:j\d+>> DivZeroCheck [<<Const3>>]
/// CHECK-DAG: <<Div:j\d+>> Div [<<Const8>>,<<Div0Chk>>]
/// CHECK-DAG: Return [<<Div>>]
- /// CHECK-START: long Main.LongDivision() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.LongDivision() constant_folding (after)
/// CHECK-DAG: <<Const2:j\d+>> LongConstant 2
/// CHECK-DAG: Return [<<Const2>>]
- /// CHECK-START: long Main.LongDivision() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.LongDivision() constant_folding (after)
/// CHECK-NOT: DivZeroCheck
/// CHECK-NOT: Div
public static long LongDivision() {
long a, b, c;
- a = $inline$long(8L);
- b = $inline$long(3L);
+ a = 8L;
+ b = 3L;
c = a / b;
return c;
}
- /// CHECK-START: float Main.FloatDivision() constant_folding$after_inlining (before)
+ /// CHECK-START: float Main.FloatDivision() constant_folding (before)
/// CHECK-DAG: <<Const8:f\d+>> FloatConstant 8
/// CHECK-DAG: <<Const2P5:f\d+>> FloatConstant 2.5
/// CHECK-DAG: <<Div:f\d+>> Div [<<Const8>>,<<Const2P5>>]
/// CHECK-DAG: Return [<<Div>>]
- /// CHECK-START: float Main.FloatDivision() constant_folding$after_inlining (after)
+ /// CHECK-START: float Main.FloatDivision() constant_folding (after)
/// CHECK-DAG: <<Const3P2:f\d+>> FloatConstant 3.2
/// CHECK-DAG: Return [<<Const3P2>>]
- /// CHECK-START: float Main.FloatDivision() constant_folding$after_inlining (after)
+ /// CHECK-START: float Main.FloatDivision() constant_folding (after)
/// CHECK-NOT: Div
public static float FloatDivision() {
float a, b, c;
- a = $inline$float(8F);
- b = $inline$float(2.5F);
+ a = 8F;
+ b = 2.5F;
c = a / b;
return c;
}
- /// CHECK-START: double Main.DoubleDivision() constant_folding$after_inlining (before)
+ /// CHECK-START: double Main.DoubleDivision() constant_folding (before)
/// CHECK-DAG: <<Const8:d\d+>> DoubleConstant 8
/// CHECK-DAG: <<Const2P5:d\d+>> DoubleConstant 2.5
/// CHECK-DAG: <<Div:d\d+>> Div [<<Const8>>,<<Const2P5>>]
/// CHECK-DAG: Return [<<Div>>]
- /// CHECK-START: double Main.DoubleDivision() constant_folding$after_inlining (after)
+ /// CHECK-START: double Main.DoubleDivision() constant_folding (after)
/// CHECK-DAG: <<Const3P2:d\d+>> DoubleConstant 3.2
/// CHECK-DAG: Return [<<Const3P2>>]
- /// CHECK-START: double Main.DoubleDivision() constant_folding$after_inlining (after)
+ /// CHECK-START: double Main.DoubleDivision() constant_folding (after)
/// CHECK-NOT: Div
public static double DoubleDivision() {
double a, b, c;
- a = $inline$double(8D);
- b = $inline$double(2.5D);
+ a = 8D;
+ b = 2.5D;
c = a / b;
return c;
}
@@ -608,90 +589,90 @@
* Exercise constant folding on remainder.
*/
- /// CHECK-START: int Main.IntRemainder() constant_folding$after_inlining (before)
+ /// CHECK-START: int Main.IntRemainder() constant_folding (before)
/// CHECK-DAG: <<Const8:i\d+>> IntConstant 8
/// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
/// CHECK-DAG: <<Div0Chk:i\d+>> DivZeroCheck [<<Const3>>]
/// CHECK-DAG: <<Rem:i\d+>> Rem [<<Const8>>,<<Div0Chk>>]
/// CHECK-DAG: Return [<<Rem>>]
- /// CHECK-START: int Main.IntRemainder() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.IntRemainder() constant_folding (after)
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: Return [<<Const2>>]
- /// CHECK-START: int Main.IntRemainder() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.IntRemainder() constant_folding (after)
/// CHECK-NOT: DivZeroCheck
/// CHECK-NOT: Rem
public static int IntRemainder() {
int a, b, c;
- a = $inline$int(8);
- b = $inline$int(3);
+ a = 8;
+ b = 3;
c = a % b;
return c;
}
- /// CHECK-START: long Main.LongRemainder() constant_folding$after_inlining (before)
+ /// CHECK-START: long Main.LongRemainder() constant_folding (before)
/// CHECK-DAG: <<Const8:j\d+>> LongConstant 8
/// CHECK-DAG: <<Const3:j\d+>> LongConstant 3
/// CHECK-DAG: <<Div0Chk:j\d+>> DivZeroCheck [<<Const3>>]
/// CHECK-DAG: <<Rem:j\d+>> Rem [<<Const8>>,<<Div0Chk>>]
/// CHECK-DAG: Return [<<Rem>>]
- /// CHECK-START: long Main.LongRemainder() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.LongRemainder() constant_folding (after)
/// CHECK-DAG: <<Const2:j\d+>> LongConstant 2
/// CHECK-DAG: Return [<<Const2>>]
- /// CHECK-START: long Main.LongRemainder() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.LongRemainder() constant_folding (after)
/// CHECK-NOT: DivZeroCheck
/// CHECK-NOT: Rem
public static long LongRemainder() {
long a, b, c;
- a = $inline$long(8L);
- b = $inline$long(3L);
+ a = 8L;
+ b = 3L;
c = a % b;
return c;
}
- /// CHECK-START: float Main.FloatRemainder() constant_folding$after_inlining (before)
+ /// CHECK-START: float Main.FloatRemainder() constant_folding (before)
/// CHECK-DAG: <<Const8:f\d+>> FloatConstant 8
/// CHECK-DAG: <<Const2P5:f\d+>> FloatConstant 2.5
/// CHECK-DAG: <<Rem:f\d+>> Rem [<<Const8>>,<<Const2P5>>]
/// CHECK-DAG: Return [<<Rem>>]
- /// CHECK-START: float Main.FloatRemainder() constant_folding$after_inlining (after)
+ /// CHECK-START: float Main.FloatRemainder() constant_folding (after)
/// CHECK-DAG: <<Const0P5:f\d+>> FloatConstant 0.5
/// CHECK-DAG: Return [<<Const0P5>>]
- /// CHECK-START: float Main.FloatRemainder() constant_folding$after_inlining (after)
+ /// CHECK-START: float Main.FloatRemainder() constant_folding (after)
/// CHECK-NOT: Rem
public static float FloatRemainder() {
float a, b, c;
- a = $inline$float(8F);
- b = $inline$float(2.5F);
+ a = 8F;
+ b = 2.5F;
c = a % b;
return c;
}
- /// CHECK-START: double Main.DoubleRemainder() constant_folding$after_inlining (before)
+ /// CHECK-START: double Main.DoubleRemainder() constant_folding (before)
/// CHECK-DAG: <<Const8:d\d+>> DoubleConstant 8
/// CHECK-DAG: <<Const2P5:d\d+>> DoubleConstant 2.5
/// CHECK-DAG: <<Rem:d\d+>> Rem [<<Const8>>,<<Const2P5>>]
/// CHECK-DAG: Return [<<Rem>>]
- /// CHECK-START: double Main.DoubleRemainder() constant_folding$after_inlining (after)
+ /// CHECK-START: double Main.DoubleRemainder() constant_folding (after)
/// CHECK-DAG: <<Const0P5:d\d+>> DoubleConstant 0.5
/// CHECK-DAG: Return [<<Const0P5>>]
- /// CHECK-START: double Main.DoubleRemainder() constant_folding$after_inlining (after)
+ /// CHECK-START: double Main.DoubleRemainder() constant_folding (after)
/// CHECK-NOT: Rem
public static double DoubleRemainder() {
double a, b, c;
- a = $inline$double(8D);
- b = $inline$double(2.5D);
+ a = 8D;
+ b = 2.5D;
c = a % b;
return c;
}
@@ -701,42 +682,42 @@
* Exercise constant folding on left shift.
*/
- /// CHECK-START: int Main.ShlIntLong() constant_folding$after_inlining (before)
+ /// CHECK-START: int Main.ShlIntLong() constant_folding (before)
/// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
/// CHECK-DAG: <<Const2L:j\d+>> LongConstant 2
/// CHECK-DAG: <<TypeConv:i\d+>> TypeConversion [<<Const2L>>]
/// CHECK-DAG: <<Shl:i\d+>> Shl [<<Const1>>,<<TypeConv>>]
/// CHECK-DAG: Return [<<Shl>>]
- /// CHECK-START: int Main.ShlIntLong() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.ShlIntLong() constant_folding (after)
/// CHECK-DAG: <<Const4:i\d+>> IntConstant 4
/// CHECK-DAG: Return [<<Const4>>]
- /// CHECK-START: int Main.ShlIntLong() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.ShlIntLong() constant_folding (after)
/// CHECK-NOT: Shl
public static int ShlIntLong() {
- int lhs = $inline$int(1);
- long rhs = $inline$long(2L);
+ int lhs = 1;
+ long rhs = 2;
return lhs << rhs;
}
- /// CHECK-START: long Main.ShlLongInt() constant_folding$after_inlining (before)
+ /// CHECK-START: long Main.ShlLongInt() constant_folding (before)
/// CHECK-DAG: <<Const3L:j\d+>> LongConstant 3
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: <<Shl:j\d+>> Shl [<<Const3L>>,<<Const2>>]
/// CHECK-DAG: Return [<<Shl>>]
- /// CHECK-START: long Main.ShlLongInt() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.ShlLongInt() constant_folding (after)
/// CHECK-DAG: <<Const12L:j\d+>> LongConstant 12
/// CHECK-DAG: Return [<<Const12L>>]
- /// CHECK-START: long Main.ShlLongInt() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.ShlLongInt() constant_folding (after)
/// CHECK-NOT: Shl
public static long ShlLongInt() {
- long lhs = $inline$long(3L);
- int rhs = $inline$int(2);
+ long lhs = 3;
+ int rhs = 2;
return lhs << rhs;
}
@@ -745,42 +726,42 @@
* Exercise constant folding on right shift.
*/
- /// CHECK-START: int Main.ShrIntLong() constant_folding$after_inlining (before)
+ /// CHECK-START: int Main.ShrIntLong() constant_folding (before)
/// CHECK-DAG: <<Const7:i\d+>> IntConstant 7
/// CHECK-DAG: <<Const2L:j\d+>> LongConstant 2
/// CHECK-DAG: <<TypeConv:i\d+>> TypeConversion [<<Const2L>>]
/// CHECK-DAG: <<Shr:i\d+>> Shr [<<Const7>>,<<TypeConv>>]
/// CHECK-DAG: Return [<<Shr>>]
- /// CHECK-START: int Main.ShrIntLong() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.ShrIntLong() constant_folding (after)
/// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
/// CHECK-DAG: Return [<<Const1>>]
- /// CHECK-START: int Main.ShrIntLong() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.ShrIntLong() constant_folding (after)
/// CHECK-NOT: Shr
public static int ShrIntLong() {
- int lhs = $inline$int(7);
- long rhs = $inline$long(2L);
+ int lhs = 7;
+ long rhs = 2;
return lhs >> rhs;
}
- /// CHECK-START: long Main.ShrLongInt() constant_folding$after_inlining (before)
+ /// CHECK-START: long Main.ShrLongInt() constant_folding (before)
/// CHECK-DAG: <<Const9L:j\d+>> LongConstant 9
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: <<Shr:j\d+>> Shr [<<Const9L>>,<<Const2>>]
/// CHECK-DAG: Return [<<Shr>>]
- /// CHECK-START: long Main.ShrLongInt() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.ShrLongInt() constant_folding (after)
/// CHECK-DAG: <<Const2L:j\d+>> LongConstant 2
/// CHECK-DAG: Return [<<Const2L>>]
- /// CHECK-START: long Main.ShrLongInt() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.ShrLongInt() constant_folding (after)
/// CHECK-NOT: Shr
public static long ShrLongInt() {
- long lhs = $inline$long(9);
- int rhs = $inline$int(2);
+ long lhs = 9;
+ int rhs = 2;
return lhs >> rhs;
}
@@ -789,42 +770,42 @@
* Exercise constant folding on unsigned right shift.
*/
- /// CHECK-START: int Main.UShrIntLong() constant_folding$after_inlining (before)
+ /// CHECK-START: int Main.UShrIntLong() constant_folding (before)
/// CHECK-DAG: <<ConstM7:i\d+>> IntConstant -7
/// CHECK-DAG: <<Const2L:j\d+>> LongConstant 2
/// CHECK-DAG: <<TypeConv:i\d+>> TypeConversion [<<Const2L>>]
/// CHECK-DAG: <<UShr:i\d+>> UShr [<<ConstM7>>,<<TypeConv>>]
/// CHECK-DAG: Return [<<UShr>>]
- /// CHECK-START: int Main.UShrIntLong() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.UShrIntLong() constant_folding (after)
/// CHECK-DAG: <<ConstRes:i\d+>> IntConstant 1073741822
/// CHECK-DAG: Return [<<ConstRes>>]
- /// CHECK-START: int Main.UShrIntLong() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.UShrIntLong() constant_folding (after)
/// CHECK-NOT: UShr
public static int UShrIntLong() {
- int lhs = $inline$int(-7);
- long rhs = $inline$long(2L);
+ int lhs = -7;
+ long rhs = 2;
return lhs >>> rhs;
}
- /// CHECK-START: long Main.UShrLongInt() constant_folding$after_inlining (before)
+ /// CHECK-START: long Main.UShrLongInt() constant_folding (before)
/// CHECK-DAG: <<ConstM9L:j\d+>> LongConstant -9
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: <<UShr:j\d+>> UShr [<<ConstM9L>>,<<Const2>>]
/// CHECK-DAG: Return [<<UShr>>]
- /// CHECK-START: long Main.UShrLongInt() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.UShrLongInt() constant_folding (after)
/// CHECK-DAG: <<ConstRes:j\d+>> LongConstant 4611686018427387901
/// CHECK-DAG: Return [<<ConstRes>>]
- /// CHECK-START: long Main.UShrLongInt() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.UShrLongInt() constant_folding (after)
/// CHECK-NOT: UShr
public static long UShrLongInt() {
- long lhs = $inline$long(-9);
- int rhs = $inline$int(2);
+ long lhs = -9;
+ int rhs = 2;
return lhs >>> rhs;
}
@@ -833,43 +814,43 @@
* Exercise constant folding on logical and.
*/
- /// CHECK-START: long Main.AndIntLong() constant_folding$after_inlining (before)
+ /// CHECK-START: long Main.AndIntLong() constant_folding (before)
/// CHECK-DAG: <<Const10:i\d+>> IntConstant 10
/// CHECK-DAG: <<Const3L:j\d+>> LongConstant 3
/// CHECK-DAG: <<TypeConv:j\d+>> TypeConversion [<<Const10>>]
/// CHECK-DAG: <<And:j\d+>> And [<<TypeConv>>,<<Const3L>>]
/// CHECK-DAG: Return [<<And>>]
- /// CHECK-START: long Main.AndIntLong() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.AndIntLong() constant_folding (after)
/// CHECK-DAG: <<Const2:j\d+>> LongConstant 2
/// CHECK-DAG: Return [<<Const2>>]
- /// CHECK-START: long Main.AndIntLong() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.AndIntLong() constant_folding (after)
/// CHECK-NOT: And
public static long AndIntLong() {
- int lhs = $inline$int(10);
- long rhs = $inline$long(3L);
+ int lhs = 10;
+ long rhs = 3;
return lhs & rhs;
}
- /// CHECK-START: long Main.AndLongInt() constant_folding$after_inlining (before)
+ /// CHECK-START: long Main.AndLongInt() constant_folding (before)
/// CHECK-DAG: <<Const10L:j\d+>> LongConstant 10
/// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
/// CHECK-DAG: <<TypeConv:j\d+>> TypeConversion [<<Const3>>]
/// CHECK-DAG: <<And:j\d+>> And [<<TypeConv>>,<<Const10L>>]
/// CHECK-DAG: Return [<<And>>]
- /// CHECK-START: long Main.AndLongInt() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.AndLongInt() constant_folding (after)
/// CHECK-DAG: <<Const2:j\d+>> LongConstant 2
/// CHECK-DAG: Return [<<Const2>>]
- /// CHECK-START: long Main.AndLongInt() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.AndLongInt() constant_folding (after)
/// CHECK-NOT: And
public static long AndLongInt() {
- long lhs = $inline$long(10L);
- int rhs = $inline$int(3);
+ long lhs = 10;
+ int rhs = 3;
return lhs & rhs;
}
@@ -878,43 +859,43 @@
* Exercise constant folding on logical or.
*/
- /// CHECK-START: long Main.OrIntLong() constant_folding$after_inlining (before)
+ /// CHECK-START: long Main.OrIntLong() constant_folding (before)
/// CHECK-DAG: <<Const10:i\d+>> IntConstant 10
/// CHECK-DAG: <<Const3L:j\d+>> LongConstant 3
/// CHECK-DAG: <<TypeConv:j\d+>> TypeConversion [<<Const10>>]
/// CHECK-DAG: <<Or:j\d+>> Or [<<TypeConv>>,<<Const3L>>]
/// CHECK-DAG: Return [<<Or>>]
- /// CHECK-START: long Main.OrIntLong() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.OrIntLong() constant_folding (after)
/// CHECK-DAG: <<Const11:j\d+>> LongConstant 11
/// CHECK-DAG: Return [<<Const11>>]
- /// CHECK-START: long Main.OrIntLong() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.OrIntLong() constant_folding (after)
/// CHECK-NOT: Or
public static long OrIntLong() {
- int lhs = $inline$int(10);
- long rhs = $inline$long(3L);
+ int lhs = 10;
+ long rhs = 3;
return lhs | rhs;
}
- /// CHECK-START: long Main.OrLongInt() constant_folding$after_inlining (before)
+ /// CHECK-START: long Main.OrLongInt() constant_folding (before)
/// CHECK-DAG: <<Const10L:j\d+>> LongConstant 10
/// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
/// CHECK-DAG: <<TypeConv:j\d+>> TypeConversion [<<Const3>>]
/// CHECK-DAG: <<Or:j\d+>> Or [<<TypeConv>>,<<Const10L>>]
/// CHECK-DAG: Return [<<Or>>]
- /// CHECK-START: long Main.OrLongInt() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.OrLongInt() constant_folding (after)
/// CHECK-DAG: <<Const11:j\d+>> LongConstant 11
/// CHECK-DAG: Return [<<Const11>>]
- /// CHECK-START: long Main.OrLongInt() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.OrLongInt() constant_folding (after)
/// CHECK-NOT: Or
public static long OrLongInt() {
- long lhs = $inline$long(10L);
- int rhs = $inline$int(3);
+ long lhs = 10;
+ int rhs = 3;
return lhs | rhs;
}
@@ -923,43 +904,43 @@
* Exercise constant folding on logical exclusive or.
*/
- /// CHECK-START: long Main.XorIntLong() constant_folding$after_inlining (before)
+ /// CHECK-START: long Main.XorIntLong() constant_folding (before)
/// CHECK-DAG: <<Const10:i\d+>> IntConstant 10
/// CHECK-DAG: <<Const3L:j\d+>> LongConstant 3
/// CHECK-DAG: <<TypeConv:j\d+>> TypeConversion [<<Const10>>]
/// CHECK-DAG: <<Xor:j\d+>> Xor [<<TypeConv>>,<<Const3L>>]
/// CHECK-DAG: Return [<<Xor>>]
- /// CHECK-START: long Main.XorIntLong() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.XorIntLong() constant_folding (after)
/// CHECK-DAG: <<Const9:j\d+>> LongConstant 9
/// CHECK-DAG: Return [<<Const9>>]
- /// CHECK-START: long Main.XorIntLong() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.XorIntLong() constant_folding (after)
/// CHECK-NOT: Xor
public static long XorIntLong() {
- int lhs = $inline$int(10);
- long rhs = $inline$long(3L);
+ int lhs = 10;
+ long rhs = 3;
return lhs ^ rhs;
}
- /// CHECK-START: long Main.XorLongInt() constant_folding$after_inlining (before)
+ /// CHECK-START: long Main.XorLongInt() constant_folding (before)
/// CHECK-DAG: <<Const10L:j\d+>> LongConstant 10
/// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
/// CHECK-DAG: <<TypeConv:j\d+>> TypeConversion [<<Const3>>]
/// CHECK-DAG: <<Xor:j\d+>> Xor [<<TypeConv>>,<<Const10L>>]
/// CHECK-DAG: Return [<<Xor>>]
- /// CHECK-START: long Main.XorLongInt() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.XorLongInt() constant_folding (after)
/// CHECK-DAG: <<Const9:j\d+>> LongConstant 9
/// CHECK-DAG: Return [<<Const9>>]
- /// CHECK-START: long Main.XorLongInt() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.XorLongInt() constant_folding (after)
/// CHECK-NOT: Xor
public static long XorLongInt() {
- long lhs = $inline$long(10L);
- int rhs = $inline$int(3);
+ long lhs = 10;
+ int rhs = 3;
return lhs ^ rhs;
}
@@ -968,23 +949,23 @@
* Exercise constant folding on constant (static) condition.
*/
- /// CHECK-START: int Main.StaticCondition() constant_folding$after_inlining (before)
+ /// CHECK-START: int Main.StaticCondition() constant_folding (before)
/// CHECK-DAG: <<Const7:i\d+>> IntConstant 7
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: <<Cond:z\d+>> GreaterThanOrEqual [<<Const7>>,<<Const2>>]
- /// CHECK-DAG: Select [{{i\d+}},{{i\d+}},<<Cond>>]
+ /// CHECK-DAG: If [<<Cond>>]
- /// CHECK-START: int Main.StaticCondition() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.StaticCondition() constant_folding (after)
/// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- /// CHECK-DAG: Select [{{i\d+}},{{i\d+}},<<Const1>>]
+ /// CHECK-DAG: If [<<Const1>>]
- /// CHECK-START: int Main.StaticCondition() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.StaticCondition() constant_folding (after)
/// CHECK-NOT: GreaterThanOrEqual
public static int StaticCondition() {
int a, b, c;
- a = $inline$int(7);
- b = $inline$int(2);
+ a = 7;
+ b = 2;
if (a < b)
c = a + b;
else
@@ -1029,30 +1010,28 @@
* (forward) post-order traversal of the the dominator tree.
*/
- /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding$after_inlining (before)
- /// CHECK-DAG: <<Cond:z\d+>> ParameterValue
+ /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding (before)
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: <<Const5:i\d+>> IntConstant 5
/// CHECK-DAG: <<Add:i\d+>> Add [<<Const5>>,<<Const2>>]
/// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const5>>,<<Const2>>]
- /// CHECK-DAG: <<Phi:i\d+>> Select [<<Sub>>,<<Add>>,<<Cond>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
/// CHECK-DAG: Return [<<Phi>>]
- /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding$after_inlining (after)
- /// CHECK-DAG: <<Cond:z\d+>> ParameterValue
+ /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding (after)
/// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
/// CHECK-DAG: <<Const7:i\d+>> IntConstant 7
- /// CHECK-DAG: <<Phi:i\d+>> Select [<<Const3>>,<<Const7>>,<<Cond>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Const7>>,<<Const3>>]
/// CHECK-DAG: Return [<<Phi>>]
- /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding (after)
/// CHECK-NOT: Add
/// CHECK-NOT: Sub
public static int JumpsAndConditionals(boolean cond) {
int a, b, c;
- a = $inline$int(5);
- b = $inline$int(2);
+ a = 5;
+ b = 2;
if (cond)
c = a + b;
else
@@ -1328,259 +1307,207 @@
/**
- * Test optimizations of comparisons with null yielding a constant result.
- */
-
- /// CHECK-START: boolean Main.ConstStringEqualsNull() constant_folding$after_inlining (before)
- /// CHECK-DAG: <<ConstStr:l\d+>> LoadString
- /// CHECK-DAG: <<Null:l\d+>> NullConstant
- /// CHECK-DAG: <<Eq:z\d+>> Equal [<<ConstStr>>,<<Null>>]
- /// CHECK-DAG: If [<<Eq>>]
-
- /// CHECK-START: boolean Main.ConstStringEqualsNull() constant_folding$after_inlining (after)
- /// CHECK-DAG: <<False:i\d+>> IntConstant 0
- /// CHECK-DAG: If [<<False>>]
-
- /// CHECK-START: boolean Main.ConstStringEqualsNull() constant_folding$after_inlining (after)
- /// CHECK-NOT: Equal
-
- public static boolean ConstStringEqualsNull() {
- // Due to Jack emitting code using the opposite condition, use != to generate Equal.
- if ($inline$ConstString() != null) {
- return false;
- } else {
- return true;
- }
- }
-
- /// CHECK-START: boolean Main.ConstStringNotEqualsNull() constant_folding$after_inlining (before)
- /// CHECK-DAG: <<ConstStr:l\d+>> LoadString
- /// CHECK-DAG: <<Null:l\d+>> NullConstant
- /// CHECK-DAG: <<Ne:z\d+>> NotEqual [<<ConstStr>>,<<Null>>]
- /// CHECK-DAG: If [<<Ne>>]
-
- /// CHECK-START: boolean Main.ConstStringNotEqualsNull() constant_folding$after_inlining (after)
- /// CHECK-DAG: <<True:i\d+>> IntConstant 1
- /// CHECK-DAG: If [<<True>>]
-
- /// CHECK-START: boolean Main.ConstStringNotEqualsNull() constant_folding$after_inlining (after)
- /// CHECK-NOT: NotEqual
-
- public static boolean ConstStringNotEqualsNull() {
- // Due to Jack emitting code using the opposite condition, use == to generate NotEqual.
- if ($inline$ConstString() == null) {
- return false;
- } else {
- return true;
- }
- }
-
- public static String $inline$ConstString() {
- return "";
- }
-
- /**
* Exercise constant folding on type conversions.
*/
- /// CHECK-START: int Main.ReturnInt33() constant_folding$after_inlining (before)
+ /// CHECK-START: int Main.ReturnInt33() constant_folding (before)
/// CHECK-DAG: <<Const33:j\d+>> LongConstant 33
/// CHECK-DAG: <<Convert:i\d+>> TypeConversion [<<Const33>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: int Main.ReturnInt33() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.ReturnInt33() constant_folding (after)
/// CHECK-DAG: <<Const33:i\d+>> IntConstant 33
/// CHECK-DAG: Return [<<Const33>>]
- /// CHECK-START: int Main.ReturnInt33() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.ReturnInt33() constant_folding (after)
/// CHECK-NOT: TypeConversion
public static int ReturnInt33() {
- long imm = $inline$long(33L);
+ long imm = 33L;
return (int) imm;
}
- /// CHECK-START: int Main.ReturnIntMax() constant_folding$after_inlining (before)
+ /// CHECK-START: int Main.ReturnIntMax() constant_folding (before)
/// CHECK-DAG: <<ConstMax:f\d+>> FloatConstant 1e+34
/// CHECK-DAG: <<Convert:i\d+>> TypeConversion [<<ConstMax>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: int Main.ReturnIntMax() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.ReturnIntMax() constant_folding (after)
/// CHECK-DAG: <<ConstMax:i\d+>> IntConstant 2147483647
/// CHECK-DAG: Return [<<ConstMax>>]
- /// CHECK-START: int Main.ReturnIntMax() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.ReturnIntMax() constant_folding (after)
/// CHECK-NOT: TypeConversion
public static int ReturnIntMax() {
- float imm = $inline$float(1.0e34f);
+ float imm = 1.0e34f;
return (int) imm;
}
- /// CHECK-START: int Main.ReturnInt0() constant_folding$after_inlining (before)
+ /// CHECK-START: int Main.ReturnInt0() constant_folding (before)
/// CHECK-DAG: <<ConstNaN:d\d+>> DoubleConstant nan
/// CHECK-DAG: <<Convert:i\d+>> TypeConversion [<<ConstNaN>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: int Main.ReturnInt0() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.ReturnInt0() constant_folding (after)
/// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
/// CHECK-DAG: Return [<<Const0>>]
- /// CHECK-START: int Main.ReturnInt0() constant_folding$after_inlining (after)
+ /// CHECK-START: int Main.ReturnInt0() constant_folding (after)
/// CHECK-NOT: TypeConversion
public static int ReturnInt0() {
- double imm = $inline$double(Double.NaN);
+ double imm = Double.NaN;
return (int) imm;
}
- /// CHECK-START: long Main.ReturnLong33() constant_folding$after_inlining (before)
+ /// CHECK-START: long Main.ReturnLong33() constant_folding (before)
/// CHECK-DAG: <<Const33:i\d+>> IntConstant 33
/// CHECK-DAG: <<Convert:j\d+>> TypeConversion [<<Const33>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: long Main.ReturnLong33() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.ReturnLong33() constant_folding (after)
/// CHECK-DAG: <<Const33:j\d+>> LongConstant 33
/// CHECK-DAG: Return [<<Const33>>]
- /// CHECK-START: long Main.ReturnLong33() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.ReturnLong33() constant_folding (after)
/// CHECK-NOT: TypeConversion
public static long ReturnLong33() {
- int imm = $inline$int(33);
+ int imm = 33;
return (long) imm;
}
- /// CHECK-START: long Main.ReturnLong34() constant_folding$after_inlining (before)
+ /// CHECK-START: long Main.ReturnLong34() constant_folding (before)
/// CHECK-DAG: <<Const34:f\d+>> FloatConstant 34
/// CHECK-DAG: <<Convert:j\d+>> TypeConversion [<<Const34>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: long Main.ReturnLong34() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.ReturnLong34() constant_folding (after)
/// CHECK-DAG: <<Const34:j\d+>> LongConstant 34
/// CHECK-DAG: Return [<<Const34>>]
- /// CHECK-START: long Main.ReturnLong34() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.ReturnLong34() constant_folding (after)
/// CHECK-NOT: TypeConversion
public static long ReturnLong34() {
- float imm = $inline$float(34.0f);
+ float imm = 34.0f;
return (long) imm;
}
- /// CHECK-START: long Main.ReturnLong0() constant_folding$after_inlining (before)
+ /// CHECK-START: long Main.ReturnLong0() constant_folding (before)
/// CHECK-DAG: <<ConstNaN:d\d+>> DoubleConstant nan
/// CHECK-DAG: <<Convert:j\d+>> TypeConversion [<<ConstNaN>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: long Main.ReturnLong0() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.ReturnLong0() constant_folding (after)
/// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
/// CHECK-DAG: Return [<<Const0>>]
- /// CHECK-START: long Main.ReturnLong0() constant_folding$after_inlining (after)
+ /// CHECK-START: long Main.ReturnLong0() constant_folding (after)
/// CHECK-NOT: TypeConversion
public static long ReturnLong0() {
- double imm = $inline$double(-Double.NaN);
+ double imm = -Double.NaN;
return (long) imm;
}
- /// CHECK-START: float Main.ReturnFloat33() constant_folding$after_inlining (before)
+ /// CHECK-START: float Main.ReturnFloat33() constant_folding (before)
/// CHECK-DAG: <<Const33:i\d+>> IntConstant 33
/// CHECK-DAG: <<Convert:f\d+>> TypeConversion [<<Const33>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: float Main.ReturnFloat33() constant_folding$after_inlining (after)
+ /// CHECK-START: float Main.ReturnFloat33() constant_folding (after)
/// CHECK-DAG: <<Const33:f\d+>> FloatConstant 33
/// CHECK-DAG: Return [<<Const33>>]
- /// CHECK-START: float Main.ReturnFloat33() constant_folding$after_inlining (after)
+ /// CHECK-START: float Main.ReturnFloat33() constant_folding (after)
/// CHECK-NOT: TypeConversion
public static float ReturnFloat33() {
- int imm = $inline$int(33);
+ int imm = 33;
return (float) imm;
}
- /// CHECK-START: float Main.ReturnFloat34() constant_folding$after_inlining (before)
+ /// CHECK-START: float Main.ReturnFloat34() constant_folding (before)
/// CHECK-DAG: <<Const34:j\d+>> LongConstant 34
/// CHECK-DAG: <<Convert:f\d+>> TypeConversion [<<Const34>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: float Main.ReturnFloat34() constant_folding$after_inlining (after)
+ /// CHECK-START: float Main.ReturnFloat34() constant_folding (after)
/// CHECK-DAG: <<Const34:f\d+>> FloatConstant 34
/// CHECK-DAG: Return [<<Const34>>]
- /// CHECK-START: float Main.ReturnFloat34() constant_folding$after_inlining (after)
+ /// CHECK-START: float Main.ReturnFloat34() constant_folding (after)
/// CHECK-NOT: TypeConversion
public static float ReturnFloat34() {
- long imm = $inline$long(34L);
+ long imm = 34L;
return (float) imm;
}
- /// CHECK-START: float Main.ReturnFloat99P25() constant_folding$after_inlining (before)
+ /// CHECK-START: float Main.ReturnFloat99P25() constant_folding (before)
/// CHECK-DAG: <<Const:d\d+>> DoubleConstant 99.25
/// CHECK-DAG: <<Convert:f\d+>> TypeConversion [<<Const>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: float Main.ReturnFloat99P25() constant_folding$after_inlining (after)
+ /// CHECK-START: float Main.ReturnFloat99P25() constant_folding (after)
/// CHECK-DAG: <<Const:f\d+>> FloatConstant 99.25
/// CHECK-DAG: Return [<<Const>>]
- /// CHECK-START: float Main.ReturnFloat99P25() constant_folding$after_inlining (after)
+ /// CHECK-START: float Main.ReturnFloat99P25() constant_folding (after)
/// CHECK-NOT: TypeConversion
public static float ReturnFloat99P25() {
- double imm = $inline$double(99.25);
+ double imm = 99.25;
return (float) imm;
}
- /// CHECK-START: double Main.ReturnDouble33() constant_folding$after_inlining (before)
+ /// CHECK-START: double Main.ReturnDouble33() constant_folding (before)
/// CHECK-DAG: <<Const33:i\d+>> IntConstant 33
/// CHECK-DAG: <<Convert:d\d+>> TypeConversion [<<Const33>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: double Main.ReturnDouble33() constant_folding$after_inlining (after)
+ /// CHECK-START: double Main.ReturnDouble33() constant_folding (after)
/// CHECK-DAG: <<Const33:d\d+>> DoubleConstant 33
/// CHECK-DAG: Return [<<Const33>>]
public static double ReturnDouble33() {
- int imm = $inline$int(33);
+ int imm = 33;
return (double) imm;
}
- /// CHECK-START: double Main.ReturnDouble34() constant_folding$after_inlining (before)
+ /// CHECK-START: double Main.ReturnDouble34() constant_folding (before)
/// CHECK-DAG: <<Const34:j\d+>> LongConstant 34
/// CHECK-DAG: <<Convert:d\d+>> TypeConversion [<<Const34>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: double Main.ReturnDouble34() constant_folding$after_inlining (after)
+ /// CHECK-START: double Main.ReturnDouble34() constant_folding (after)
/// CHECK-DAG: <<Const34:d\d+>> DoubleConstant 34
/// CHECK-DAG: Return [<<Const34>>]
- /// CHECK-START: double Main.ReturnDouble34() constant_folding$after_inlining (after)
+ /// CHECK-START: double Main.ReturnDouble34() constant_folding (after)
/// CHECK-NOT: TypeConversion
public static double ReturnDouble34() {
- long imm = $inline$long(34L);
+ long imm = 34L;
return (double) imm;
}
- /// CHECK-START: double Main.ReturnDouble99P25() constant_folding$after_inlining (before)
+ /// CHECK-START: double Main.ReturnDouble99P25() constant_folding (before)
/// CHECK-DAG: <<Const:f\d+>> FloatConstant 99.25
/// CHECK-DAG: <<Convert:d\d+>> TypeConversion [<<Const>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: double Main.ReturnDouble99P25() constant_folding$after_inlining (after)
+ /// CHECK-START: double Main.ReturnDouble99P25() constant_folding (after)
/// CHECK-DAG: <<Const:d\d+>> DoubleConstant 99.25
/// CHECK-DAG: Return [<<Const>>]
- /// CHECK-START: double Main.ReturnDouble99P25() constant_folding$after_inlining (after)
+ /// CHECK-START: double Main.ReturnDouble99P25() constant_folding (after)
/// CHECK-NOT: TypeConversion
public static double ReturnDouble99P25() {
- float imm = $inline$float(99.25f);
+ float imm = 99.25f;
return (double) imm;
}
@@ -1659,9 +1586,6 @@
assertFalse(CmpFloatGreaterThanNaN(arbitrary));
assertFalse(CmpDoubleLessThanNaN(arbitrary));
- assertFalse(ConstStringEqualsNull());
- assertTrue(ConstStringNotEqualsNull());
-
Main main = new Main();
assertIntEquals(1, main.smaliCmpLongConstants());
assertIntEquals(-1, main.smaliCmpGtFloatConstants());
diff --git a/test/450-checker-types/build b/test/450-checker-types/build
new file mode 100755
index 0000000..49292c9
--- /dev/null
+++ b/test/450-checker-types/build
@@ -0,0 +1,23 @@
+#!/bin/bash
+#
+# Copyright 2017 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.
+
+# This checker test is incompatible with jack bytecode output,
+# so force it to use javac/dx.
+export USE_JACK=false
+# Also disable desugar because it is missing in jack platform builds.
+export DESUGAR=false
+
+./default-build "$@"
diff --git a/test/450-checker-types/smali/SmaliTests.smali b/test/450-checker-types/smali/SmaliTests.smali
deleted file mode 100644
index 6a3122e..0000000
--- a/test/450-checker-types/smali/SmaliTests.smali
+++ /dev/null
@@ -1,120 +0,0 @@
-# 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.
-
-.class public LSmaliTests;
-.super Ljava/lang/Object;
-
-## CHECK-START: void SmaliTests.testInstanceOf_EQ0_NotInlined(java.lang.Object) builder (after)
-## CHECK-DAG: <<Cst0:i\d+>> IntConstant 0
-## CHECK-DAG: <<IOf:z\d+>> InstanceOf
-## CHECK-DAG: Equal [<<IOf>>,<<Cst0>>]
-
-## CHECK-START: void SmaliTests.testInstanceOf_EQ0_NotInlined(java.lang.Object) instruction_simplifier (before)
-## CHECK: CheckCast
-
-## CHECK-START: void SmaliTests.testInstanceOf_EQ0_NotInlined(java.lang.Object) instruction_simplifier (after)
-## CHECK-NOT: CheckCast
-
-.method public static testInstanceOf_EQ0_NotInlined(Ljava/lang/Object;)V
- .registers 3
-
- const v0, 0x0
- instance-of v1, p0, LSubclassC;
- if-eq v1, v0, :return
-
- check-cast p0, LSubclassC;
- invoke-virtual {p0}, LSubclassC;->$noinline$g()V
-
- :return
- return-void
-
-.end method
-
-## CHECK-START: void SmaliTests.testInstanceOf_EQ1_NotInlined(java.lang.Object) builder (after)
-## CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
-## CHECK-DAG: <<IOf:z\d+>> InstanceOf
-## CHECK-DAG: Equal [<<IOf>>,<<Cst1>>]
-
-## CHECK-START: void SmaliTests.testInstanceOf_EQ1_NotInlined(java.lang.Object) instruction_simplifier (before)
-## CHECK: CheckCast
-
-## CHECK-START: void SmaliTests.testInstanceOf_EQ1_NotInlined(java.lang.Object) instruction_simplifier (after)
-## CHECK-NOT: CheckCast
-
-.method public static testInstanceOf_EQ1_NotInlined(Ljava/lang/Object;)V
- .registers 3
-
- const v0, 0x1
- instance-of v1, p0, LSubclassC;
- if-eq v1, v0, :invoke
- return-void
-
- :invoke
- check-cast p0, LSubclassC;
- invoke-virtual {p0}, LSubclassC;->$noinline$g()V
- return-void
-
-.end method
-
-## CHECK-START: void SmaliTests.testInstanceOf_NE0_NotInlined(java.lang.Object) builder (after)
-## CHECK-DAG: <<Cst0:i\d+>> IntConstant 0
-## CHECK-DAG: <<IOf:z\d+>> InstanceOf
-## CHECK-DAG: NotEqual [<<IOf>>,<<Cst0>>]
-
-## CHECK-START: void SmaliTests.testInstanceOf_NE0_NotInlined(java.lang.Object) instruction_simplifier (before)
-## CHECK: CheckCast
-
-## CHECK-START: void SmaliTests.testInstanceOf_NE0_NotInlined(java.lang.Object) instruction_simplifier (after)
-## CHECK-NOT: CheckCast
-
-.method public static testInstanceOf_NE0_NotInlined(Ljava/lang/Object;)V
- .registers 3
-
- const v0, 0x0
- instance-of v1, p0, LSubclassC;
- if-ne v1, v0, :invoke
- return-void
-
- :invoke
- check-cast p0, LSubclassC;
- invoke-virtual {p0}, LSubclassC;->$noinline$g()V
- return-void
-
-.end method
-
-## CHECK-START: void SmaliTests.testInstanceOf_NE1_NotInlined(java.lang.Object) builder (after)
-## CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
-## CHECK-DAG: <<IOf:z\d+>> InstanceOf
-## CHECK-DAG: NotEqual [<<IOf>>,<<Cst1>>]
-
-## CHECK-START: void SmaliTests.testInstanceOf_NE1_NotInlined(java.lang.Object) instruction_simplifier (before)
-## CHECK: CheckCast
-
-## CHECK-START: void SmaliTests.testInstanceOf_NE1_NotInlined(java.lang.Object) instruction_simplifier (after)
-## CHECK-NOT: CheckCast
-
-.method public static testInstanceOf_NE1_NotInlined(Ljava/lang/Object;)V
- .registers 3
-
- const v0, 0x1
- instance-of v1, p0, LSubclassC;
- if-ne v1, v0, :return
-
- check-cast p0, LSubclassC;
- invoke-virtual {p0}, LSubclassC;->$noinline$g()V
-
- :return
- return-void
-
-.end method
diff --git a/test/450-checker-types/src/Main.java b/test/450-checker-types/src/Main.java
index ea8609e..ae0fdbe 100644
--- a/test/450-checker-types/src/Main.java
+++ b/test/450-checker-types/src/Main.java
@@ -210,6 +210,58 @@
public static boolean $inline$InstanceofSubclassB(Object o) { return o instanceof SubclassB; }
public static boolean $inline$InstanceofSubclassC(Object o) { return o instanceof SubclassC; }
+ /// CHECK-START: void Main.testInstanceOf_NotInlined(java.lang.Object) builder (after)
+ /// CHECK-DAG: <<Cst0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<IOf1:z\d+>> InstanceOf
+ /// CHECK-DAG: NotEqual [<<IOf1>>,<<Cst1>>]
+ /// CHECK-DAG: <<IOf2:z\d+>> InstanceOf
+ /// CHECK-DAG: Equal [<<IOf2>>,<<Cst0>>]
+
+ /// CHECK-START: void Main.testInstanceOf_NotInlined(java.lang.Object) instruction_simplifier (before)
+ /// CHECK: CheckCast
+ /// CHECK: CheckCast
+ /// CHECK-NOT: CheckCast
+
+ /// CHECK-START: void Main.testInstanceOf_NotInlined(java.lang.Object) instruction_simplifier (after)
+ /// CHECK-NOT: CheckCast
+ public void testInstanceOf_NotInlined(Object o) {
+ if ((o instanceof SubclassC) == true) {
+ ((SubclassC)o).$noinline$g();
+ }
+ if ((o instanceof SubclassB) != false) {
+ ((SubclassB)o).$noinline$g();
+ }
+ }
+
+ /// CHECK-START: void Main.testNotInstanceOf_NotInlined(java.lang.Object) builder (after)
+ /// CHECK-DAG: <<Cst0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<IOf1:z\d+>> InstanceOf
+ /// CHECK-DAG: Equal [<<IOf1>>,<<Cst1>>]
+ /// CHECK-DAG: <<IOf2:z\d+>> InstanceOf
+ /// CHECK-DAG: NotEqual [<<IOf2>>,<<Cst0>>]
+
+ /// CHECK-START: void Main.testNotInstanceOf_NotInlined(java.lang.Object) instruction_simplifier (before)
+ /// CHECK: CheckCast
+ /// CHECK: CheckCast
+ /// CHECK-NOT: CheckCast
+
+ /// CHECK-START: void Main.testNotInstanceOf_NotInlined(java.lang.Object) instruction_simplifier (after)
+ /// CHECK-NOT: CheckCast
+ public void testNotInstanceOf_NotInlined(Object o) {
+ if ((o instanceof SubclassC) != true) {
+ // Empty branch to flip the condition.
+ } else {
+ ((SubclassC)o).$noinline$g();
+ }
+ if ((o instanceof SubclassB) == false) {
+ // Empty branch to flip the condition.
+ } else {
+ ((SubclassB)o).$noinline$g();
+ }
+ }
+
/// CHECK-START: void Main.testInstanceOf_Inlined(java.lang.Object) inliner (after)
/// CHECK-DAG: <<IOf:z\d+>> InstanceOf
/// CHECK-DAG: If [<<IOf>>]
@@ -634,7 +686,7 @@
/// CHECK-DAG: <<Null:l\d+>> NullConstant
/// CHECK-DAG: <<Phi:l\d+>> Phi [<<Arg>>,<<Null>>] klass:SubclassA
/// CHECK-DAG: <<NCPhi:l\d+>> NullCheck [<<Phi>>]
- /// CHECK-DAG: InvokeVirtual [<<NCPhi>>] method_name:Super.hashCode
+ /// CHECK-DAG: InvokeVirtual [<<NCPhi>>] method_name:java.lang.Object.hashCode
public void testThisArgumentMoreSpecific(boolean cond) {
// Inlining method from Super will build it with `this` typed as Super.
@@ -655,7 +707,7 @@
/// CHECK-START: void Main.testExplicitArgumentMoreSpecific(SubclassA) inliner (after)
/// CHECK-DAG: <<Arg:l\d+>> ParameterValue klass:SubclassA
/// CHECK-DAG: <<NCArg:l\d+>> NullCheck [<<Arg>>] klass:SubclassA
- /// CHECK-DAG: InvokeVirtual [<<NCArg>>] method_name:Super.hashCode
+ /// CHECK-DAG: InvokeVirtual [<<NCArg>>] method_name:java.lang.Object.hashCode
public void testExplicitArgumentMoreSpecific(SubclassA obj) {
// Inlining a method will build it with reference types from its signature,
diff --git a/test/463-checker-boolean-simplifier/build b/test/463-checker-boolean-simplifier/build
new file mode 100755
index 0000000..49292c9
--- /dev/null
+++ b/test/463-checker-boolean-simplifier/build
@@ -0,0 +1,23 @@
+#!/bin/bash
+#
+# Copyright 2017 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.
+
+# This checker test is incompatible with jack bytecode output,
+# so force it to use javac/dx.
+export USE_JACK=false
+# Also disable desugar because it is missing in jack platform builds.
+export DESUGAR=false
+
+./default-build "$@"
diff --git a/test/463-checker-boolean-simplifier/smali/BooleanNotDx.smali b/test/463-checker-boolean-simplifier/smali/BooleanNotDx.smali
deleted file mode 100644
index 765d0eb..0000000
--- a/test/463-checker-boolean-simplifier/smali/BooleanNotDx.smali
+++ /dev/null
@@ -1,65 +0,0 @@
-# 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.
-
-.class public LBooleanNotSmali;
-.super Ljava/lang/Object;
-
-#
-# Elementary test negating a boolean. Verifies that blocks are merged and
-# empty branches removed.
-#
-
-## CHECK-START: boolean BooleanNotSmali.BooleanNot(boolean) select_generator (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 [<<Const0>>,<<Const1>>]
-## CHECK-DAG: Return [<<Phi>>]
-
-## CHECK-START: boolean BooleanNotSmali.BooleanNot(boolean) select_generator (before)
-## CHECK: Goto
-## CHECK: Goto
-## CHECK: Goto
-## CHECK-NOT: Goto
-
-## CHECK-START: boolean BooleanNotSmali.BooleanNot(boolean) select_generator (after)
-## CHECK-DAG: <<Param:z\d+>> ParameterValue
-## CHECK-DAG: <<Const0:i\d+>> IntConstant 0
-## CHECK-DAG: <<Const1:i\d+>> IntConstant 1
-## CHECK-DAG: <<NotParam:i\d+>> Select [<<Const1>>,<<Const0>>,<<Param>>]
-## CHECK-DAG: Return [<<NotParam>>]
-
-## CHECK-START: boolean BooleanNotSmali.BooleanNot(boolean) select_generator (after)
-## CHECK-NOT: If
-## CHECK-NOT: Phi
-
-## CHECK-START: boolean BooleanNotSmali.BooleanNot(boolean) select_generator (after)
-## CHECK: Goto
-## CHECK-NOT: Goto
-
-.method public static BooleanNot(Z)Z
- .registers 2
-
- if-eqz v1, :true_start
- const/4 v0, 0x0
-
-:return_start
- return v0
-
-:true_start
- const/4 v0, 0x1
- goto :return_start
-
-.end method
diff --git a/test/463-checker-boolean-simplifier/src/Main.java b/test/463-checker-boolean-simplifier/src/Main.java
index 9368488..d1d02cd 100644
--- a/test/463-checker-boolean-simplifier/src/Main.java
+++ b/test/463-checker-boolean-simplifier/src/Main.java
@@ -32,14 +32,42 @@
}
}
- // Invoke a method written in smali that implements the boolean ! operator. This method
- // uses the if/else pattern generated by dx (while Jack generates a different pattern).
- // Since this method is in a smali-generated class, we invoke it through reflection.
- public static boolean SmaliBooleanNot(boolean x) throws Exception {
- Class<?> c = Class.forName("BooleanNotSmali");
- java.lang.reflect.Method method = c.getMethod("BooleanNot", boolean.class);
- Object retValue = method.invoke(null, new Object[] { Boolean.valueOf(x) });
- return ((Boolean) retValue).booleanValue();
+ /*
+ * Elementary test negating a boolean. Verifies that blocks are merged and
+ * empty branches removed.
+ */
+
+ /// CHECK-START: boolean Main.BooleanNot(boolean) select_generator (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) select_generator (before)
+ /// CHECK: Goto
+ /// CHECK: Goto
+ /// CHECK: Goto
+ /// CHECK-NOT: Goto
+
+ /// CHECK-START: boolean Main.BooleanNot(boolean) select_generator (after)
+ /// CHECK-DAG: <<Param:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<NotParam:i\d+>> Select [<<Const1>>,<<Const0>>,<<Param>>]
+ /// CHECK-DAG: Return [<<NotParam>>]
+
+ /// CHECK-START: boolean Main.BooleanNot(boolean) select_generator (after)
+ /// CHECK-NOT: If
+ /// CHECK-NOT: Phi
+
+ /// CHECK-START: boolean Main.BooleanNot(boolean) select_generator (after)
+ /// CHECK: Goto
+ /// CHECK-NOT: Goto
+
+ public static boolean BooleanNot(boolean x) {
+ return !x;
}
/*
@@ -157,7 +185,11 @@
/// CHECK-NOT: BooleanNot
public static int NegatedCondition(boolean x) {
- return (x != false) ? 42 : 43;
+ if (x != false) {
+ return 42;
+ } else {
+ return 43;
+ }
}
/// CHECK-START: int Main.SimpleTrueBlock(boolean, int) select_generator (after)
@@ -221,7 +253,13 @@
/// CHECK-DAG: Return [<<Select123>>]
public static int ThreeBlocks(boolean x, boolean y) {
- return x ? 1 : (y ? 2 : 3);
+ if (x) {
+ return 1;
+ } else if (y) {
+ return 2;
+ } else {
+ return 3;
+ }
}
/// CHECK-START: int Main.MultiplePhis() select_generator (before)
@@ -254,10 +292,8 @@
while (y++ < 10) {
if (y > 1) {
x = 13;
- continue;
} else {
x = 42;
- continue;
}
}
return x;
@@ -330,8 +366,8 @@
}
public static void main(String[] args) throws Exception {
- assertBoolEquals(false, SmaliBooleanNot(true));
- assertBoolEquals(true, SmaliBooleanNot(false));
+ assertBoolEquals(false, BooleanNot(true));
+ assertBoolEquals(true, BooleanNot(false));
assertBoolEquals(true, GreaterThan(10, 5));
assertBoolEquals(false, GreaterThan(10, 10));
assertBoolEquals(false, GreaterThan(5, 10));
diff --git a/test/537-checker-inline-and-unverified/build b/test/537-checker-inline-and-unverified/build
new file mode 100755
index 0000000..49292c9
--- /dev/null
+++ b/test/537-checker-inline-and-unverified/build
@@ -0,0 +1,23 @@
+#!/bin/bash
+#
+# Copyright 2017 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.
+
+# This checker test is incompatible with jack bytecode output,
+# so force it to use javac/dx.
+export USE_JACK=false
+# Also disable desugar because it is missing in jack platform builds.
+export DESUGAR=false
+
+./default-build "$@"
diff --git a/test/537-checker-inline-and-unverified/src/Main.java b/test/537-checker-inline-and-unverified/src/Main.java
index b9d5fc9..bdc14b0 100644
--- a/test/537-checker-inline-and-unverified/src/Main.java
+++ b/test/537-checker-inline-and-unverified/src/Main.java
@@ -45,14 +45,12 @@
}
public static boolean $opt$noinline$testNoInline() {
- boolean result = true;
try {
- result = (null instanceof InaccessibleClass);
- throw new Error("Unreachable");
+ return null instanceof InaccessibleClass;
} catch (IllegalAccessError e) {
// expected
}
- return result;
+ return false;
}
public static boolean $opt$inline$testInline() {
