Refactor builder intrinsic tests.
Move tests for building HIR for intrinsics in instruction
builder to a single test. Remove duplicate rotate tests.
Enable these tests on the RI (some were disabled in the
known failures, some by using src-art, some were enabled).
Drop the unnecessary `--experimental method-handles`-passing
build script that used to be in 709-checker-varhandles.
Test: testrunner.py --host --optimizing --jvm
(Ignore pre-existing --jvm failures.)
Change-Id: Iee799c5f5daa6b1ba711e834fb93156c5e5e8fa8
diff --git a/test/557-checker-instruct-simplifier-ror/src/Main.java b/test/557-checker-instruct-simplifier-ror/src/Main.java
index 1c52f07..5d4bb7a 100644
--- a/test/557-checker-instruct-simplifier-ror/src/Main.java
+++ b/test/557-checker-instruct-simplifier-ror/src/Main.java
@@ -28,64 +28,6 @@
}
}
- /// CHECK-START: int Main.rotateIntegerRight(int, int) builder (after)
- /// CHECK: <<ArgValue:i\d+>> ParameterValue
- /// CHECK: <<ArgDistance:i\d+>> ParameterValue
- /// CHECK: <<Ror:i\d+>> Ror [<<ArgValue>>,<<ArgDistance>>]
- /// CHECK: Return [<<Ror>>]
-
- /// CHECK-START: int Main.rotateIntegerRight(int, int) builder (after)
- /// CHECK-NOT: LoadClass
- /// CHECK-NOT: ClinitCheck
- /// CHECK-NOT: InvokeStaticOrDirect
- public static int rotateIntegerRight(int value, int distance) {
- return Integer.rotateRight(value, distance);
- }
-
- /// CHECK-START: int Main.rotateIntegerLeft(int, int) builder (after)
- /// CHECK: <<ArgValue:i\d+>> ParameterValue
- /// CHECK: <<ArgDistance:i\d+>> ParameterValue
- /// CHECK: <<Neg:i\d+>> Neg [<<ArgDistance>>]
- /// CHECK: <<Ror:i\d+>> Ror [<<ArgValue>>,<<Neg>>]
- /// CHECK: Return [<<Ror>>]
-
- /// CHECK-START: int Main.rotateIntegerLeft(int, int) builder (after)
- /// CHECK-NOT: LoadClass
- /// CHECK-NOT: ClinitCheck
- /// CHECK-NOT: InvokeStaticOrDirect
- public static int rotateIntegerLeft(int value, int distance) {
- return Integer.rotateLeft(value, distance);
- }
-
- /// CHECK-START: long Main.rotateLongRight(long, int) builder (after)
- /// CHECK: <<ArgValue:j\d+>> ParameterValue
- /// CHECK: <<ArgDistance:i\d+>> ParameterValue
- /// CHECK: <<Ror:j\d+>> Ror [<<ArgValue>>,<<ArgDistance>>]
- /// CHECK: Return [<<Ror>>]
-
- /// CHECK-START: long Main.rotateLongRight(long, int) builder (after)
- /// CHECK-NOT: LoadClass
- /// CHECK-NOT: ClinitCheck
- /// CHECK-NOT: InvokeStaticOrDirect
- public static long rotateLongRight(long value, int distance) {
- return Long.rotateRight(value, distance);
- }
-
- /// CHECK-START: long Main.rotateLongLeft(long, int) builder (after)
- /// CHECK: <<ArgValue:j\d+>> ParameterValue
- /// CHECK: <<ArgDistance:i\d+>> ParameterValue
- /// CHECK: <<Neg:i\d+>> Neg [<<ArgDistance>>]
- /// CHECK: <<Ror:j\d+>> Ror [<<ArgValue>>,<<Neg>>]
- /// CHECK: Return [<<Ror>>]
-
- /// CHECK-START: long Main.rotateLongLeft(long, int) builder (after)
- /// CHECK-NOT: LoadClass
- /// CHECK-NOT: ClinitCheck
- /// CHECK-NOT: InvokeStaticOrDirect
- public static long rotateLongLeft(long value, int distance) {
- return Long.rotateLeft(value, distance);
- }
-
// (i >>> #distance) | (i << #(reg_bits - distance))
/// CHECK-START: int Main.ror_int_constant_c_c(int) instruction_simplifier (before)
diff --git a/test/565-checker-rotate/expected.txt b/test/565-checker-rotate/expected.txt
deleted file mode 100644
index b0aad4d..0000000
--- a/test/565-checker-rotate/expected.txt
+++ /dev/null
@@ -1 +0,0 @@
-passed
diff --git a/test/565-checker-rotate/info.txt b/test/565-checker-rotate/info.txt
deleted file mode 100644
index c6a8091..0000000
--- a/test/565-checker-rotate/info.txt
+++ /dev/null
@@ -1 +0,0 @@
-Unit test for 32-bit and 64-bit rotate operations.
diff --git a/test/566-checker-signum/expected.txt b/test/566-checker-signum/expected.txt
deleted file mode 100644
index b0aad4d..0000000
--- a/test/566-checker-signum/expected.txt
+++ /dev/null
@@ -1 +0,0 @@
-passed
diff --git a/test/566-checker-signum/info.txt b/test/566-checker-signum/info.txt
deleted file mode 100644
index 328e494..0000000
--- a/test/566-checker-signum/info.txt
+++ /dev/null
@@ -1 +0,0 @@
-Unit test for 32-bit and 64-bit signum operations.
diff --git a/test/566-checker-signum/src/Main.java b/test/566-checker-signum/src/Main.java
deleted file mode 100644
index fa8e5cd..0000000
--- a/test/566-checker-signum/src/Main.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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.
- */
-
-// This file is just for running on the RI as the test is ART specific.
-public class Main {
- public static void main(String[] args) {
- System.out.println("passed");
- }
-}
diff --git a/test/567-checker-builder-intrinsics/expected.txt b/test/567-checker-builder-intrinsics/expected.txt
new file mode 100644
index 0000000..9554e0d
--- /dev/null
+++ b/test/567-checker-builder-intrinsics/expected.txt
@@ -0,0 +1,8 @@
+TestRotate passed
+TestCompare passed
+TestSignum passed
+TestIsNan passed
+TestVarHandles passed
+TestMinMax passed
+TestAbs passed
+TestFpAbs passed
diff --git a/test/567-checker-builder-intrinsics/info.txt b/test/567-checker-builder-intrinsics/info.txt
new file mode 100644
index 0000000..7ad7aa8
--- /dev/null
+++ b/test/567-checker-builder-intrinsics/info.txt
@@ -0,0 +1,2 @@
+Tests for creating intermediate representation in InstructionBuilder for simple
+intrinsics. It also tests some simplifications for these instructions.
diff --git a/test/565-checker-rotate/src/Main.java b/test/567-checker-builder-intrinsics/src/Main.java
similarity index 72%
rename from test/565-checker-rotate/src/Main.java
rename to test/567-checker-builder-intrinsics/src/Main.java
index 79b8555..3320fb7 100644
--- a/test/565-checker-rotate/src/Main.java
+++ b/test/567-checker-builder-intrinsics/src/Main.java
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2018 The Android Open Source Project
+ * Copyright (C) 2020 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.
@@ -14,9 +14,15 @@
* limitations under the License.
*/
-// This file is just for running on the RI as the test is ART specific.
public class Main {
public static void main(String args[]) {
- System.out.println("passed");
+ TestRotate.main();
+ TestCompare.main();
+ TestSignum.main();
+ TestIsNan.main();
+ TestVarHandles.main();
+ TestMinMax.main();
+ TestAbs.main();
+ TestFpAbs.main();
}
-}
\ No newline at end of file
+}
diff --git a/test/681-checker-abs/src/Main.java b/test/567-checker-builder-intrinsics/src/TestAbs.java
similarity index 73%
rename from test/681-checker-abs/src/Main.java
rename to test/567-checker-builder-intrinsics/src/TestAbs.java
index 7c68e17..defc988 100644
--- a/test/681-checker-abs/src/Main.java
+++ b/test/567-checker-builder-intrinsics/src/TestAbs.java
@@ -17,29 +17,29 @@
/**
* Functional tests for detecting abs.
*/
-public class Main {
+public class TestAbs {
//
// Intrinsics.
//
- /// CHECK-START: int Main.absI(int) builder (after)
+ /// CHECK-START: int TestAbs.absI(int) builder (after)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
/// CHECK-DAG: Return [<<Abs>>]
//
- /// CHECK-START: int Main.absI(int) builder (after)
+ /// CHECK-START: int TestAbs.absI(int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int absI(int a) {
return Math.abs(a);
}
- /// CHECK-START: long Main.absL(long) builder (after)
+ /// CHECK-START: long TestAbs.absL(long) builder (after)
/// CHECK-DAG: <<Par:j\d+>> ParameterValue
/// CHECK-DAG: <<Abs:j\d+>> Abs [<<Par>>]
/// CHECK-DAG: Return [<<Abs>>]
//
- /// CHECK-START: long Main.absL(long) builder (after)
+ /// CHECK-START: long TestAbs.absL(long) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static long absL(long a) {
return Math.abs(a);
@@ -49,7 +49,7 @@
// Types.
//
- /// CHECK-START: int Main.abs1(int) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestAbs.abs1(int) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
/// CHECK-DAG: <<Cnd:z\d+>> GreaterThanOrEqual [<<Par>>,<<Zer>>]
@@ -57,18 +57,18 @@
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Neg>>,<<Par>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.abs1(int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestAbs.abs1(int) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
/// CHECK-DAG: Return [<<Abs>>]
//
- /// CHECK-START: int Main.abs1(int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestAbs.abs1(int) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int abs1(int a) {
return a < 0 ? -a : a;
}
- /// CHECK-START: int Main.abs2(int) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestAbs.abs2(int) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
/// CHECK-DAG: <<Cnd:z\d+>> GreaterThan [<<Par>>,<<Zer>>]
@@ -76,18 +76,18 @@
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Neg>>,<<Par>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.abs2(int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestAbs.abs2(int) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
/// CHECK-DAG: Return [<<Abs>>]
//
- /// CHECK-START: int Main.abs2(int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestAbs.abs2(int) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int abs2(int a) {
return a <= 0 ? -a : a;
}
- /// CHECK-START: int Main.abs3(int) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestAbs.abs3(int) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
/// CHECK-DAG: <<Cnd:z\d+>> LessThanOrEqual [<<Par>>,<<Zer>>]
@@ -95,18 +95,18 @@
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Par>>,<<Neg>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.abs3(int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestAbs.abs3(int) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
/// CHECK-DAG: Return [<<Abs>>]
//
- /// CHECK-START: int Main.abs3(int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestAbs.abs3(int) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int abs3(int a) {
return a > 0 ? a : -a;
}
- /// CHECK-START: int Main.abs4(int) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestAbs.abs4(int) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
/// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Par>>,<<Zer>>]
@@ -114,18 +114,18 @@
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Par>>,<<Neg>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.abs4(int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestAbs.abs4(int) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
/// CHECK-DAG: Return [<<Abs>>]
//
- /// CHECK-START: int Main.abs4(int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestAbs.abs4(int) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int abs4(int a) {
return a >= 0 ? a : -a;
}
- /// CHECK-START: int Main.abs5(short) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestAbs.abs5(short) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Par:s\d+>> ParameterValue
/// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
/// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Par>>,<<Zer>>]
@@ -133,18 +133,18 @@
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Par>>,<<Neg>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.abs5(short) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestAbs.abs5(short) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Par:s\d+>> ParameterValue
/// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
/// CHECK-DAG: Return [<<Abs>>]
//
- /// CHECK-START: int Main.abs5(short) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestAbs.abs5(short) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int abs5(short a) {
return a >= 0 ? a : -a;
}
- /// CHECK-START: int Main.abs6(byte) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestAbs.abs6(byte) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Par:b\d+>> ParameterValue
/// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
/// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Par>>,<<Zer>>]
@@ -152,18 +152,18 @@
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Par>>,<<Neg>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.abs6(byte) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestAbs.abs6(byte) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Par:b\d+>> ParameterValue
/// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
/// CHECK-DAG: Return [<<Abs>>]
//
- /// CHECK-START: int Main.abs6(byte) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestAbs.abs6(byte) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int abs6(byte a) {
return a >= 0 ? a : -a;
}
- /// CHECK-START: long Main.abs7(long) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: long TestAbs.abs7(long) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Par:j\d+>> ParameterValue
/// CHECK-DAG: <<Zer:j\d+>> LongConstant 0
/// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Par>>,<<Zer>>]
@@ -171,12 +171,12 @@
/// CHECK-DAG: <<Sel:j\d+>> Select [<<Par>>,<<Neg>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: long Main.abs7(long) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: long TestAbs.abs7(long) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Par:j\d+>> ParameterValue
/// CHECK-DAG: <<Abs:j\d+>> Abs [<<Par>>]
/// CHECK-DAG: Return [<<Abs>>]
//
- /// CHECK-START: long Main.abs7(long) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: long TestAbs.abs7(long) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static long abs7(long a) {
return a >= 0 ? a : -a;
@@ -186,7 +186,7 @@
// Complications.
//
- /// CHECK-START: int Main.abs0(int[]) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestAbs.abs0(int[]) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
/// CHECK-DAG: <<Arr:i\d+>> ArrayGet [{{l\d+}},{{i\d+}}]
/// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Arr>>,<<Zer>>]
@@ -194,12 +194,12 @@
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Arr>>,<<Neg>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.abs0(int[]) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestAbs.abs0(int[]) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Arr:i\d+>> ArrayGet [{{l\d+}},{{i\d+}}]
/// CHECK-DAG: <<Abs:i\d+>> Abs [<<Arr>>]
/// CHECK-DAG: Return [<<Abs>>]
//
- /// CHECK-START: int Main.abs0(int[]) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestAbs.abs0(int[]) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int abs0(int[] a) {
return a[0] >= 0 ? a[0] : -a[0];
@@ -209,58 +209,58 @@
// Nop zero extension.
//
- /// CHECK-START: int Main.zabs1(byte) instruction_simplifier (before)
+ /// CHECK-START: int TestAbs.zabs1(byte) instruction_simplifier (before)
/// CHECK-DAG: <<Par:b\d+>> ParameterValue
/// CHECK-DAG: <<Msk:i\d+>> IntConstant 255
/// CHECK-DAG: <<And:i\d+>> [<<Par>>,<<Msk>>]
/// CHECK-DAG: <<Abs:i\d+>> Abs
/// CHECK-DAG: Return [<<Abs>>]
//
- /// CHECK-START: int Main.zabs1(byte) instruction_simplifier (after)
+ /// CHECK-START: int TestAbs.zabs1(byte) instruction_simplifier (after)
/// CHECK-DAG: <<Par:b\d+>> ParameterValue
/// CHECK-DAG: <<Cnv:a\d+>> TypeConversion [<<Par>>]
/// CHECK-DAG: Return [<<Cnv>>]
//
- /// CHECK-START: int Main.zabs1(byte) instruction_simplifier (after)
+ /// CHECK-START: int TestAbs.zabs1(byte) instruction_simplifier (after)
/// CHECK-NOT: Abs
public static int zabs1(byte a) {
return Math.abs(a & 0xff);
}
- /// CHECK-START: int Main.zabs2(short) instruction_simplifier (before)
+ /// CHECK-START: int TestAbs.zabs2(short) instruction_simplifier (before)
/// CHECK-DAG: <<Par:s\d+>> ParameterValue
/// CHECK-DAG: <<Msk:i\d+>> IntConstant 65535
/// CHECK-DAG: <<And:i\d+>> [<<Msk>>,<<Par>>]
/// CHECK-DAG: <<Abs:i\d+>> Abs
/// CHECK-DAG: Return [<<Abs>>]
//
- /// CHECK-START: int Main.zabs2(short) instruction_simplifier (after)
+ /// CHECK-START: int TestAbs.zabs2(short) instruction_simplifier (after)
/// CHECK-DAG: <<Par:s\d+>> ParameterValue
/// CHECK-DAG: <<Cnv:c\d+>> TypeConversion [<<Par>>]
/// CHECK-DAG: Return [<<Cnv>>]
//
- /// CHECK-START: int Main.zabs2(short) instruction_simplifier (after)
+ /// CHECK-START: int TestAbs.zabs2(short) instruction_simplifier (after)
/// CHECK-NOT: Abs
public static int zabs2(short a) {
return Math.abs(a & 0xffff);
}
- /// CHECK-START: int Main.zabs3(char) instruction_simplifier (before)
+ /// CHECK-START: int TestAbs.zabs3(char) instruction_simplifier (before)
/// CHECK-DAG: <<Par:c\d+>> ParameterValue
/// CHECK-DAG: <<Abs:i\d+>> Abs
/// CHECK-DAG: Return [<<Abs>>]
//
- /// CHECK-START: int Main.zabs3(char) instruction_simplifier (after)
+ /// CHECK-START: int TestAbs.zabs3(char) instruction_simplifier (after)
/// CHECK-DAG: <<Par:c\d+>> ParameterValue
/// CHECK-DAG: Return [<<Par>>]
//
- /// CHECK-START: int Main.zabs3(char) instruction_simplifier (after)
+ /// CHECK-START: int TestAbs.zabs3(char) instruction_simplifier (after)
/// CHECK-NOT: Abs
public static int zabs3(char a) {
return Math.abs(a);
}
- public static void main(String[] args) {
+ public static void main() {
// Intrinsics.
expectEquals(10, absI(-10));
expectEquals(20, absI(20));
@@ -293,7 +293,7 @@
expectEquals(0xffff, zabs2((short) -1));
expectEquals(1, zabs3((char) 1));
expectEquals(0xffff, zabs3((char) -1));
- System.out.println("passed");
+ System.out.println("TestAbs passed");
}
private static void expectEquals(int expected, int result) {
diff --git a/test/567-checker-compare/src/Main.java b/test/567-checker-builder-intrinsics/src/TestCompare.java
similarity index 87%
rename from test/567-checker-compare/src/Main.java
rename to test/567-checker-builder-intrinsics/src/TestCompare.java
index fe1691d..185616a 100644
--- a/test/567-checker-compare/src/Main.java
+++ b/test/567-checker-builder-intrinsics/src/TestCompare.java
@@ -14,46 +14,46 @@
* limitations under the License.
*/
-public class Main {
+public class TestCompare {
- /// CHECK-START: void Main.$opt$noinline$testReplaceInputWithItself(int) builder (after)
+ /// CHECK-START: void TestCompare.$opt$noinline$testReplaceInputWithItself(int) builder (after)
/// CHECK-DAG: <<ArgX:i\d+>> ParameterValue
/// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
/// CHECK-DAG: <<Cmp:i\d+>> Compare [<<ArgX>>,<<Zero>>]
/// CHECK-DAG: GreaterThanOrEqual [<<Cmp>>,<<Zero>>]
- /// CHECK-START: void Main.$opt$noinline$testReplaceInputWithItself(int) instruction_simplifier (after)
+ /// CHECK-START: void TestCompare.$opt$noinline$testReplaceInputWithItself(int) instruction_simplifier (after)
/// CHECK-DAG: <<ArgX:i\d+>> ParameterValue
/// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
/// CHECK-DAG: GreaterThanOrEqual [<<ArgX>>,<<Zero>>]
public static void $opt$noinline$testReplaceInputWithItself(int x) {
- // The instruction simplifier first replaces Integer.compare(x, 0) with Compare HIR
- // and then merges the Compare into the GreaterThanOrEqual. This is a regression
- // test that to check that it is allowed to replace the second input of the
- // GreaterThanOrEqual, i.e. <<Zero>>, with the very same instruction.
+ // The instruction builder first replaces Integer.compare(x, 0) with Compare HIR
+ // and then the instruction simplifier merges the Compare into the GreaterThanOrEqual.
+ // This is a regression test to check that it is allowed to replace the second
+ // input of the GreaterThanOrEqual, i.e. <<Zero>>, with the very same instruction.
if (Integer.compare(x, 0) < 0) {
System.out.println("OOOPS");
}
}
- /// CHECK-START: int Main.compareBooleans(boolean, boolean) select_generator (after)
+ /// CHECK-START: int TestCompare.compareBooleans(boolean, boolean) select_generator (after)
/// CHECK-NOT: Phi
- /// CHECK-START: int Main.compareBooleans(boolean, boolean) instruction_simplifier$after_bce (after)
+ /// CHECK-START: int TestCompare.compareBooleans(boolean, boolean) instruction_simplifier$after_bce (after)
/// CHECK: <<ArgX:z\d+>> ParameterValue
/// CHECK: <<ArgY:z\d+>> ParameterValue
/// CHECK-DAG: <<Result:i\d+>> Compare [<<ArgX>>,<<ArgY>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareBooleans(boolean, boolean) instruction_simplifier$after_bce (after)
+ /// CHECK-START: int TestCompare.compareBooleans(boolean, boolean) instruction_simplifier$after_bce (after)
/// CHECK-NOT: Select
private static int compareBooleans(boolean x, boolean y) {
return Integer.compare((x ? 1 : 0), (y ? 1 : 0));
}
- /// CHECK-START: int Main.compareBooleans2(boolean, boolean) builder (after)
+ /// CHECK-START: int TestCompare.compareBooleans2(boolean, boolean) builder (after)
/// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
/// CHECK-DAG: <<One:i\d+>> IntConstant 1
/// CHECK-DAG: <<PhiX:i\d+>> Phi [<<One>>,<<Zero>>]
@@ -61,10 +61,10 @@
/// CHECK-DAG: <<Result:i\d+>> Compare [<<PhiX>>,<<PhiY>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareBooleans2(boolean, boolean) builder (after)
+ /// CHECK-START: int TestCompare.compareBooleans2(boolean, boolean) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
- /// CHECK-START: int Main.compareBooleans2(boolean, boolean) select_generator (after)
+ /// CHECK-START: int TestCompare.compareBooleans2(boolean, boolean) select_generator (after)
/// CHECK: <<ArgX:z\d+>> ParameterValue
/// CHECK: <<ArgY:z\d+>> ParameterValue
/// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
@@ -74,16 +74,16 @@
/// CHECK-DAG: <<Result:i\d+>> Compare [<<SelX>>,<<SelY>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareBooleans2(boolean, boolean) select_generator (after)
+ /// CHECK-START: int TestCompare.compareBooleans2(boolean, boolean) select_generator (after)
/// CHECK-NOT: Phi
- /// CHECK-START: int Main.compareBooleans2(boolean, boolean) instruction_simplifier$after_bce (after)
+ /// CHECK-START: int TestCompare.compareBooleans2(boolean, boolean) instruction_simplifier$after_bce (after)
/// CHECK: <<ArgX:z\d+>> ParameterValue
/// CHECK: <<ArgY:z\d+>> ParameterValue
/// CHECK-DAG: <<Result:i\d+>> Compare [<<ArgX>>,<<ArgY>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareBooleans2(boolean, boolean) instruction_simplifier$after_bce (after)
+ /// CHECK-START: int TestCompare.compareBooleans2(boolean, boolean) instruction_simplifier$after_bce (after)
/// CHECK-NOT: Select
private static int compareBooleans2(boolean x, boolean y) {
@@ -104,55 +104,55 @@
return Integer.compare(src_x, src_y);
}
- /// CHECK-START: int Main.compareBytes(byte, byte) builder (after)
+ /// CHECK-START: int TestCompare.compareBytes(byte, byte) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareBytes(byte, byte) builder (after)
+ /// CHECK-START: int TestCompare.compareBytes(byte, byte) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int compareBytes(byte x, byte y) {
return Integer.compare(x, y);
}
- /// CHECK-START: int Main.compareShorts(short, short) builder (after)
+ /// CHECK-START: int TestCompare.compareShorts(short, short) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareShorts(short, short) builder (after)
+ /// CHECK-START: int TestCompare.compareShorts(short, short) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int compareShorts(short x, short y) {
return Integer.compare(x, y);
}
- /// CHECK-START: int Main.compareChars(char, char) builder (after)
+ /// CHECK-START: int TestCompare.compareChars(char, char) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareChars(char, char) builder (after)
+ /// CHECK-START: int TestCompare.compareChars(char, char) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int compareChars(char x, char y) {
return Integer.compare(x, y);
}
- /// CHECK-START: int Main.compareInts(int, int) builder (after)
+ /// CHECK-START: int TestCompare.compareInts(int, int) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareInts(int, int) builder (after)
+ /// CHECK-START: int TestCompare.compareInts(int, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int compareInts(int x, int y) {
return Integer.compare(x, y);
}
- /// CHECK-START: int Main.compareLongs(long, long) builder (after)
+ /// CHECK-START: int TestCompare.compareLongs(long, long) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareLongs(long, long) builder (after)
+ /// CHECK-START: int TestCompare.compareLongs(long, long) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int compareLongs(long x, long y) {
@@ -160,33 +160,33 @@
}
- /// CHECK-START: int Main.compareByteShort(byte, short) builder (after)
+ /// CHECK-START: int TestCompare.compareByteShort(byte, short) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareByteShort(byte, short) builder (after)
+ /// CHECK-START: int TestCompare.compareByteShort(byte, short) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareByteShort(byte x, short y) {
return Integer.compare(x, y);
}
- /// CHECK-START: int Main.compareByteChar(byte, char) builder (after)
+ /// CHECK-START: int TestCompare.compareByteChar(byte, char) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareByteChar(byte, char) builder (after)
+ /// CHECK-START: int TestCompare.compareByteChar(byte, char) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareByteChar(byte x, char y) {
return Integer.compare(x, y);
}
- /// CHECK-START: int Main.compareByteInt(byte, int) builder (after)
+ /// CHECK-START: int TestCompare.compareByteInt(byte, int) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareByteInt(byte, int) builder (after)
+ /// CHECK-START: int TestCompare.compareByteInt(byte, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareByteInt(byte x, int y) {
@@ -194,33 +194,33 @@
}
- /// CHECK-START: int Main.compareShortByte(short, byte) builder (after)
+ /// CHECK-START: int TestCompare.compareShortByte(short, byte) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareShortByte(short, byte) builder (after)
+ /// CHECK-START: int TestCompare.compareShortByte(short, byte) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareShortByte(short x, byte y) {
return Integer.compare(x, y);
}
- /// CHECK-START: int Main.compareShortChar(short, char) builder (after)
+ /// CHECK-START: int TestCompare.compareShortChar(short, char) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareShortChar(short, char) builder (after)
+ /// CHECK-START: int TestCompare.compareShortChar(short, char) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareShortChar(short x, char y) {
return Integer.compare(x, y);
}
- /// CHECK-START: int Main.compareShortInt(short, int) builder (after)
+ /// CHECK-START: int TestCompare.compareShortInt(short, int) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareShortInt(short, int) builder (after)
+ /// CHECK-START: int TestCompare.compareShortInt(short, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareShortInt(short x, int y) {
@@ -228,33 +228,33 @@
}
- /// CHECK-START: int Main.compareCharByte(char, byte) builder (after)
+ /// CHECK-START: int TestCompare.compareCharByte(char, byte) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareCharByte(char, byte) builder (after)
+ /// CHECK-START: int TestCompare.compareCharByte(char, byte) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareCharByte(char x, byte y) {
return Integer.compare(x, y);
}
- /// CHECK-START: int Main.compareCharShort(char, short) builder (after)
+ /// CHECK-START: int TestCompare.compareCharShort(char, short) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareCharShort(char, short) builder (after)
+ /// CHECK-START: int TestCompare.compareCharShort(char, short) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareCharShort(char x, short y) {
return Integer.compare(x, y);
}
- /// CHECK-START: int Main.compareCharInt(char, int) builder (after)
+ /// CHECK-START: int TestCompare.compareCharInt(char, int) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareCharInt(char, int) builder (after)
+ /// CHECK-START: int TestCompare.compareCharInt(char, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareCharInt(char x, int y) {
@@ -262,33 +262,33 @@
}
- /// CHECK-START: int Main.compareIntByte(int, byte) builder (after)
+ /// CHECK-START: int TestCompare.compareIntByte(int, byte) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareIntByte(int, byte) builder (after)
+ /// CHECK-START: int TestCompare.compareIntByte(int, byte) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareIntByte(int x, byte y) {
return Integer.compare(x, y);
}
- /// CHECK-START: int Main.compareIntShort(int, short) builder (after)
+ /// CHECK-START: int TestCompare.compareIntShort(int, short) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareIntShort(int, short) builder (after)
+ /// CHECK-START: int TestCompare.compareIntShort(int, short) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareIntShort(int x, short y) {
return Integer.compare(x, y);
}
- /// CHECK-START: int Main.compareIntChar(int, char) builder (after)
+ /// CHECK-START: int TestCompare.compareIntChar(int, char) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareIntChar(int, char) builder (after)
+ /// CHECK-START: int TestCompare.compareIntChar(int, char) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareIntChar(int x, char y) {
@@ -296,7 +296,7 @@
}
- public static void testCompareBooleans() throws Exception {
+ public static void testCompareBooleans() {
expectEquals(-1, compareBooleans(false, true));
expectEquals(-1, compareBooleans2(false, true));
@@ -867,7 +867,7 @@
}
- public static void main(String args[]) throws Exception {
+ public static void main() {
$opt$noinline$testReplaceInputWithItself(42);
testCompareBooleans();
@@ -893,7 +893,7 @@
testCompareIntShort();
testCompareIntChar();
- System.out.println("passed");
+ System.out.println("TestCompare passed");
}
private static void expectEquals(int expected, int result) {
diff --git a/test/631-checker-fp-abs/src/Main.java b/test/567-checker-builder-intrinsics/src/TestFpAbs.java
similarity index 95%
rename from test/631-checker-fp-abs/src/Main.java
rename to test/567-checker-builder-intrinsics/src/TestFpAbs.java
index 6e0e6db..e6c338d 100644
--- a/test/631-checker-fp-abs/src/Main.java
+++ b/test/567-checker-builder-intrinsics/src/TestFpAbs.java
@@ -21,7 +21,7 @@
* we require that Math.abs() clears the sign bit (but changes nothing else)
* for all numbers, including NaN (signaling NaN may become quiet though).
*/
-public class Main {
+public class TestFpAbs {
private final static boolean isDalvik =
System.getProperty("java.vm.name").equals("Dalvik");
@@ -31,21 +31,21 @@
public static boolean doThrow = false;
- /// CHECK-START: float Main.$opt$noinline$absSP(float) builder (after)
+ /// CHECK-START: float TestFpAbs.$opt$noinline$absSP(float) builder (after)
/// CHECK-DAG: <<Result:f\d+>> Abs
/// CHECK-DAG: Return [<<Result>>]
private static float $opt$noinline$absSP(float f) {
return Math.abs(f);
}
- /// CHECK-START: double Main.$opt$noinline$absDP(double) builder (after)
+ /// CHECK-START: double TestFpAbs.$opt$noinline$absDP(double) builder (after)
/// CHECK-DAG: <<Result:d\d+>> Abs
/// CHECK-DAG: Return [<<Result>>]
private static double $opt$noinline$absDP(double d) {
return Math.abs(d);
}
- public static void main(String args[]) {
+ public static void main() {
// A few obvious numbers.
for (float f = -100.0f; f < 0.0f; f += 0.5f) {
expectEqualsSP(-f, $opt$noinline$absSP(f));
@@ -129,7 +129,7 @@
Double.doubleToRawLongBits($opt$noinline$absDP(d)));
}
- System.out.println("passed");
+ System.out.println("TestFpAbs passed");
}
private static void expectEquals32(int expected, int result) {
diff --git a/test/575-checker-isnan/src/Main.java b/test/567-checker-builder-intrinsics/src/TestIsNan.java
similarity index 90%
rename from test/575-checker-isnan/src/Main.java
rename to test/567-checker-builder-intrinsics/src/TestIsNan.java
index 4773f63..03b76d7 100644
--- a/test/575-checker-isnan/src/Main.java
+++ b/test/567-checker-builder-intrinsics/src/TestIsNan.java
@@ -14,29 +14,29 @@
* limitations under the License.
*/
-public class Main {
+public class TestIsNan {
- /// CHECK-START: boolean Main.isNaN32(float) builder (after)
+ /// CHECK-START: boolean TestIsNan.isNaN32(float) builder (after)
/// CHECK-DAG: <<Result:z\d+>> NotEqual
/// CHECK-DAG: Return [<<Result>>]
//
- /// CHECK-START: boolean Main.isNaN32(float) builder (after)
+ /// CHECK-START: boolean TestIsNan.isNaN32(float) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static boolean isNaN32(float x) {
return Float.isNaN(x);
}
- /// CHECK-START: boolean Main.isNaN64(double) builder (after)
+ /// CHECK-START: boolean TestIsNan.isNaN64(double) builder (after)
/// CHECK-DAG: <<Result:z\d+>> NotEqual
/// CHECK-DAG: Return [<<Result>>]
//
- /// CHECK-START: boolean Main.isNaN64(double) builder (after)
+ /// CHECK-START: boolean TestIsNan.isNaN64(double) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static boolean isNaN64(double x) {
return Double.isNaN(x);
}
- public static void main(String args[]) {
+ public static void main() {
// A few distinct numbers.
expectFalse(isNaN32(Float.NEGATIVE_INFINITY));
expectFalse(isNaN32(-1.0f));
@@ -101,7 +101,7 @@
expectTrue(isNaN64(dvals[i]));
}
- System.out.println("passed");
+ System.out.println("TestIsNan passed");
}
private static void expectTrue(boolean value) {
diff --git a/test/679-checker-minmax/src/Main.java b/test/567-checker-builder-intrinsics/src/TestMinMax.java
similarity index 76%
rename from test/679-checker-minmax/src/Main.java
rename to test/567-checker-builder-intrinsics/src/TestMinMax.java
index 0e13264..0e88517 100644
--- a/test/679-checker-minmax/src/Main.java
+++ b/test/567-checker-builder-intrinsics/src/TestMinMax.java
@@ -17,22 +17,22 @@
/**
* Functional tests for detecting min/max.
*/
-public class Main {
+public class TestMinMax {
//
// Direct intrinsics.
//
- /// CHECK-START: int Main.minI(int) builder (after)
+ /// CHECK-START: int TestMinMax.minI(int) builder (after)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<Con:i\d+>> IntConstant 20
/// CHECK-DAG: <<Min:i\d+>> Min [<<Par>>,<<Con>>]
/// CHECK-DAG: Return [<<Min>>]
//
- /// CHECK-START: int Main.minI(int) builder (after)
+ /// CHECK-START: int TestMinMax.minI(int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
//
- /// CHECK-START-ARM64: int Main.minI(int) disassembly (after)
+ /// CHECK-START-ARM64: int TestMinMax.minI(int) disassembly (after)
/// CHECK-NOT: mov {{w\d+}}, #0x14
/// CHECK: cmp {{w\d+}}, #0x14
// Check that the constant generation was handled by VIXL.
@@ -42,16 +42,16 @@
return Math.min(a, 20);
}
- /// CHECK-START: long Main.minL(long) builder (after)
+ /// CHECK-START: long TestMinMax.minL(long) builder (after)
/// CHECK-DAG: <<Par:j\d+>> ParameterValue
/// CHECK-DAG: <<Con:j\d+>> LongConstant 20
/// CHECK-DAG: <<Min:j\d+>> Min [<<Par>>,<<Con>>]
/// CHECK-DAG: Return [<<Min>>]
//
- /// CHECK-START: long Main.minL(long) builder (after)
+ /// CHECK-START: long TestMinMax.minL(long) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
//
- /// CHECK-START-ARM64: long Main.minL(long) disassembly (after)
+ /// CHECK-START-ARM64: long TestMinMax.minL(long) disassembly (after)
/// CHECK-NOT: mov {{x\d+}}, #0x14
/// CHECK: cmp {{x\d+}}, #0x14
// Check that the constant generation was handled by VIXL.
@@ -61,16 +61,16 @@
return Math.min(a, 20L);
}
- /// CHECK-START: int Main.maxI(int) builder (after)
+ /// CHECK-START: int TestMinMax.maxI(int) builder (after)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<Con:i\d+>> IntConstant 20
/// CHECK-DAG: <<Max:i\d+>> Max [<<Par>>,<<Con>>]
/// CHECK-DAG: Return [<<Max>>]
//
- /// CHECK-START: int Main.maxI(int) builder (after)
+ /// CHECK-START: int TestMinMax.maxI(int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
//
- /// CHECK-START-ARM64: int Main.maxI(int) disassembly (after)
+ /// CHECK-START-ARM64: int TestMinMax.maxI(int) disassembly (after)
/// CHECK-NOT: mov {{w\d+}}, #0x14
/// CHECK: cmp {{w\d+}}, #0x14
// Check that the constant generation was handled by VIXL.
@@ -80,16 +80,16 @@
return Math.max(a, 20);
}
- /// CHECK-START: long Main.maxL(long) builder (after)
+ /// CHECK-START: long TestMinMax.maxL(long) builder (after)
/// CHECK-DAG: <<Par:j\d+>> ParameterValue
/// CHECK-DAG: <<Con:j\d+>> LongConstant 20
/// CHECK-DAG: <<Max:j\d+>> Max [<<Par>>,<<Con>>]
/// CHECK-DAG: Return [<<Max>>]
//
- /// CHECK-START: long Main.maxL(long) builder (after)
+ /// CHECK-START: long TestMinMax.maxL(long) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
//
- /// CHECK-START-ARM64: long Main.maxL(long) disassembly (after)
+ /// CHECK-START-ARM64: long TestMinMax.maxL(long) disassembly (after)
/// CHECK-NOT: mov {{x\d+}}, #0x14
/// CHECK: cmp {{x\d+}}, #0x14
// Check that the constant generation was handled by VIXL.
@@ -103,7 +103,7 @@
// Special Cases
//
- /// CHECK-START-ARM64: int Main.minIntConstantZero(int) disassembly (after)
+ /// CHECK-START-ARM64: int TestMinMax.minIntConstantZero(int) disassembly (after)
/// CHECK-NOT: InvokeStaticOrDirect
/// CHECK-NOT: mov {{w\d+}}, #0x0
/// CHECK: cmp {{w\d+}}, #0x0 (0)
@@ -113,7 +113,7 @@
return Math.min(a, 0);
}
- /// CHECK-START-ARM64: int Main.minIntConstantOne(int) disassembly (after)
+ /// CHECK-START-ARM64: int TestMinMax.minIntConstantOne(int) disassembly (after)
/// CHECK-NOT: InvokeStaticOrDirect
/// CHECK-NOT: mov {{w\d+}}, #0x1
/// CHECK: cmp {{w\d+}}, #0x1 (1)
@@ -123,7 +123,7 @@
return Math.min(a, 1);
}
- /// CHECK-START-ARM64: int Main.minIntConstantMinusOne(int) disassembly (after)
+ /// CHECK-START-ARM64: int TestMinMax.minIntConstantMinusOne(int) disassembly (after)
/// CHECK-NOT: InvokeStaticOrDirect
/// CHECK-NOT: mov {{w\d+}}, #0xffffffff
/// CHECK: cmn {{w\d+}}, #0x1 (1)
@@ -133,7 +133,7 @@
return Math.min(a, -1);
}
- /// CHECK-START-ARM64: long Main.minLongConstantZero(long) disassembly (after)
+ /// CHECK-START-ARM64: long TestMinMax.minLongConstantZero(long) disassembly (after)
/// CHECK-NOT: InvokeStaticOrDirect
/// CHECK-NOT: mov {{x\d+}}, #0x0
/// CHECK: cmp {{x\d+}}, #0x0 (0)
@@ -143,7 +143,7 @@
return Math.min(a, 0L);
}
- /// CHECK-START-ARM64: long Main.minLongConstantOne(long) disassembly (after)
+ /// CHECK-START-ARM64: long TestMinMax.minLongConstantOne(long) disassembly (after)
/// CHECK-NOT: InvokeStaticOrDirect
/// CHECK-NOT: mov {{x\d+}}, #0x1
/// CHECK: cmp {{x\d+}}, #0x1 (1)
@@ -153,7 +153,7 @@
return Math.min(a, 1L);
}
- /// CHECK-START-ARM64: long Main.minLongConstantMinusOne(long) disassembly (after)
+ /// CHECK-START-ARM64: long TestMinMax.minLongConstantMinusOne(long) disassembly (after)
/// CHECK-NOT: InvokeStaticOrDirect
/// CHECK-NOT: mov {{x\d+}}, #0xffffffffffffffff
/// CHECK: cmn {{x\d+}}, #0x1 (1)
@@ -163,7 +163,7 @@
return Math.min(a, -1L);
}
- /// CHECK-START-ARM64: int Main.maxIntConstantZero(int) disassembly (after)
+ /// CHECK-START-ARM64: int TestMinMax.maxIntConstantZero(int) disassembly (after)
/// CHECK-NOT: InvokeStaticOrDirect
/// CHECK-NOT: mov {{w\d+}}, #0x0
/// CHECK: cmp {{w\d+}}, #0x0 (0)
@@ -173,7 +173,7 @@
return Math.max(a, 0);
}
- /// CHECK-START-ARM64: int Main.maxIntConstantOne(int) disassembly (after)
+ /// CHECK-START-ARM64: int TestMinMax.maxIntConstantOne(int) disassembly (after)
/// CHECK-NOT: InvokeStaticOrDirect
/// CHECK-NOT: mov {{w\d+}}, #0x1
/// CHECK: cmp {{w\d+}}, #0x1 (1)
@@ -183,7 +183,7 @@
return Math.max(a, 1);
}
- /// CHECK-START-ARM64: int Main.maxIntConstantMinusOne(int) disassembly (after)
+ /// CHECK-START-ARM64: int TestMinMax.maxIntConstantMinusOne(int) disassembly (after)
/// CHECK-NOT: InvokeStaticOrDirect
/// CHECK-NOT: mov {{w\d+}}, #0xffffffff
/// CHECK: cmn {{w\d+}}, #0x1 (1)
@@ -193,7 +193,7 @@
return Math.max(a, -1);
}
- /// CHECK-START-ARM64: int Main.maxIntLargeConstant(int) disassembly (after)
+ /// CHECK-START-ARM64: int TestMinMax.maxIntLargeConstant(int) disassembly (after)
/// CHECK-NOT: InvokeStaticOrDirect
/// CHECK: mov {{w\d+}}, #0x2001
/// CHECK: cmp {{w\d+}}, {{w\d+}}
@@ -205,7 +205,7 @@
return Math.max(a, 8193);
}
- /// CHECK-START-ARM64: long Main.maxLongConstantZero(long) disassembly (after)
+ /// CHECK-START-ARM64: long TestMinMax.maxLongConstantZero(long) disassembly (after)
/// CHECK-NOT: InvokeStaticOrDirect
/// CHECK-NOT: mov {{x\d+}}, #0x0
/// CHECK: cmp {{x\d+}}, #0x0 (0)
@@ -215,7 +215,7 @@
return Math.max(a, 0L);
}
- /// CHECK-START-ARM64: long Main.maxLongConstantOne(long) disassembly (after)
+ /// CHECK-START-ARM64: long TestMinMax.maxLongConstantOne(long) disassembly (after)
/// CHECK-NOT: InvokeStaticOrDirect
/// CHECK-NOT: mov {{x\d+}}, #0x1
/// CHECK: cmp {{x\d+}}, #0x1 (1)
@@ -225,7 +225,7 @@
return Math.max(a, 1L);
}
- /// CHECK-START-ARM64: long Main.maxLongConstantMinusOne(long) disassembly (after)
+ /// CHECK-START-ARM64: long TestMinMax.maxLongConstantMinusOne(long) disassembly (after)
/// CHECK-NOT: InvokeStaticOrDirect
/// CHECK-NOT: mov {{x\d+}}, #0xffffffffffffffff
/// CHECK: cmn {{x\d+}}, #0x1 (1)
@@ -235,7 +235,7 @@
return Math.max(a, -1L);
}
- /// CHECK-START-ARM64: long Main.maxLongLargeConstant(long) disassembly (after)
+ /// CHECK-START-ARM64: long TestMinMax.maxLongLargeConstant(long) disassembly (after)
/// CHECK-NOT: InvokeStaticOrDirect
/// CHECK: mov {{x\d+}}, #0x2001
/// CHECK: cmp {{x\d+}}, {{x\d+}}
@@ -251,211 +251,211 @@
// Different types.
//
- /// CHECK-START: int Main.min1(int, int) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestMinMax.min1(int, int) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Cnd:z\d+>> GreaterThanOrEqual [<<Op1:i\d+>>,<<Op2:i\d+>>]
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.min1(int, int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.min1(int, int) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Min:i\d+>> Min
/// CHECK-DAG: Return [<<Min>>]
//
- /// CHECK-START: int Main.min1(int, int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.min1(int, int) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int min1(int a, int b) {
return a < b ? a : b;
}
- /// CHECK-START: int Main.min2(int, int) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestMinMax.min2(int, int) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Cnd:z\d+>> GreaterThan [<<Op1:i\d+>>,<<Op2:i\d+>>]
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.min2(int, int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.min2(int, int) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Min:i\d+>> Min
/// CHECK-DAG: Return [<<Min>>]
//
- /// CHECK-START: int Main.min2(int, int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.min2(int, int) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int min2(int a, int b) {
return a <= b ? a : b;
}
- /// CHECK-START: int Main.min3(int, int) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestMinMax.min3(int, int) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Cnd:z\d+>> LessThanOrEqual [<<Op1:i\d+>>,<<Op2:i\d+>>]
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.min3(int, int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.min3(int, int) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Min:i\d+>> Min
/// CHECK-DAG: Return [<<Min>>]
//
- /// CHECK-START: int Main.min3(int, int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.min3(int, int) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int min3(int a, int b) {
return a > b ? b : a;
}
- /// CHECK-START: int Main.min4(int, int) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestMinMax.min4(int, int) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:i\d+>>,<<Op2:i\d+>>]
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.min4(int, int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.min4(int, int) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Min:i\d+>> Min
/// CHECK-DAG: Return [<<Min>>]
//
- /// CHECK-START: int Main.min4(int, int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.min4(int, int) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int min4(int a, int b) {
return a >= b ? b : a;
}
- /// CHECK-START: int Main.min5(short, short) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestMinMax.min5(short, short) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:s\d+>>,<<Op2:s\d+>>]
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.min5(short, short) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.min5(short, short) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Min:i\d+>> Min
/// CHECK-DAG: Return [<<Min>>]
//
- /// CHECK-START: int Main.min5(short, short) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.min5(short, short) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int min5(short a, short b) {
return a >= b ? b : a;
}
- /// CHECK-START: int Main.min6(byte, byte) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestMinMax.min6(byte, byte) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:b\d+>>,<<Op2:b\d+>>]
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.min6(byte, byte) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.min6(byte, byte) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Min:i\d+>> Min
/// CHECK-DAG: Return [<<Min>>]
//
- /// CHECK-START: int Main.min6(byte, byte) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.min6(byte, byte) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int min6(byte a, byte b) {
return a >= b ? b : a;
}
- /// CHECK-START: long Main.min7(long, long) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: long TestMinMax.min7(long, long) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:j\d+>>,<<Op2:j\d+>>]
/// CHECK-DAG: <<Sel:j\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: long Main.min7(long, long) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: long TestMinMax.min7(long, long) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Min:j\d+>> Min
/// CHECK-DAG: Return [<<Min>>]
//
- /// CHECK-START: long Main.min7(long, long) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: long TestMinMax.min7(long, long) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static long min7(long a, long b) {
return a >= b ? b : a;
}
- /// CHECK-START: int Main.max1(int, int) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestMinMax.max1(int, int) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Cnd:z\d+>> GreaterThanOrEqual [<<Op1:i\d+>>,<<Op2:i\d+>>]
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.max1(int, int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.max1(int, int) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Max:i\d+>> Max
/// CHECK-DAG: Return [<<Max>>]
//
- /// CHECK-START: int Main.max1(int, int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.max1(int, int) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int max1(int a, int b) {
return a < b ? b : a;
}
- /// CHECK-START: int Main.max2(int, int) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestMinMax.max2(int, int) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Cnd:z\d+>> GreaterThan [<<Op1:i\d+>>,<<Op2:i\d+>>]
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.max2(int, int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.max2(int, int) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Max:i\d+>> Max
/// CHECK-DAG: Return [<<Max>>]
//
- /// CHECK-START: int Main.max2(int, int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.max2(int, int) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int max2(int a, int b) {
return a <= b ? b : a;
}
- /// CHECK-START: int Main.max3(int, int) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestMinMax.max3(int, int) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Cnd:z\d+>> LessThanOrEqual [<<Op1:i\d+>>,<<Op2:i\d+>>]
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.max3(int, int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.max3(int, int) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Max:i\d+>> Max
/// CHECK-DAG: Return [<<Max>>]
//
- /// CHECK-START: int Main.max3(int, int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.max3(int, int) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int max3(int a, int b) {
return a > b ? a : b;
}
- /// CHECK-START: int Main.max4(int, int) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestMinMax.max4(int, int) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:i\d+>>,<<Op2:i\d+>>]
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.max4(int, int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.max4(int, int) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Max:i\d+>> Max
/// CHECK-DAG: Return [<<Max>>]
//
- /// CHECK-START: int Main.max4(int, int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.max4(int, int) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int max4(int a, int b) {
return a >= b ? a : b;
}
- /// CHECK-START: int Main.max5(short, short) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestMinMax.max5(short, short) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:s\d+>>,<<Op2:s\d+>>]
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.max5(short, short) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.max5(short, short) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Max:i\d+>> Max
/// CHECK-DAG: Return [<<Max>>]
//
- /// CHECK-START: int Main.max5(short, short) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.max5(short, short) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int max5(short a, short b) {
return a >= b ? a : b;
}
- /// CHECK-START: int Main.max6(byte, byte) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestMinMax.max6(byte, byte) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:b\d+>>,<<Op2:b\d+>>]
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.max6(byte, byte) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.max6(byte, byte) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Max:i\d+>> Max
/// CHECK-DAG: Return [<<Max>>]
//
- /// CHECK-START: int Main.max6(byte, byte) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.max6(byte, byte) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int max6(byte a, byte b) {
return a >= b ? a : b;
}
- /// CHECK-START: long Main.max7(long, long) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: long TestMinMax.max7(long, long) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:j\d+>>,<<Op2:j\d+>>]
/// CHECK-DAG: <<Sel:j\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: long Main.max7(long, long) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: long TestMinMax.max7(long, long) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Max:j\d+>> Max
/// CHECK-DAG: Return [<<Max>>]
//
- /// CHECK-START: long Main.max7(long, long) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: long TestMinMax.max7(long, long) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static long max7(long a, long b) {
return a >= b ? a : b;
@@ -465,18 +465,18 @@
// Complications.
//
- /// CHECK-START: int Main.min0(int[], int[]) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestMinMax.min0(int[], int[]) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Ar1:i\d+>> ArrayGet [{{l\d+}},{{i\d+}}]
/// CHECK-DAG: <<Ar2:i\d+>> ArrayGet [{{l\d+}},{{i\d+}}]
/// CHECK-DAG: <<Cnd:z\d+>> GreaterThan [<<Ar1>>,<<Ar2>>]
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Ar1>>,<<Ar2>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.min0(int[], int[]) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.min0(int[], int[]) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Min:i\d+>> Min
/// CHECK-DAG: Return [<<Min>>]
//
- /// CHECK-START: int Main.min0(int[], int[]) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.min0(int[], int[]) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int min0(int[] a, int[] b) {
// Repeat of array references needs finding the common subexpressions
@@ -484,18 +484,18 @@
return a[0] <= b[0] ? a[0] : b[0];
}
- /// CHECK-START: int Main.max0(int[], int[]) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestMinMax.max0(int[], int[]) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Ar1:i\d+>> ArrayGet [{{l\d+}},{{i\d+}}]
/// CHECK-DAG: <<Ar2:i\d+>> ArrayGet [{{l\d+}},{{i\d+}}]
/// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Ar1>>,<<Ar2>>]
/// CHECK-DAG: <<Sel:i\d+>> Select [<<Ar1>>,<<Ar2>>,<<Cnd>>]
/// CHECK-DAG: Return [<<Sel>>]
//
- /// CHECK-START: int Main.max0(int[], int[]) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.max0(int[], int[]) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Max:i\d+>> Max
/// CHECK-DAG: Return [<<Max>>]
//
- /// CHECK-START: int Main.max0(int[], int[]) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.max0(int[], int[]) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int max0(int[] a, int[] b) {
// Repeat of array references needs finding the common subexpressions
@@ -503,7 +503,7 @@
return a[0] >= b[0] ? a[0] : b[0];
}
- /// CHECK-START: int Main.minmax1(int) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestMinMax.minmax1(int) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<P100:i\d+>> IntConstant 100
/// CHECK-DAG: <<M100:i\d+>> IntConstant -100
@@ -513,7 +513,7 @@
/// CHECK-DAG: <<Sel2:i\d+>> Select [<<M100>>,<<Sel1>>,<<Cnd2>>]
/// CHECK-DAG: Return [<<Sel2>>]
//
- /// CHECK-START: int Main.minmax1(int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.minmax1(int) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<P100:i\d+>> IntConstant 100
/// CHECK-DAG: <<M100:i\d+>> IntConstant -100
@@ -521,7 +521,7 @@
/// CHECK-DAG: <<Max:i\d+>> Max [<<Min>>,<<M100>>]
/// CHECK-DAG: Return [<<Max>>]
//
- /// CHECK-START: int Main.minmax1(int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.minmax1(int) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int minmax1(int x) {
// Simple if-if gives clean select sequence.
@@ -534,7 +534,7 @@
return x;
}
- /// CHECK-START: int Main.minmax2(int) instruction_simplifier$after_gvn (before)
+ /// CHECK-START: int TestMinMax.minmax2(int) instruction_simplifier$after_gvn (before)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<P100:i\d+>> IntConstant 100
/// CHECK-DAG: <<M100:i\d+>> IntConstant -100
@@ -544,7 +544,7 @@
/// CHECK-DAG: <<Sel2:i\d+>> Select [<<P100>>,<<Sel1>>,<<Cnd1>>]
/// CHECK-DAG: Return [<<Sel2>>]
//
- /// CHECK-START: int Main.minmax2(int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.minmax2(int) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<P100:i\d+>> IntConstant 100
/// CHECK-DAG: <<M100:i\d+>> IntConstant -100
@@ -552,7 +552,7 @@
/// CHECK-DAG: <<Min:i\d+>> Min [<<Max>>,<<P100>>]
/// CHECK-DAG: Return [<<Min>>]
//
- /// CHECK-START: int Main.minmax2(int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.minmax2(int) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int minmax2(int x) {
// Simple if-else requires inspecting bounds of resulting selects.
@@ -564,7 +564,7 @@
return x;
}
- /// CHECK-START: int Main.minmax3(int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.minmax3(int) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<P100:i\d+>> IntConstant 100
/// CHECK-DAG: <<M100:i\d+>> IntConstant -100
@@ -572,13 +572,13 @@
/// CHECK-DAG: <<Min:i\d+>> Min [<<Max>>,<<P100>>]
/// CHECK-DAG: Return [<<Min>>]
//
- /// CHECK-START: int Main.minmax3(int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.minmax3(int) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int minmax3(int x) {
return (x > 100) ? 100 : ((x < -100) ? -100 : x);
}
- /// CHECK-START: int Main.minmax4(int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.minmax4(int) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<P100:i\d+>> IntConstant 100
/// CHECK-DAG: <<M100:i\d+>> IntConstant -100
@@ -586,13 +586,13 @@
/// CHECK-DAG: <<Max:i\d+>> Max [<<Min>>,<<M100>>]
/// CHECK-DAG: Return [<<Max>>]
//
- /// CHECK-START: int Main.minmax4(int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.minmax4(int) instruction_simplifier$after_gvn (after)
/// CHECK-NOT: Select
public static int minmax4(int x) {
return (x < -100) ? -100 : ((x > 100) ? 100 : x);
}
- /// CHECK-START: int Main.minmaxCSEScalar(int, int) select_generator (after)
+ /// CHECK-START: int TestMinMax.minmaxCSEScalar(int, int) select_generator (after)
/// CHECK-DAG: <<Par1:i\d+>> ParameterValue
/// CHECK-DAG: <<Par2:i\d+>> ParameterValue
/// CHECK-DAG: <<Cnd1:z\d+>> LessThanOrEqual [<<Par1>>,<<Par2>>]
@@ -606,7 +606,7 @@
/// CHECK-DAG: <<Add5:i\d+>> Add [<<Sel2>>,<<Add4>>]
/// CHECK-DAG: Return [<<Add5>>]
//
- /// CHECK-START: int Main.minmaxCSEScalar(int, int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.minmaxCSEScalar(int, int) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Par1:i\d+>> ParameterValue
/// CHECK-DAG: <<Par2:i\d+>> ParameterValue
/// CHECK-DAG: <<Max:i\d+>> Max [<<Par1>>,<<Par2>>]
@@ -628,7 +628,7 @@
return t1 + t2 + t3 + t4 + t5 + t6;
}
- /// CHECK-START: int Main.minmaxCSEArray(int[], int[]) select_generator (after)
+ /// CHECK-START: int TestMinMax.minmaxCSEArray(int[], int[]) select_generator (after)
/// CHECK-DAG: <<Arr1:i\d+>> ArrayGet
/// CHECK-DAG: <<Arr2:i\d+>> ArrayGet
/// CHECK-DAG: <<Cnd1:z\d+>> LessThanOrEqual [<<Arr1>>,<<Arr2>>]
@@ -642,7 +642,7 @@
/// CHECK-DAG: <<Add5:i\d+>> Add [<<Sel2>>,<<Add4>>]
/// CHECK-DAG: Return [<<Add5>>]
//
- /// CHECK-START: int Main.minmaxCSEArray(int[], int[]) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.minmaxCSEArray(int[], int[]) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Arr1:i\d+>> ArrayGet
/// CHECK-DAG: <<Arr2:i\d+>> ArrayGet
/// CHECK-DAG: <<Max:i\d+>> Max [<<Arr1>>,<<Arr2>>]
@@ -664,7 +664,7 @@
return t1 + t2 + t3 + t4 + t5 + t6;
}
- /// CHECK-START: int Main.minmaxCSEScalarAndCond(int, int) instruction_simplifier$after_gvn (after)
+ /// CHECK-START: int TestMinMax.minmaxCSEScalarAndCond(int, int) instruction_simplifier$after_gvn (after)
/// CHECK-DAG: <<Par1:i\d+>> ParameterValue
/// CHECK-DAG: <<Par2:i\d+>> ParameterValue
/// CHECK-DAG: <<Max:i\d+>> Max [<<Par1>>,<<Par2>>]
@@ -686,7 +686,7 @@
return t1 + t2 + t3 + t4;
}
- public static void main(String[] args) {
+ public static void main() {
// Intrinsics.
expectEquals(10, minI(10));
expectEquals(20, minI(25));
@@ -760,7 +760,7 @@
expectEquals(90, minmaxCSEArray(a, b));
expectEquals(20, minmaxCSEScalarAndCond(10, 10));
expectEquals(60, minmaxCSEScalarAndCond(10, 20));
- System.out.println("passed");
+ System.out.println("TestMinMax passed");
}
private static void expectEquals(int expected, int result) {
diff --git a/test/565-checker-rotate/src-art/Main.java b/test/567-checker-builder-intrinsics/src/TestRotate.java
similarity index 87%
rename from test/565-checker-rotate/src-art/Main.java
rename to test/567-checker-builder-intrinsics/src/TestRotate.java
index 6efb210..0593e60 100644
--- a/test/565-checker-rotate/src-art/Main.java
+++ b/test/567-checker-builder-intrinsics/src/TestRotate.java
@@ -14,137 +14,137 @@
* limitations under the License.
*/
-public class Main {
+public class TestRotate {
- /// CHECK-START: int Main.rotateLeftByte(byte, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateLeftByte(byte, int) builder (after)
/// CHECK: <<ArgVal:b\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<NegDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateLeftByte(byte, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateLeftByte(byte, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateLeftByte(byte value, int distance) {
return Integer.rotateLeft(value, distance);
}
- /// CHECK-START: int Main.rotateLeftShort(short, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateLeftShort(short, int) builder (after)
/// CHECK: <<ArgVal:s\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<NegDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateLeftShort(short, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateLeftShort(short, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateLeftShort(short value, int distance) {
return Integer.rotateLeft(value, distance);
}
- /// CHECK-START: int Main.rotateLeftChar(char, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateLeftChar(char, int) builder (after)
/// CHECK: <<ArgVal:c\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<NegDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateLeftChar(char, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateLeftChar(char, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateLeftChar(char value, int distance) {
return Integer.rotateLeft(value, distance);
}
- /// CHECK-START: int Main.rotateLeftInt(int, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateLeftInt(int, int) builder (after)
/// CHECK: <<ArgVal:i\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<NegDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateLeftInt(int, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateLeftInt(int, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateLeftInt(int value, int distance) {
return Integer.rotateLeft(value, distance);
}
- /// CHECK-START: long Main.rotateLeftLong(long, int) builder (after)
+ /// CHECK-START: long TestRotate.rotateLeftLong(long, int) builder (after)
/// CHECK: <<ArgVal:j\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
/// CHECK-DAG: <<Result:j\d+>> Ror [<<ArgVal>>,<<NegDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: long Main.rotateLeftLong(long, int) builder (after)
+ /// CHECK-START: long TestRotate.rotateLeftLong(long, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static long rotateLeftLong(long value, int distance) {
return Long.rotateLeft(value, distance);
}
- /// CHECK-START: int Main.rotateRightByte(byte, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateRightByte(byte, int) builder (after)
/// CHECK: <<ArgVal:b\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateRightByte(byte, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateRightByte(byte, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateRightByte(byte value, int distance) {
return Integer.rotateRight(value, distance);
}
- /// CHECK-START: int Main.rotateRightShort(short, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateRightShort(short, int) builder (after)
/// CHECK: <<ArgVal:s\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateRightShort(short, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateRightShort(short, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateRightShort(short value, int distance) {
return Integer.rotateRight(value, distance);
}
- /// CHECK-START: int Main.rotateRightChar(char, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateRightChar(char, int) builder (after)
/// CHECK: <<ArgVal:c\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateRightChar(char, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateRightChar(char, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateRightChar(char value, int distance) {
return Integer.rotateRight(value, distance);
}
- /// CHECK-START: int Main.rotateRightInt(int, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateRightInt(int, int) builder (after)
/// CHECK: <<ArgVal:i\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateRightInt(int, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateRightInt(int, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateRightInt(int value, int distance) {
return Integer.rotateRight(value, distance);
}
- /// CHECK-START: long Main.rotateRightLong(long, int) builder (after)
+ /// CHECK-START: long TestRotate.rotateRightLong(long, int) builder (after)
/// CHECK: <<ArgVal:j\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<Result:j\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: long Main.rotateRightLong(long, int) builder (after)
+ /// CHECK-START: long TestRotate.rotateRightLong(long, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static long rotateRightLong(long value, int distance) {
@@ -152,34 +152,34 @@
}
- /// CHECK-START: int Main.rotateLeftIntWithByteDistance(int, byte) builder (after)
+ /// CHECK-START: int TestRotate.rotateLeftIntWithByteDistance(int, byte) builder (after)
/// CHECK: <<ArgVal:i\d+>> ParameterValue
/// CHECK: <<ArgDist:b\d+>> ParameterValue
/// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<NegDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateLeftIntWithByteDistance(int, byte) builder (after)
+ /// CHECK-START: int TestRotate.rotateLeftIntWithByteDistance(int, byte) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateLeftIntWithByteDistance(int value, byte distance) {
return Integer.rotateLeft(value, distance);
}
- /// CHECK-START: int Main.rotateRightIntWithByteDistance(int, byte) builder (after)
+ /// CHECK-START: int TestRotate.rotateRightIntWithByteDistance(int, byte) builder (after)
/// CHECK: <<ArgVal:i\d+>> ParameterValue
/// CHECK: <<ArgDist:b\d+>> ParameterValue
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateRightIntWithByteDistance(int, byte) builder (after)
+ /// CHECK-START: int TestRotate.rotateRightIntWithByteDistance(int, byte) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateRightIntWithByteDistance(int value, byte distance) {
return Integer.rotateRight(value, distance);
}
- /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateLeftBoolean(boolean, int) builder (after)
/// CHECK: <<ArgVal:z\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
@@ -189,10 +189,10 @@
/// CHECK-DAG: <<Result:i\d+>> Ror [<<Val>>,<<NegDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateLeftBoolean(boolean, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
- /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) select_generator (after)
+ /// CHECK-START: int TestRotate.rotateLeftBoolean(boolean, int) select_generator (after)
/// CHECK: <<ArgVal:z\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
@@ -202,17 +202,17 @@
/// CHECK-DAG: <<Result:i\d+>> Ror [<<SelVal>>,<<NegDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) select_generator (after)
+ /// CHECK-START: int TestRotate.rotateLeftBoolean(boolean, int) select_generator (after)
/// CHECK-NOT: Phi
- /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) instruction_simplifier$after_bce (after)
+ /// CHECK-START: int TestRotate.rotateLeftBoolean(boolean, int) instruction_simplifier$after_bce (after)
/// CHECK: <<ArgVal:z\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<NegDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) instruction_simplifier$after_bce (after)
+ /// CHECK-START: int TestRotate.rotateLeftBoolean(boolean, int) instruction_simplifier$after_bce (after)
/// CHECK-NOT: Select
private static int rotateLeftBoolean(boolean value, int distance) {
@@ -227,7 +227,7 @@
return Integer.rotateLeft(src, distance);
}
- public static void testRotateLeftBoolean() throws Exception {
+ public static void testRotateLeftBoolean() {
for (int i = 0; i < 40; i++) { // overshoot a bit
int j = i & 31;
expectEqualsInt(0, rotateLeftBoolean(false, i));
@@ -326,7 +326,7 @@
}
}
- /// CHECK-START: int Main.rotateRightBoolean(boolean, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateRightBoolean(boolean, int) builder (after)
/// CHECK: <<ArgVal:z\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
@@ -335,10 +335,10 @@
/// CHECK-DAG: <<Result:i\d+>> Ror [<<Val>>,<<ArgDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateRightBoolean(boolean, int) builder (after)
+ /// CHECK-START: int TestRotate.rotateRightBoolean(boolean, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
- /// CHECK-START: int Main.rotateRightBoolean(boolean, int) select_generator (after)
+ /// CHECK-START: int TestRotate.rotateRightBoolean(boolean, int) select_generator (after)
/// CHECK: <<ArgVal:z\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
@@ -347,16 +347,16 @@
/// CHECK-DAG: <<Result:i\d+>> Ror [<<SelVal>>,<<ArgDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateRightBoolean(boolean, int) select_generator (after)
+ /// CHECK-START: int TestRotate.rotateRightBoolean(boolean, int) select_generator (after)
/// CHECK-NOT: Phi
- /// CHECK-START: int Main.rotateRightBoolean(boolean, int) instruction_simplifier$after_bce (after)
+ /// CHECK-START: int TestRotate.rotateRightBoolean(boolean, int) instruction_simplifier$after_bce (after)
/// CHECK: <<ArgVal:z\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateRightBoolean(boolean, int) instruction_simplifier$after_bce (after)
+ /// CHECK-START: int TestRotate.rotateRightBoolean(boolean, int) instruction_simplifier$after_bce (after)
/// CHECK-NOT: Select
private static int rotateRightBoolean(boolean value, int distance) {
@@ -371,7 +371,7 @@
return Integer.rotateRight(src, distance);
}
- public static void testRotateRightBoolean() throws Exception {
+ public static void testRotateRightBoolean() {
for (int i = 0; i < 40; i++) { // overshoot a bit
int j = (-i) & 31;
expectEqualsInt(0, rotateRightBoolean(false, i));
@@ -509,7 +509,7 @@
}
- public static void main(String args[]) throws Exception {
+ public static void main() {
testRotateLeftBoolean();
testRotateLeftByte();
testRotateLeftShort();
@@ -528,7 +528,7 @@
testRotateLeftIntWithByteDistance();
testRotateRightIntWithByteDistance();
- System.out.println("passed");
+ System.out.println("TestRotate passed");
}
diff --git a/test/566-checker-signum/src-art/Main.java b/test/567-checker-builder-intrinsics/src/TestSignum.java
similarity index 81%
rename from test/566-checker-signum/src-art/Main.java
rename to test/567-checker-builder-intrinsics/src/TestSignum.java
index 8fec4de..0a68ac2 100644
--- a/test/566-checker-signum/src-art/Main.java
+++ b/test/567-checker-builder-intrinsics/src/TestSignum.java
@@ -14,74 +14,74 @@
* limitations under the License.
*/
-public class Main {
+public class TestSignum {
- /// CHECK-START: int Main.signByte(byte) builder (after)
+ /// CHECK-START: int TestSignum.signByte(byte) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.signByte(byte) builder (after)
+ /// CHECK-START: int TestSignum.signByte(byte) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int signByte(byte x) {
return Integer.signum(x);
}
- /// CHECK-START: int Main.signShort(short) builder (after)
+ /// CHECK-START: int TestSignum.signShort(short) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.signShort(short) builder (after)
+ /// CHECK-START: int TestSignum.signShort(short) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int signShort(short x) {
return Integer.signum(x);
}
- /// CHECK-START: int Main.signChar(char) builder (after)
+ /// CHECK-START: int TestSignum.signChar(char) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.signChar(char) builder (after)
+ /// CHECK-START: int TestSignum.signChar(char) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int signChar(char x) {
return Integer.signum(x);
}
- /// CHECK-START: int Main.signInt(int) builder (after)
+ /// CHECK-START: int TestSignum.signInt(int) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.signInt(int) builder (after)
+ /// CHECK-START: int TestSignum.signInt(int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int signInt(int x) {
return Integer.signum(x);
}
- /// CHECK-START: int Main.signLong(long) builder (after)
+ /// CHECK-START: int TestSignum.signLong(long) builder (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.signLong(long) builder (after)
+ /// CHECK-START: int TestSignum.signLong(long) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int signLong(long x) {
return Long.signum(x);
}
- /// CHECK-START: int Main.signBoolean(boolean) builder (after)
+ /// CHECK-START: int TestSignum.signBoolean(boolean) builder (after)
/// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
/// CHECK-DAG: <<One:i\d+>> IntConstant 1
/// CHECK-DAG: <<Phi:i\d+>> Phi [<<One>>,<<Zero>>]
/// CHECK-DAG: <<Result:i\d+>> Compare [<<Phi>>,<<Zero>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.signBoolean(boolean) builder (after)
+ /// CHECK-START: int TestSignum.signBoolean(boolean) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
- /// CHECK-START: int Main.signBoolean(boolean) select_generator (after)
+ /// CHECK-START: int TestSignum.signBoolean(boolean) select_generator (after)
/// CHECK-DAG: <<Arg:z\d+>> ParameterValue
/// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
/// CHECK-DAG: <<One:i\d+>> IntConstant 1
@@ -89,16 +89,16 @@
/// CHECK-DAG: <<Result:i\d+>> Compare [<<Sel>>,<<Zero>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.signBoolean(boolean) select_generator (after)
+ /// CHECK-START: int TestSignum.signBoolean(boolean) select_generator (after)
/// CHECK-NOT: Phi
- /// CHECK-START: int Main.signBoolean(boolean) instruction_simplifier$after_bce (after)
+ /// CHECK-START: int TestSignum.signBoolean(boolean) instruction_simplifier$after_bce (after)
/// CHECK-DAG: <<Arg:z\d+>> ParameterValue
/// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
/// CHECK-DAG: <<Result:i\d+>> Compare [<<Arg>>,<<Zero>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.signBoolean(boolean) instruction_simplifier$after_bce (after)
+ /// CHECK-START: int TestSignum.signBoolean(boolean) instruction_simplifier$after_bce (after)
/// CHECK-NOT: Select
private static int signBoolean(boolean x) {
@@ -113,7 +113,7 @@
return Integer.signum(src_x);
}
- public static void testSignBoolean() throws Exception {
+ public static void testSignBoolean() {
expectEquals(0, signBoolean(false));
expectEquals(1, signBoolean(true));
}
@@ -195,7 +195,7 @@
}
- public static void main(String args[]) throws Exception {
+ public static void main() {
testSignBoolean();
testSignByte();
testSignShort();
@@ -203,7 +203,7 @@
testSignInt();
testSignLong();
- System.out.println("passed");
+ System.out.println("TestSignum passed");
}
private static void expectEquals(int expected, int result) {
diff --git a/test/709-checker-varhandles/src/Main.java b/test/567-checker-builder-intrinsics/src/TestVarHandles.java
similarity index 69%
rename from test/709-checker-varhandles/src/Main.java
rename to test/567-checker-builder-intrinsics/src/TestVarHandles.java
index 8bb0434..2a82c06 100644
--- a/test/709-checker-varhandles/src/Main.java
+++ b/test/567-checker-builder-intrinsics/src/TestVarHandles.java
@@ -22,52 +22,52 @@
* Instead, this test ensures the methods are recognized as intrinsic and behave
* as expected.
*/
-public class Main {
+public class TestVarHandles {
//
// Fences (native).
//
- /// CHECK-START: void Main.fullFence() builder (after)
+ /// CHECK-START: void TestVarHandles.fullFence() builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
//
- /// CHECK-START: void Main.fullFence() builder (after)
+ /// CHECK-START: void TestVarHandles.fullFence() builder (after)
/// CHECK-DAG: MemoryBarrier kind:AnyAny
private static void fullFence() {
VarHandle.fullFence();
}
- /// CHECK-START: void Main.acquireFence() builder (after)
+ /// CHECK-START: void TestVarHandles.acquireFence() builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
//
- /// CHECK-START: void Main.acquireFence() builder (after)
+ /// CHECK-START: void TestVarHandles.acquireFence() builder (after)
/// CHECK-DAG: MemoryBarrier kind:LoadAny
private static void acquireFence() {
VarHandle.acquireFence();
}
- /// CHECK-START: void Main.releaseFence() builder (after)
+ /// CHECK-START: void TestVarHandles.releaseFence() builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
//
- /// CHECK-START: void Main.releaseFence() builder (after)
+ /// CHECK-START: void TestVarHandles.releaseFence() builder (after)
/// CHECK-DAG: MemoryBarrier kind:AnyStore
private static void releaseFence() {
VarHandle.releaseFence();
}
- /// CHECK-START: void Main.loadLoadFence() builder (after)
+ /// CHECK-START: void TestVarHandles.loadLoadFence() builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
//
- /// CHECK-START: void Main.loadLoadFence() builder (after)
+ /// CHECK-START: void TestVarHandles.loadLoadFence() builder (after)
/// CHECK-DAG: MemoryBarrier kind:LoadAny
private static void loadLoadFence() {
VarHandle.loadLoadFence();
}
- /// CHECK-START: void Main.storeStoreFence() builder (after)
+ /// CHECK-START: void TestVarHandles.storeStoreFence() builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
//
- /// CHECK-START: void Main.storeStoreFence() builder (after)
+ /// CHECK-START: void TestVarHandles.storeStoreFence() builder (after)
/// CHECK-DAG: MemoryBarrier kind:StoreStore
private static void storeStoreFence() {
VarHandle.storeStoreFence();
@@ -77,13 +77,12 @@
// Driver.
//
- public static void main(String[] args) {
- System.out.println("starting");
+ public static void main() {
acquireFence();
releaseFence();
loadLoadFence();
storeStoreFence();
fullFence();
- System.out.println("passed");
+ System.out.println("TestVarHandles passed");
}
}
diff --git a/test/567-checker-compare/expected.txt b/test/567-checker-compare/expected.txt
deleted file mode 100644
index b0aad4d..0000000
--- a/test/567-checker-compare/expected.txt
+++ /dev/null
@@ -1 +0,0 @@
-passed
diff --git a/test/567-checker-compare/info.txt b/test/567-checker-compare/info.txt
deleted file mode 100644
index 5bac7b1..0000000
--- a/test/567-checker-compare/info.txt
+++ /dev/null
@@ -1 +0,0 @@
-Unit test for 32-bit and 64-bit compare operations.
diff --git a/test/575-checker-isnan/expected.txt b/test/575-checker-isnan/expected.txt
deleted file mode 100644
index b0aad4d..0000000
--- a/test/575-checker-isnan/expected.txt
+++ /dev/null
@@ -1 +0,0 @@
-passed
diff --git a/test/575-checker-isnan/info.txt b/test/575-checker-isnan/info.txt
deleted file mode 100644
index 5c48a6a..0000000
--- a/test/575-checker-isnan/info.txt
+++ /dev/null
@@ -1 +0,0 @@
-Unit test for float/double isNaN() operation.
diff --git a/test/631-checker-fp-abs/expected.txt b/test/631-checker-fp-abs/expected.txt
deleted file mode 100644
index b0aad4d..0000000
--- a/test/631-checker-fp-abs/expected.txt
+++ /dev/null
@@ -1 +0,0 @@
-passed
diff --git a/test/631-checker-fp-abs/info.txt b/test/631-checker-fp-abs/info.txt
deleted file mode 100644
index 0a1499e..0000000
--- a/test/631-checker-fp-abs/info.txt
+++ /dev/null
@@ -1 +0,0 @@
-Tests on floating-point Math.abs.
diff --git a/test/679-checker-minmax/expected.txt b/test/679-checker-minmax/expected.txt
deleted file mode 100644
index b0aad4d..0000000
--- a/test/679-checker-minmax/expected.txt
+++ /dev/null
@@ -1 +0,0 @@
-passed
diff --git a/test/679-checker-minmax/info.txt b/test/679-checker-minmax/info.txt
deleted file mode 100644
index 4f7b9f5..0000000
--- a/test/679-checker-minmax/info.txt
+++ /dev/null
@@ -1 +0,0 @@
-Functional tests on detecting min/max.
diff --git a/test/681-checker-abs/expected.txt b/test/681-checker-abs/expected.txt
deleted file mode 100644
index b0aad4d..0000000
--- a/test/681-checker-abs/expected.txt
+++ /dev/null
@@ -1 +0,0 @@
-passed
diff --git a/test/681-checker-abs/info.txt b/test/681-checker-abs/info.txt
deleted file mode 100644
index d36e76e..0000000
--- a/test/681-checker-abs/info.txt
+++ /dev/null
@@ -1 +0,0 @@
-Functional tests on detecting abs.
diff --git a/test/709-checker-varhandles/build b/test/709-checker-varhandles/build
deleted file mode 100755
index 2b0b2c1..0000000
--- a/test/709-checker-varhandles/build
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/bin/bash
-#
-# Copyright 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.
-
-# make us exit on a failure
-set -e
-
-./default-build "$@" --experimental method-handles
diff --git a/test/709-checker-varhandles/expected.txt b/test/709-checker-varhandles/expected.txt
deleted file mode 100644
index 651da72..0000000
--- a/test/709-checker-varhandles/expected.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-starting
-passed
diff --git a/test/709-checker-varhandles/info.txt b/test/709-checker-varhandles/info.txt
deleted file mode 100644
index 2221240..0000000
--- a/test/709-checker-varhandles/info.txt
+++ /dev/null
@@ -1 +0,0 @@
-Test support for intrinsics in Java 9 java.lang.invoke.VarHandle.
diff --git a/test/knownfailures.json b/test/knownfailures.json
index adcdffe..68a8101 100644
--- a/test/knownfailures.json
+++ b/test/knownfailures.json
@@ -965,7 +965,6 @@
"565-checker-doublenegbitwise",
"565-checker-irreducible-loop",
"566-polymorphic-inlining",
- "567-checker-compare",
"569-checker-pattern-replacement",
"570-checker-osr",
"571-irreducible-loop",
@@ -1009,7 +1008,6 @@
"628-vdex",
"629-vdex-speed",
"630-safecast-array",
- "631-checker-fp-abs",
"633-checker-rtp-getclass",
"634-vdex-duplicate",
"636-wrong-static-access",