ART: Distinguish Checker lines from comments
In order to prevent tests passing due to lines with hard-to-spot
formatting errors begin ignored, e.g. by forgetting the colon after
"//CHECK", Checker will now require its assertions to start with "///"
or "##", respectivelly for Java and Smali. Such lines will never be
ignored and will fail the test unless successfully parsed.
Change-Id: I0da9a8f13eb96d950af8c85df17d1899a853a299
diff --git a/test/441-checker-inliner/src/Main.java b/test/441-checker-inliner/src/Main.java
index 8894d4e..df969a4 100644
--- a/test/441-checker-inliner/src/Main.java
+++ b/test/441-checker-inliner/src/Main.java
@@ -16,133 +16,133 @@
public class Main {
- // CHECK-START: void Main.InlineVoid() inliner (before)
- // CHECK-DAG: <<Const42:i\d+>> IntConstant 42
- // CHECK-DAG: InvokeStaticOrDirect
- // CHECK-DAG: InvokeStaticOrDirect [<<Const42>>]
+ /// CHECK-START: void Main.InlineVoid() inliner (before)
+ /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42
+ /// CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-DAG: InvokeStaticOrDirect [<<Const42>>]
- // CHECK-START: void Main.InlineVoid() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main.InlineVoid() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static void InlineVoid() {
returnVoid();
returnVoidWithOneParameter(42);
}
- // CHECK-START: int Main.InlineParameter(int) inliner (before)
- // CHECK-DAG: <<Param:i\d+>> ParameterValue
- // CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<Param>>]
- // CHECK-DAG: Return [<<Result>>]
+ /// CHECK-START: int Main.InlineParameter(int) inliner (before)
+ /// CHECK-DAG: <<Param:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<Param>>]
+ /// CHECK-DAG: Return [<<Result>>]
- // CHECK-START: int Main.InlineParameter(int) inliner (after)
- // CHECK-DAG: <<Param:i\d+>> ParameterValue
- // CHECK-DAG: Return [<<Param>>]
+ /// CHECK-START: int Main.InlineParameter(int) inliner (after)
+ /// CHECK-DAG: <<Param:i\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Param>>]
public static int InlineParameter(int a) {
return returnParameter(a);
}
- // CHECK-START: long Main.InlineWideParameter(long) inliner (before)
- // CHECK-DAG: <<Param:j\d+>> ParameterValue
- // CHECK-DAG: <<Result:j\d+>> InvokeStaticOrDirect [<<Param>>]
- // CHECK-DAG: Return [<<Result>>]
+ /// CHECK-START: long Main.InlineWideParameter(long) inliner (before)
+ /// CHECK-DAG: <<Param:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Result:j\d+>> InvokeStaticOrDirect [<<Param>>]
+ /// CHECK-DAG: Return [<<Result>>]
- // CHECK-START: long Main.InlineWideParameter(long) inliner (after)
- // CHECK-DAG: <<Param:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Param>>]
+ /// CHECK-START: long Main.InlineWideParameter(long) inliner (after)
+ /// CHECK-DAG: <<Param:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Param>>]
public static long InlineWideParameter(long a) {
return returnWideParameter(a);
}
- // CHECK-START: java.lang.Object Main.InlineReferenceParameter(java.lang.Object) inliner (before)
- // CHECK-DAG: <<Param:l\d+>> ParameterValue
- // CHECK-DAG: <<Result:l\d+>> InvokeStaticOrDirect [<<Param>>]
- // CHECK-DAG: Return [<<Result>>]
+ /// CHECK-START: java.lang.Object Main.InlineReferenceParameter(java.lang.Object) inliner (before)
+ /// CHECK-DAG: <<Param:l\d+>> ParameterValue
+ /// CHECK-DAG: <<Result:l\d+>> InvokeStaticOrDirect [<<Param>>]
+ /// CHECK-DAG: Return [<<Result>>]
- // CHECK-START: java.lang.Object Main.InlineReferenceParameter(java.lang.Object) inliner (after)
- // CHECK-DAG: <<Param:l\d+>> ParameterValue
- // CHECK-DAG: Return [<<Param>>]
+ /// CHECK-START: java.lang.Object Main.InlineReferenceParameter(java.lang.Object) inliner (after)
+ /// CHECK-DAG: <<Param:l\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Param>>]
public static Object InlineReferenceParameter(Object o) {
return returnReferenceParameter(o);
}
- // CHECK-START: int Main.InlineInt() inliner (before)
- // CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Result>>]
+ /// CHECK-START: int Main.InlineInt() inliner (before)
+ /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Result>>]
- // CHECK-START: int Main.InlineInt() inliner (after)
- // CHECK-DAG: <<Const4:i\d+>> IntConstant 4
- // CHECK-DAG: Return [<<Const4>>]
+ /// CHECK-START: int Main.InlineInt() inliner (after)
+ /// CHECK-DAG: <<Const4:i\d+>> IntConstant 4
+ /// CHECK-DAG: Return [<<Const4>>]
public static int InlineInt() {
return returnInt();
}
- // CHECK-START: long Main.InlineWide() inliner (before)
- // CHECK-DAG: <<Result:j\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Result>>]
+ /// CHECK-START: long Main.InlineWide() inliner (before)
+ /// CHECK-DAG: <<Result:j\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Result>>]
- // CHECK-START: long Main.InlineWide() inliner (after)
- // CHECK-DAG: <<Const8:j\d+>> LongConstant 8
- // CHECK-DAG: Return [<<Const8>>]
+ /// CHECK-START: long Main.InlineWide() inliner (after)
+ /// CHECK-DAG: <<Const8:j\d+>> LongConstant 8
+ /// CHECK-DAG: Return [<<Const8>>]
public static long InlineWide() {
return returnWide();
}
- // CHECK-START: int Main.InlineAdd() inliner (before)
- // CHECK-DAG: <<Const3:i\d+>> IntConstant 3
- // CHECK-DAG: <<Const5:i\d+>> IntConstant 5
- // CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Result>>]
+ /// CHECK-START: int Main.InlineAdd() inliner (before)
+ /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
+ /// CHECK-DAG: <<Const5:i\d+>> IntConstant 5
+ /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Result>>]
- // CHECK-START: int Main.InlineAdd() inliner (after)
- // CHECK-DAG: <<Const3:i\d+>> IntConstant 3
- // CHECK-DAG: <<Const5:i\d+>> IntConstant 5
- // CHECK-DAG: <<Add:i\d+>> Add [<<Const3>>,<<Const5>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.InlineAdd() inliner (after)
+ /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
+ /// CHECK-DAG: <<Const5:i\d+>> IntConstant 5
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Const3>>,<<Const5>>]
+ /// CHECK-DAG: Return [<<Add>>]
public static int InlineAdd() {
return returnAdd(3, 5);
}
- // CHECK-START: int Main.InlineFieldAccess() inliner (before)
- // CHECK-DAG: <<After:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<After>>]
+ /// CHECK-START: int Main.InlineFieldAccess() inliner (before)
+ /// CHECK-DAG: <<After:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<After>>]
- // CHECK-START: int Main.InlineFieldAccess() inliner (after)
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Before:i\d+>> StaticFieldGet
- // CHECK-DAG: <<After:i\d+>> Add [<<Before>>,<<Const1>>]
- // CHECK-DAG: StaticFieldSet [{{l\d+}},<<After>>]
- // CHECK-DAG: Return [<<After>>]
+ /// CHECK-START: int Main.InlineFieldAccess() inliner (after)
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Before:i\d+>> StaticFieldGet
+ /// CHECK-DAG: <<After:i\d+>> Add [<<Before>>,<<Const1>>]
+ /// CHECK-DAG: StaticFieldSet [{{l\d+}},<<After>>]
+ /// CHECK-DAG: Return [<<After>>]
- // CHECK-START: int Main.InlineFieldAccess() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.InlineFieldAccess() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static int InlineFieldAccess() {
return incCounter();
}
- // CHECK-START: int Main.InlineWithControlFlow(boolean) inliner (before)
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Const3:i\d+>> IntConstant 3
- // CHECK-DAG: <<Const5:i\d+>> IntConstant 5
- // CHECK-DAG: <<Add:i\d+>> InvokeStaticOrDirect [<<Const1>>,<<Const3>>]
- // CHECK-DAG: <<Sub:i\d+>> InvokeStaticOrDirect [<<Const5>>,<<Const3>>]
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: int Main.InlineWithControlFlow(boolean) inliner (before)
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
+ /// CHECK-DAG: <<Const5:i\d+>> IntConstant 5
+ /// CHECK-DAG: <<Add:i\d+>> InvokeStaticOrDirect [<<Const1>>,<<Const3>>]
+ /// CHECK-DAG: <<Sub:i\d+>> InvokeStaticOrDirect [<<Const5>>,<<Const3>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
+ /// CHECK-DAG: Return [<<Phi>>]
- // CHECK-START: int Main.InlineWithControlFlow(boolean) inliner (after)
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Const3:i\d+>> IntConstant 3
- // CHECK-DAG: <<Const5:i\d+>> IntConstant 5
- // CHECK-DAG: <<Add:i\d+>> Add [<<Const1>>,<<Const3>>]
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Const5>>,<<Const3>>]
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: int Main.InlineWithControlFlow(boolean) inliner (after)
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
+ /// CHECK-DAG: <<Const5:i\d+>> IntConstant 5
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Const1>>,<<Const3>>]
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const5>>,<<Const3>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
+ /// CHECK-DAG: Return [<<Phi>>]
public static int InlineWithControlFlow(boolean cond) {
int x, const1, const3, const5;
diff --git a/test/442-checker-constant-folding/src/Main.java b/test/442-checker-constant-folding/src/Main.java
index c258db9..b7863be 100644
--- a/test/442-checker-constant-folding/src/Main.java
+++ b/test/442-checker-constant-folding/src/Main.java
@@ -51,14 +51,14 @@
* on negation.
*/
- // CHECK-START: int Main.IntNegation() constant_folding (before)
- // CHECK-DAG: <<Const42:i\d+>> IntConstant 42
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Const42>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.IntNegation() constant_folding (before)
+ /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Const42>>]
+ /// CHECK-DAG: Return [<<Neg>>]
- // CHECK-START: int Main.IntNegation() constant_folding (after)
- // CHECK-DAG: <<ConstN42:i\d+>> IntConstant -42
- // CHECK-DAG: Return [<<ConstN42>>]
+ /// CHECK-START: int Main.IntNegation() constant_folding (after)
+ /// CHECK-DAG: <<ConstN42:i\d+>> IntConstant -42
+ /// CHECK-DAG: Return [<<ConstN42>>]
public static int IntNegation() {
int x, y;
@@ -72,15 +72,15 @@
* on addition.
*/
- // 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 (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)
- // CHECK-DAG: <<Const3:i\d+>> IntConstant 3
- // CHECK-DAG: Return [<<Const3>>]
+ /// CHECK-START: int Main.IntAddition1() constant_folding (after)
+ /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
+ /// CHECK-DAG: Return [<<Const3>>]
public static int IntAddition1() {
int a, b, c;
@@ -95,19 +95,19 @@
* on addition.
*/
- // 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: <<Add1:i\d+>> Add [<<Const1>>,<<Const2>>]
- // CHECK-DAG: <<Add2:i\d+>> Add [<<Const5>>,<<Const6>>]
- // CHECK-DAG: <<Add3:i\d+>> Add [<<Add1>>,<<Add2>>]
- // CHECK-DAG: Return [<<Add3>>]
+ /// 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: <<Add1:i\d+>> Add [<<Const1>>,<<Const2>>]
+ /// CHECK-DAG: <<Add2:i\d+>> Add [<<Const5>>,<<Const6>>]
+ /// CHECK-DAG: <<Add3:i\d+>> Add [<<Add1>>,<<Add2>>]
+ /// CHECK-DAG: Return [<<Add3>>]
- // 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)
+ /// CHECK-DAG: <<Const14:i\d+>> IntConstant 14
+ /// CHECK-DAG: Return [<<Const14>>]
public static int IntAddition2() {
int a, b, c;
@@ -126,15 +126,15 @@
* on subtraction.
*/
- // 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 (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)
- // CHECK-DAG: <<Const4:i\d+>> IntConstant 4
- // CHECK-DAG: Return [<<Const4>>]
+ /// CHECK-START: int Main.IntSubtraction() constant_folding (after)
+ /// CHECK-DAG: <<Const4:i\d+>> IntConstant 4
+ /// CHECK-DAG: Return [<<Const4>>]
public static int IntSubtraction() {
int a, b, c;
@@ -149,15 +149,15 @@
* on addition.
*/
- // 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 (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)
- // CHECK-DAG: <<Const3:j\d+>> LongConstant 3
- // CHECK-DAG: Return [<<Const3>>]
+ /// CHECK-START: long Main.LongAddition() constant_folding (after)
+ /// CHECK-DAG: <<Const3:j\d+>> LongConstant 3
+ /// CHECK-DAG: Return [<<Const3>>]
public static long LongAddition() {
long a, b, c;
@@ -172,15 +172,15 @@
* on subtraction.
*/
- // 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 (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)
- // CHECK-DAG: <<Const4:j\d+>> LongConstant 4
- // CHECK-DAG: Return [<<Const4>>]
+ /// CHECK-START: long Main.LongSubtraction() constant_folding (after)
+ /// CHECK-DAG: <<Const4:j\d+>> LongConstant 4
+ /// CHECK-DAG: Return [<<Const4>>]
public static long LongSubtraction() {
long a, b, c;
@@ -194,15 +194,15 @@
* Three-register program with a constant (static) condition.
*/
- // 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: If [<<Cond>>]
+ /// 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: If [<<Cond>>]
- // CHECK-START: int Main.StaticCondition() constant_folding (after)
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: If [<<Const1>>]
+ /// CHECK-START: int Main.StaticCondition() constant_folding (after)
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: If [<<Const1>>]
public static int StaticCondition() {
int a, b, c;
@@ -224,19 +224,19 @@
* (forward) post-order traversal of the the dominator tree.
*/
- // 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+>> Phi [<<Add>>,<<Sub>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// 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+>> Phi [<<Add>>,<<Sub>>]
+ /// CHECK-DAG: Return [<<Phi>>]
- // 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+>> Phi [<<Const7>>,<<Const3>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// 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+>> Phi [<<Const7>>,<<Const3>>]
+ /// CHECK-DAG: Return [<<Phi>>]
public static int JumpsAndConditionals(boolean cond) {
int a, b, c;
@@ -253,388 +253,388 @@
* Test optimizations of arithmetic identities yielding a constant result.
*/
- // CHECK-START: int Main.And0(int) constant_folding (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<And:i\d+>> And [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<And>>]
+ /// CHECK-START: int Main.And0(int) constant_folding (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<And:i\d+>> And [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<And>>]
- // CHECK-START: int Main.And0(int) constant_folding (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-NOT: And
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: int Main.And0(int) constant_folding (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-NOT: And
+ /// CHECK-DAG: Return [<<Const0>>]
public static int And0(int arg) {
return arg & 0;
}
- // CHECK-START: long Main.Mul0(long) constant_folding (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-DAG: <<Mul:j\d+>> Mul [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: long Main.Mul0(long) constant_folding (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-DAG: <<Mul:j\d+>> Mul [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: long Main.Mul0(long) constant_folding (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-NOT: Mul
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: long Main.Mul0(long) constant_folding (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-NOT: Mul
+ /// CHECK-DAG: Return [<<Const0>>]
public static long Mul0(long arg) {
return arg * 0;
}
- // CHECK-START: int Main.OrAllOnes(int) constant_folding (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
- // CHECK-DAG: <<Or:i\d+>> Or [<<Arg>>,<<ConstF>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.OrAllOnes(int) constant_folding (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Arg>>,<<ConstF>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.OrAllOnes(int) constant_folding (after)
- // CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
- // CHECK-NOT: Or
- // CHECK-DAG: Return [<<ConstF>>]
+ /// CHECK-START: int Main.OrAllOnes(int) constant_folding (after)
+ /// CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
+ /// CHECK-NOT: Or
+ /// CHECK-DAG: Return [<<ConstF>>]
public static int OrAllOnes(int arg) {
return arg | -1;
}
- // CHECK-START: long Main.Rem0(long) constant_folding (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-DAG: <<DivZeroCheck:j\d+>> DivZeroCheck [<<Arg>>]
- // CHECK-DAG: <<Rem:j\d+>> Rem [<<Const0>>,<<DivZeroCheck>>]
- // CHECK-DAG: Return [<<Rem>>]
+ /// CHECK-START: long Main.Rem0(long) constant_folding (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-DAG: <<DivZeroCheck:j\d+>> DivZeroCheck [<<Arg>>]
+ /// CHECK-DAG: <<Rem:j\d+>> Rem [<<Const0>>,<<DivZeroCheck>>]
+ /// CHECK-DAG: Return [<<Rem>>]
- // CHECK-START: long Main.Rem0(long) constant_folding (after)
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-NOT: Rem
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: long Main.Rem0(long) constant_folding (after)
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-NOT: Rem
+ /// CHECK-DAG: Return [<<Const0>>]
public static long Rem0(long arg) {
return 0 % arg;
}
- // CHECK-START: int Main.Rem1(int) constant_folding (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Rem:i\d+>> Rem [<<Arg>>,<<Const1>>]
- // CHECK-DAG: Return [<<Rem>>]
+ /// CHECK-START: int Main.Rem1(int) constant_folding (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Rem:i\d+>> Rem [<<Arg>>,<<Const1>>]
+ /// CHECK-DAG: Return [<<Rem>>]
- // CHECK-START: int Main.Rem1(int) constant_folding (after)
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-NOT: Rem
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: int Main.Rem1(int) constant_folding (after)
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-NOT: Rem
+ /// CHECK-DAG: Return [<<Const0>>]
public static int Rem1(int arg) {
return arg % 1;
}
- // CHECK-START: long Main.RemN1(long) constant_folding (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<ConstN1:j\d+>> LongConstant -1
- // CHECK-DAG: <<DivZeroCheck:j\d+>> DivZeroCheck [<<ConstN1>>]
- // CHECK-DAG: <<Rem:j\d+>> Rem [<<Arg>>,<<DivZeroCheck>>]
- // CHECK-DAG: Return [<<Rem>>]
+ /// CHECK-START: long Main.RemN1(long) constant_folding (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstN1:j\d+>> LongConstant -1
+ /// CHECK-DAG: <<DivZeroCheck:j\d+>> DivZeroCheck [<<ConstN1>>]
+ /// CHECK-DAG: <<Rem:j\d+>> Rem [<<Arg>>,<<DivZeroCheck>>]
+ /// CHECK-DAG: Return [<<Rem>>]
- // CHECK-START: long Main.RemN1(long) constant_folding (after)
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-NOT: Rem
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: long Main.RemN1(long) constant_folding (after)
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-NOT: Rem
+ /// CHECK-DAG: Return [<<Const0>>]
public static long RemN1(long arg) {
return arg % -1;
}
- // CHECK-START: int Main.Shl0(int) constant_folding (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Shl:i\d+>> Shl [<<Const0>>,<<Arg>>]
- // CHECK-DAG: Return [<<Shl>>]
+ /// CHECK-START: int Main.Shl0(int) constant_folding (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Shl:i\d+>> Shl [<<Const0>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Shl>>]
- // CHECK-START: int Main.Shl0(int) constant_folding (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-NOT: Shl
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: int Main.Shl0(int) constant_folding (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-NOT: Shl
+ /// CHECK-DAG: Return [<<Const0>>]
public static int Shl0(int arg) {
return 0 << arg;
}
- // CHECK-START: long Main.Shr0(int) constant_folding (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-DAG: <<Shr:j\d+>> Shr [<<Const0>>,<<Arg>>]
- // CHECK-DAG: Return [<<Shr>>]
+ /// CHECK-START: long Main.Shr0(int) constant_folding (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-DAG: <<Shr:j\d+>> Shr [<<Const0>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Shr>>]
- // CHECK-START: long Main.Shr0(int) constant_folding (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-NOT: Shr
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: long Main.Shr0(int) constant_folding (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-NOT: Shr
+ /// CHECK-DAG: Return [<<Const0>>]
public static long Shr0(int arg) {
return (long)0 >> arg;
}
- // CHECK-START: long Main.SubSameLong(long) constant_folding (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg>>,<<Arg>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: long Main.SubSameLong(long) constant_folding (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: long Main.SubSameLong(long) constant_folding (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-NOT: Sub
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: long Main.SubSameLong(long) constant_folding (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-NOT: Sub
+ /// CHECK-DAG: Return [<<Const0>>]
public static long SubSameLong(long arg) {
return arg - arg;
}
- // CHECK-START: int Main.UShr0(int) constant_folding (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<UShr:i\d+>> UShr [<<Const0>>,<<Arg>>]
- // CHECK-DAG: Return [<<UShr>>]
+ /// CHECK-START: int Main.UShr0(int) constant_folding (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<UShr:i\d+>> UShr [<<Const0>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<UShr>>]
- // CHECK-START: int Main.UShr0(int) constant_folding (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-NOT: UShr
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: int Main.UShr0(int) constant_folding (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-NOT: UShr
+ /// CHECK-DAG: Return [<<Const0>>]
public static int UShr0(int arg) {
return 0 >>> arg;
}
- // CHECK-START: int Main.XorSameInt(int) constant_folding (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<Arg>>]
- // CHECK-DAG: Return [<<Xor>>]
+ /// CHECK-START: int Main.XorSameInt(int) constant_folding (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Xor>>]
- // CHECK-START: int Main.XorSameInt(int) constant_folding (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-NOT: Xor
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: int Main.XorSameInt(int) constant_folding (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-NOT: Xor
+ /// CHECK-DAG: Return [<<Const0>>]
public static int XorSameInt(int arg) {
return arg ^ arg;
}
- // CHECK-START: boolean Main.CmpFloatGreaterThanNaN(float) constant_folding (before)
- // CHECK-DAG: <<Arg:f\d+>> ParameterValue
- // CHECK-DAG: <<ConstNan:f\d+>> FloatConstant nan
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: IntConstant 1
- // CHECK-DAG: <<Cmp:i\d+>> Compare [<<Arg>>,<<ConstNan>>]
- // CHECK-DAG: <<Le:z\d+>> LessThanOrEqual [<<Cmp>>,<<Const0>>]
- // CHECK-DAG: If [<<Le>>]
+ /// CHECK-START: boolean Main.CmpFloatGreaterThanNaN(float) constant_folding (before)
+ /// CHECK-DAG: <<Arg:f\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstNan:f\d+>> FloatConstant nan
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: IntConstant 1
+ /// CHECK-DAG: <<Cmp:i\d+>> Compare [<<Arg>>,<<ConstNan>>]
+ /// CHECK-DAG: <<Le:z\d+>> LessThanOrEqual [<<Cmp>>,<<Const0>>]
+ /// CHECK-DAG: If [<<Le>>]
- // CHECK-START: boolean Main.CmpFloatGreaterThanNaN(float) constant_folding (after)
- // CHECK-DAG: ParameterValue
- // CHECK-DAG: FloatConstant nan
- // CHECK-DAG: IntConstant 0
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: If [<<Const1>>]
+ /// CHECK-START: boolean Main.CmpFloatGreaterThanNaN(float) constant_folding (after)
+ /// CHECK-DAG: ParameterValue
+ /// CHECK-DAG: FloatConstant nan
+ /// CHECK-DAG: IntConstant 0
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: If [<<Const1>>]
- // CHECK-START: boolean Main.CmpFloatGreaterThanNaN(float) constant_folding (after)
- // CHECK-NOT: Compare
- // CHECK-NOT: LessThanOrEqual
+ /// CHECK-START: boolean Main.CmpFloatGreaterThanNaN(float) constant_folding (after)
+ /// CHECK-NOT: Compare
+ /// CHECK-NOT: LessThanOrEqual
public static boolean CmpFloatGreaterThanNaN(float arg) {
return arg > Float.NaN;
}
- // CHECK-START: boolean Main.CmpDoubleLessThanNaN(double) constant_folding (before)
- // CHECK-DAG: <<Arg:d\d+>> ParameterValue
- // CHECK-DAG: <<ConstNan:d\d+>> DoubleConstant nan
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: IntConstant 1
- // CHECK-DAG: <<Cmp:i\d+>> Compare [<<Arg>>,<<ConstNan>>]
- // CHECK-DAG: <<Ge:z\d+>> GreaterThanOrEqual [<<Cmp>>,<<Const0>>]
- // CHECK-DAG: If [<<Ge>>]
+ /// CHECK-START: boolean Main.CmpDoubleLessThanNaN(double) constant_folding (before)
+ /// CHECK-DAG: <<Arg:d\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstNan:d\d+>> DoubleConstant nan
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: IntConstant 1
+ /// CHECK-DAG: <<Cmp:i\d+>> Compare [<<Arg>>,<<ConstNan>>]
+ /// CHECK-DAG: <<Ge:z\d+>> GreaterThanOrEqual [<<Cmp>>,<<Const0>>]
+ /// CHECK-DAG: If [<<Ge>>]
- // CHECK-START: boolean Main.CmpDoubleLessThanNaN(double) constant_folding (after)
- // CHECK-DAG: ParameterValue
- // CHECK-DAG: DoubleConstant nan
- // CHECK-DAG: IntConstant 0
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: If [<<Const1>>]
+ /// CHECK-START: boolean Main.CmpDoubleLessThanNaN(double) constant_folding (after)
+ /// CHECK-DAG: ParameterValue
+ /// CHECK-DAG: DoubleConstant nan
+ /// CHECK-DAG: IntConstant 0
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: If [<<Const1>>]
- // CHECK-START: boolean Main.CmpDoubleLessThanNaN(double) constant_folding (after)
- // CHECK-NOT: Compare
- // CHECK-NOT: GreaterThanOrEqual
+ /// CHECK-START: boolean Main.CmpDoubleLessThanNaN(double) constant_folding (after)
+ /// CHECK-NOT: Compare
+ /// CHECK-NOT: GreaterThanOrEqual
public static boolean CmpDoubleLessThanNaN(double arg) {
return arg < Double.NaN;
}
- // 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 (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)
- // CHECK-DAG: <<Const33:i\d+>> IntConstant 33
- // CHECK-DAG: Return [<<Const33>>]
+ /// CHECK-START: int Main.ReturnInt33() constant_folding (after)
+ /// CHECK-DAG: <<Const33:i\d+>> IntConstant 33
+ /// CHECK-DAG: Return [<<Const33>>]
public static int ReturnInt33() {
long imm = 33L;
return (int) imm;
}
- // 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 (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)
- // CHECK-DAG: <<ConstMax:i\d+>> IntConstant 2147483647
- // CHECK-DAG: Return [<<ConstMax>>]
+ /// CHECK-START: int Main.ReturnIntMax() constant_folding (after)
+ /// CHECK-DAG: <<ConstMax:i\d+>> IntConstant 2147483647
+ /// CHECK-DAG: Return [<<ConstMax>>]
public static int ReturnIntMax() {
float imm = 1.0e34f;
return (int) imm;
}
- // 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 (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)
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: int Main.ReturnInt0() constant_folding (after)
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: Return [<<Const0>>]
public static int ReturnInt0() {
double imm = Double.NaN;
return (int) imm;
}
- // 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 (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)
- // CHECK-DAG: <<Const33:j\d+>> LongConstant 33
- // CHECK-DAG: Return [<<Const33>>]
+ /// CHECK-START: long Main.ReturnLong33() constant_folding (after)
+ /// CHECK-DAG: <<Const33:j\d+>> LongConstant 33
+ /// CHECK-DAG: Return [<<Const33>>]
public static long ReturnLong33() {
int imm = 33;
return (long) imm;
}
- // 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 (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)
- // CHECK-DAG: <<Const34:j\d+>> LongConstant 34
- // CHECK-DAG: Return [<<Const34>>]
+ /// CHECK-START: long Main.ReturnLong34() constant_folding (after)
+ /// CHECK-DAG: <<Const34:j\d+>> LongConstant 34
+ /// CHECK-DAG: Return [<<Const34>>]
public static long ReturnLong34() {
float imm = 34.0f;
return (long) imm;
}
- // 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 (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)
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: long Main.ReturnLong0() constant_folding (after)
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-DAG: Return [<<Const0>>]
public static long ReturnLong0() {
double imm = -Double.NaN;
return (long) imm;
}
- // 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 (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)
- // CHECK-DAG: <<Const33:f\d+>> FloatConstant 33
- // CHECK-DAG: Return [<<Const33>>]
+ /// CHECK-START: float Main.ReturnFloat33() constant_folding (after)
+ /// CHECK-DAG: <<Const33:f\d+>> FloatConstant 33
+ /// CHECK-DAG: Return [<<Const33>>]
public static float ReturnFloat33() {
int imm = 33;
return (float) imm;
}
- // 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 (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)
- // CHECK-DAG: <<Const34:f\d+>> FloatConstant 34
- // CHECK-DAG: Return [<<Const34>>]
+ /// CHECK-START: float Main.ReturnFloat34() constant_folding (after)
+ /// CHECK-DAG: <<Const34:f\d+>> FloatConstant 34
+ /// CHECK-DAG: Return [<<Const34>>]
public static float ReturnFloat34() {
long imm = 34L;
return (float) imm;
}
- // 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 (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)
- // CHECK-DAG: <<Const:f\d+>> FloatConstant 99.25
- // CHECK-DAG: Return [<<Const>>]
+ /// CHECK-START: float Main.ReturnFloat99P25() constant_folding (after)
+ /// CHECK-DAG: <<Const:f\d+>> FloatConstant 99.25
+ /// CHECK-DAG: Return [<<Const>>]
public static float ReturnFloat99P25() {
double imm = 99.25;
return (float) imm;
}
- // 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 (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)
- // CHECK-DAG: <<Const33:d\d+>> DoubleConstant 33
- // CHECK-DAG: Return [<<Const33>>]
+ /// 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 = 33;
return (double) imm;
}
- // 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 (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)
- // CHECK-DAG: <<Const34:d\d+>> DoubleConstant 34
- // CHECK-DAG: Return [<<Const34>>]
+ /// CHECK-START: double Main.ReturnDouble34() constant_folding (after)
+ /// CHECK-DAG: <<Const34:d\d+>> DoubleConstant 34
+ /// CHECK-DAG: Return [<<Const34>>]
public static double ReturnDouble34() {
long imm = 34L;
return (double) imm;
}
- // 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 (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)
- // CHECK-DAG: <<Const:d\d+>> DoubleConstant 99.25
- // CHECK-DAG: Return [<<Const>>]
+ /// CHECK-START: double Main.ReturnDouble99P25() constant_folding (after)
+ /// CHECK-DAG: <<Const:d\d+>> DoubleConstant 99.25
+ /// CHECK-DAG: Return [<<Const>>]
public static double ReturnDouble99P25() {
float imm = 99.25f;
diff --git a/test/444-checker-nce/src/Main.java b/test/444-checker-nce/src/Main.java
index 501d79c..6ac0cad 100644
--- a/test/444-checker-nce/src/Main.java
+++ b/test/444-checker-nce/src/Main.java
@@ -16,63 +16,63 @@
public class Main {
- // CHECK-START: Main Main.keepTest(Main) instruction_simplifier_after_types (before)
- // CHECK: NullCheck
- // CHECK: InvokeStaticOrDirect
+ /// CHECK-START: Main Main.keepTest(Main) instruction_simplifier_after_types (before)
+ /// CHECK: NullCheck
+ /// CHECK: InvokeStaticOrDirect
- // CHECK-START: Main Main.keepTest(Main) instruction_simplifier_after_types (after)
- // CHECK: NullCheck
- // CHECK: InvokeStaticOrDirect
+ /// CHECK-START: Main Main.keepTest(Main) instruction_simplifier_after_types (after)
+ /// CHECK: NullCheck
+ /// CHECK: InvokeStaticOrDirect
public Main keepTest(Main m) {
return m.g();
}
- // CHECK-START: Main Main.thisTest() instruction_simplifier (before)
- // CHECK: NullCheck
- // CHECK: InvokeStaticOrDirect
+ /// CHECK-START: Main Main.thisTest() instruction_simplifier (before)
+ /// CHECK: NullCheck
+ /// CHECK: InvokeStaticOrDirect
- // CHECK-START: Main Main.thisTest() instruction_simplifier (after)
- // CHECK-NOT: NullCheck
- // CHECK: InvokeStaticOrDirect
+ /// CHECK-START: Main Main.thisTest() instruction_simplifier (after)
+ /// CHECK-NOT: NullCheck
+ /// CHECK: InvokeStaticOrDirect
public Main thisTest() {
return g();
}
- // CHECK-START: Main Main.newInstanceRemoveTest() instruction_simplifier (before)
- // CHECK: NewInstance
- // CHECK: NullCheck
- // CHECK: InvokeStaticOrDirect
- // CHECK: NullCheck
- // CHECK: InvokeStaticOrDirect
+ /// CHECK-START: Main Main.newInstanceRemoveTest() instruction_simplifier (before)
+ /// CHECK: NewInstance
+ /// CHECK: NullCheck
+ /// CHECK: InvokeStaticOrDirect
+ /// CHECK: NullCheck
+ /// CHECK: InvokeStaticOrDirect
- // CHECK-START: Main Main.newInstanceRemoveTest() instruction_simplifier (after)
- // CHECK-NOT: NullCheck
+ /// CHECK-START: Main Main.newInstanceRemoveTest() instruction_simplifier (after)
+ /// CHECK-NOT: NullCheck
public Main newInstanceRemoveTest() {
Main m = new Main();
return m.g();
}
- // CHECK-START: Main Main.newArrayRemoveTest() instruction_simplifier (before)
- // CHECK: NewArray
- // CHECK: NullCheck
- // CHECK: ArrayGet
+ /// CHECK-START: Main Main.newArrayRemoveTest() instruction_simplifier (before)
+ /// CHECK: NewArray
+ /// CHECK: NullCheck
+ /// CHECK: ArrayGet
- // CHECK-START: Main Main.newArrayRemoveTest() instruction_simplifier (after)
- // CHECK: NewArray
- // CHECK-NOT: NullCheck
- // CHECK: ArrayGet
+ /// CHECK-START: Main Main.newArrayRemoveTest() instruction_simplifier (after)
+ /// CHECK: NewArray
+ /// CHECK-NOT: NullCheck
+ /// CHECK: ArrayGet
public Main newArrayRemoveTest() {
Main[] ms = new Main[1];
return ms[0];
}
- // CHECK-START: Main Main.ifRemoveTest(boolean) instruction_simplifier_after_types (before)
- // CHECK: NewInstance
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.ifRemoveTest(boolean) instruction_simplifier_after_types (before)
+ /// CHECK: NewInstance
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.ifRemoveTest(boolean) instruction_simplifier_after_types (after)
- // CHECK: NewInstance
- // CHECK-NOT: NullCheck
+ /// CHECK-START: Main Main.ifRemoveTest(boolean) instruction_simplifier_after_types (after)
+ /// CHECK: NewInstance
+ /// CHECK-NOT: NullCheck
public Main ifRemoveTest(boolean flag) {
Main m = null;
if (flag) {
@@ -83,13 +83,13 @@
return m.g();
}
- // CHECK-START: Main Main.ifKeepTest(boolean) instruction_simplifier_after_types (before)
- // CHECK: NewInstance
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.ifKeepTest(boolean) instruction_simplifier_after_types (before)
+ /// CHECK: NewInstance
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.ifKeepTest(boolean) instruction_simplifier_after_types (after)
- // CHECK: NewInstance
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.ifKeepTest(boolean) instruction_simplifier_after_types (after)
+ /// CHECK: NewInstance
+ /// CHECK: NullCheck
public Main ifKeepTest(boolean flag) {
Main m = null;
if (flag) {
@@ -98,11 +98,11 @@
return m.g();
}
- // CHECK-START: Main Main.forRemoveTest(int) instruction_simplifier_after_types (before)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.forRemoveTest(int) instruction_simplifier_after_types (before)
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.forRemoveTest(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: NullCheck
+ /// CHECK-START: Main Main.forRemoveTest(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: NullCheck
public Main forRemoveTest(int count) {
Main a = new Main();
Main m = new Main();
@@ -114,11 +114,11 @@
return m.g();
}
- // CHECK-START: Main Main.forKeepTest(int) instruction_simplifier_after_types (before)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.forKeepTest(int) instruction_simplifier_after_types (before)
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.forKeepTest(int) instruction_simplifier_after_types (after)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.forKeepTest(int) instruction_simplifier_after_types (after)
+ /// CHECK: NullCheck
public Main forKeepTest(int count) {
Main a = new Main();
Main m = new Main();
@@ -132,11 +132,11 @@
return m.g();
}
- // CHECK-START: Main Main.phiFlowRemoveTest(int) instruction_simplifier_after_types (before)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.phiFlowRemoveTest(int) instruction_simplifier_after_types (before)
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.phiFlowRemoveTest(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: NullCheck
+ /// CHECK-START: Main Main.phiFlowRemoveTest(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: NullCheck
public Main phiFlowRemoveTest(int count) {
Main a = new Main();
Main m = new Main();
@@ -154,11 +154,11 @@
return n.g();
}
- // CHECK-START: Main Main.phiFlowKeepTest(int) instruction_simplifier_after_types (before)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.phiFlowKeepTest(int) instruction_simplifier_after_types (before)
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.phiFlowKeepTest(int) instruction_simplifier_after_types (after)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.phiFlowKeepTest(int) instruction_simplifier_after_types (after)
+ /// CHECK: NullCheck
public Main phiFlowKeepTest(int count) {
Main a = new Main();
Main m = new Main();
@@ -178,11 +178,11 @@
return n.g();
}
- // CHECK-START: Main Main.scopeRemoveTest(int, Main) instruction_simplifier (before)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.scopeRemoveTest(int, Main) instruction_simplifier (before)
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.scopeRemoveTest(int, Main) instruction_simplifier (after)
- // CHECK-NOT: NullCheck
+ /// CHECK-START: Main Main.scopeRemoveTest(int, Main) instruction_simplifier (after)
+ /// CHECK-NOT: NullCheck
public Main scopeRemoveTest(int count, Main a) {
Main m = null;
for (int i = 0; i < count; i++) {
@@ -196,11 +196,11 @@
return m;
}
- // CHECK-START: Main Main.scopeKeepTest(int, Main) instruction_simplifier_after_types (before)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.scopeKeepTest(int, Main) instruction_simplifier_after_types (before)
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.scopeKeepTest(int, Main) instruction_simplifier_after_types (after)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.scopeKeepTest(int, Main) instruction_simplifier_after_types (after)
+ /// CHECK: NullCheck
public Main scopeKeepTest(int count, Main a) {
Main m = new Main();
for (int i = 0; i < count; i++) {
@@ -214,11 +214,11 @@
return m;
}
- // CHECK-START: Main Main.scopeIfNotNullRemove(Main) instruction_simplifier_after_types (before)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.scopeIfNotNullRemove(Main) instruction_simplifier_after_types (before)
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.scopeIfNotNullRemove(Main) instruction_simplifier_after_types (after)
- // CHECK-NOT: NullCheck
+ /// CHECK-START: Main Main.scopeIfNotNullRemove(Main) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: NullCheck
public Main scopeIfNotNullRemove(Main m) {
if (m != null) {
return m.g();
@@ -226,11 +226,11 @@
return m;
}
- // CHECK-START: Main Main.scopeIfKeep(Main) instruction_simplifier_after_types (before)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.scopeIfKeep(Main) instruction_simplifier_after_types (before)
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.scopeIfKeep(Main) instruction_simplifier_after_types (after)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.scopeIfKeep(Main) instruction_simplifier_after_types (after)
+ /// CHECK: NullCheck
public Main scopeIfKeep(Main m) {
if (m == null) {
m = new Main();
@@ -258,12 +258,12 @@
class ListElement {
private ListElement next;
- // CHECK-START: boolean ListElement.isShorter(ListElement, ListElement) instruction_simplifier_after_types (before)
- // CHECK: NullCheck
- // CHECK: NullCheck
+ /// CHECK-START: boolean ListElement.isShorter(ListElement, ListElement) instruction_simplifier_after_types (before)
+ /// CHECK: NullCheck
+ /// CHECK: NullCheck
- // CHECK-START: boolean ListElement.isShorter(ListElement, ListElement) instruction_simplifier_after_types (after)
- // CHECK-NOT: NullCheck
+ /// CHECK-START: boolean ListElement.isShorter(ListElement, ListElement) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: NullCheck
static boolean isShorter(ListElement x, ListElement y) {
ListElement xTail = x;
ListElement yTail = y;
diff --git a/test/445-checker-licm/src/Main.java b/test/445-checker-licm/src/Main.java
index 96918d3..42f9a11 100644
--- a/test/445-checker-licm/src/Main.java
+++ b/test/445-checker-licm/src/Main.java
@@ -16,14 +16,14 @@
public class Main {
- // CHECK-START: int Main.div() licm (before)
- // CHECK-DAG: Div loop:{{B\d+}}
+ /// CHECK-START: int Main.div() licm (before)
+ /// CHECK-DAG: Div loop:{{B\d+}}
- // CHECK-START: int Main.div() licm (after)
- // CHECK-NOT: Div loop:{{B\d+}}
+ /// CHECK-START: int Main.div() licm (after)
+ /// CHECK-NOT: Div loop:{{B\d+}}
- // CHECK-START: int Main.div() licm (after)
- // CHECK-DAG: Div loop:none
+ /// CHECK-START: int Main.div() licm (after)
+ /// CHECK-DAG: Div loop:none
public static int div() {
int result = 0;
@@ -33,14 +33,14 @@
return result;
}
- // CHECK-START: int Main.innerDiv() licm (before)
- // CHECK-DAG: Div loop:{{B\d+}}
+ /// CHECK-START: int Main.innerDiv() licm (before)
+ /// CHECK-DAG: Div loop:{{B\d+}}
- // CHECK-START: int Main.innerDiv() licm (after)
- // CHECK-NOT: Div loop:{{B\d+}}
+ /// CHECK-START: int Main.innerDiv() licm (after)
+ /// CHECK-NOT: Div loop:{{B\d+}}
- // CHECK-START: int Main.innerDiv() licm (after)
- // CHECK-DAG: Div loop:none
+ /// CHECK-START: int Main.innerDiv() licm (after)
+ /// CHECK-DAG: Div loop:none
public static int innerDiv() {
int result = 0;
@@ -52,11 +52,11 @@
return result;
}
- // CHECK-START: int Main.innerDiv2() licm (before)
- // CHECK-DAG: Mul loop:B4
+ /// CHECK-START: int Main.innerDiv2() licm (before)
+ /// CHECK-DAG: Mul loop:B4
- // CHECK-START: int Main.innerDiv2() licm (after)
- // CHECK-DAG: Mul loop:B2
+ /// CHECK-START: int Main.innerDiv2() licm (after)
+ /// CHECK-DAG: Mul loop:B2
public static int innerDiv2() {
int result = 0;
@@ -71,11 +71,11 @@
return result;
}
- // CHECK-START: int Main.innerDiv3(int, int) licm (before)
- // CHECK-DAG: Div loop:{{B\d+}}
+ /// CHECK-START: int Main.innerDiv3(int, int) licm (before)
+ /// CHECK-DAG: Div loop:{{B\d+}}
- // CHECK-START: int Main.innerDiv3(int, int) licm (after)
- // CHECK-DAG: Div loop:{{B\d+}}
+ /// CHECK-START: int Main.innerDiv3(int, int) licm (after)
+ /// CHECK-DAG: Div loop:{{B\d+}}
public static int innerDiv3(int a, int b) {
int result = 0;
@@ -87,17 +87,17 @@
return result;
}
- // CHECK-START: int Main.arrayLength(int[]) licm (before)
- // CHECK-DAG: <<NullCheck:l\d+>> NullCheck loop:{{B\d+}}
- // CHECK-DAG: ArrayLength [<<NullCheck>>] loop:{{B\d+}}
+ /// CHECK-START: int Main.arrayLength(int[]) licm (before)
+ /// CHECK-DAG: <<NullCheck:l\d+>> NullCheck loop:{{B\d+}}
+ /// CHECK-DAG: ArrayLength [<<NullCheck>>] loop:{{B\d+}}
- // CHECK-START: int Main.arrayLength(int[]) licm (after)
- // CHECK-NOT: NullCheck loop:{{B\d+}}
- // CHECK-NOT: ArrayLength loop:{{B\d+}}
+ /// CHECK-START: int Main.arrayLength(int[]) licm (after)
+ /// CHECK-NOT: NullCheck loop:{{B\d+}}
+ /// CHECK-NOT: ArrayLength loop:{{B\d+}}
- // CHECK-START: int Main.arrayLength(int[]) licm (after)
- // CHECK-DAG: <<NullCheck:l\d+>> NullCheck loop:none
- // CHECK-DAG: ArrayLength [<<NullCheck>>] loop:none
+ /// CHECK-START: int Main.arrayLength(int[]) licm (after)
+ /// CHECK-DAG: <<NullCheck:l\d+>> NullCheck loop:none
+ /// CHECK-DAG: ArrayLength [<<NullCheck>>] loop:none
public static int arrayLength(int[] array) {
int result = 0;
diff --git a/test/446-checker-inliner2/src/Main.java b/test/446-checker-inliner2/src/Main.java
index 9ed66d6..de00a09 100644
--- a/test/446-checker-inliner2/src/Main.java
+++ b/test/446-checker-inliner2/src/Main.java
@@ -16,16 +16,16 @@
public class Main {
- // CHECK-START: int Main.inlineInstanceCall(Main) inliner (before)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.inlineInstanceCall(Main) inliner (before)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: int Main.inlineInstanceCall(Main) inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineInstanceCall(Main) inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
- // CHECK-START: int Main.inlineInstanceCall(Main) inliner (after)
- // CHECK-DAG: <<Field:i\d+>> InstanceFieldGet
- // CHECK-DAG: Return [<<Field>>]
+ /// CHECK-START: int Main.inlineInstanceCall(Main) inliner (after)
+ /// CHECK-DAG: <<Field:i\d+>> InstanceFieldGet
+ /// CHECK-DAG: Return [<<Field>>]
public static int inlineInstanceCall(Main m) {
return m.foo();
@@ -37,16 +37,16 @@
int field = 42;
- // CHECK-START: int Main.inlineNestedCall() inliner (before)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.inlineNestedCall() inliner (before)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: int Main.inlineNestedCall() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineNestedCall() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
- // CHECK-START: int Main.inlineNestedCall() inliner (after)
- // CHECK-DAG: <<Const38:i\d+>> IntConstant 38
- // CHECK-DAG: Return [<<Const38>>]
+ /// CHECK-START: int Main.inlineNestedCall() inliner (after)
+ /// CHECK-DAG: <<Const38:i\d+>> IntConstant 38
+ /// CHECK-DAG: Return [<<Const38>>]
public static int inlineNestedCall() {
return nestedCall();
diff --git a/test/447-checker-inliner3/src/Main.java b/test/447-checker-inliner3/src/Main.java
index 9d022b9..e3fdffd 100644
--- a/test/447-checker-inliner3/src/Main.java
+++ b/test/447-checker-inliner3/src/Main.java
@@ -16,12 +16,12 @@
public class Main {
- // CHECK-START: int Main.inlineIfThenElse() inliner (before)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.inlineIfThenElse() inliner (before)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: int Main.inlineIfThenElse() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineIfThenElse() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static int inlineIfThenElse() {
return foo(true);
@@ -35,11 +35,11 @@
}
}
- // CHECK-START: int Main.inlineInLoop() inliner (before)
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineInLoop() inliner (before)
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: int Main.inlineInLoop() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineInLoop() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static int inlineInLoop() {
int result = 0;
@@ -49,11 +49,11 @@
return result;
}
- // CHECK-START: int Main.inlineInLoopHeader() inliner (before)
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineInLoopHeader() inliner (before)
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: int Main.inlineInLoopHeader() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineInLoopHeader() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static int inlineInLoopHeader() {
int result = 0;
diff --git a/test/449-checker-bce/src/Main.java b/test/449-checker-bce/src/Main.java
index f90d85d..8960df8 100644
--- a/test/449-checker-bce/src/Main.java
+++ b/test/449-checker-bce/src/Main.java
@@ -16,21 +16,21 @@
public class Main {
- // CHECK-START: int Main.sieve(int) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: int Main.sieve(int) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: int Main.sieve(int) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: int Main.sieve(int) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
static int sieve(int size) {
int primeCount = 0;
@@ -47,25 +47,25 @@
}
- // CHECK-START: void Main.narrow(int[], int) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.narrow(int[], int) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.narrow(int[], int) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.narrow(int[], int) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
static void narrow(int[] array, int offset) {
if (offset < 0) {
@@ -108,18 +108,18 @@
}
- // CHECK-START: void Main.constantIndexing1(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantIndexing1(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.constantIndexing1(int[]) BCE (after)
- // CHECK-NOT: Deoptimize
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantIndexing1(int[]) BCE (after)
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
static void constantIndexing1(int[] array) {
array[5] = 1;
@@ -127,29 +127,29 @@
}
- // CHECK-START: void Main.constantIndexing2(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantIndexing2(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.constantIndexing2(int[]) BCE (after)
- // CHECK: LessThanOrEqual
- // CHECK: Deoptimize
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantIndexing2(int[]) BCE (after)
+ /// CHECK: LessThanOrEqual
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
static void constantIndexing2(int[] array) {
array[1] = 1;
@@ -160,45 +160,45 @@
}
- // CHECK-START: int[] Main.constantIndexing3(int[], int[], boolean) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: int[] Main.constantIndexing3(int[], int[], boolean) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: int[] Main.constantIndexing3(int[], int[], boolean) BCE (after)
- // CHECK: LessThanOrEqual
- // CHECK: Deoptimize
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: LessThanOrEqual
- // CHECK: Deoptimize
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: int[] Main.constantIndexing3(int[], int[], boolean) BCE (after)
+ /// CHECK: LessThanOrEqual
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: LessThanOrEqual
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
static int[] constantIndexing3(int[] array1, int[] array2, boolean copy) {
if (!copy) {
@@ -212,14 +212,14 @@
}
- // CHECK-START: void Main.constantIndexing4(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantIndexing4(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.constantIndexing4(int[]) BCE (after)
- // CHECK-NOT: LessThanOrEqual
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantIndexing4(int[]) BCE (after)
+ /// CHECK-NOT: LessThanOrEqual
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
// There is only one array access. It's not beneficial
// to create a compare with deoptimization instruction.
@@ -228,18 +228,18 @@
}
- // CHECK-START: void Main.constantIndexing5(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantIndexing5(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.constantIndexing5(int[]) BCE (after)
- // CHECK-NOT: Deoptimize
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantIndexing5(int[]) BCE (after)
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
static void constantIndexing5(int[] array) {
// We don't apply the deoptimization for very large constant index
@@ -249,37 +249,37 @@
array[Integer.MAX_VALUE - 998] = 1;
}
- // CHECK-START: void Main.loopPattern1(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.loopPattern1(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.loopPattern1(int[]) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.loopPattern1(int[]) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
static void loopPattern1(int[] array) {
for (int i = 0; i < array.length; i++) {
@@ -316,33 +316,33 @@
}
- // CHECK-START: void Main.loopPattern2(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.loopPattern2(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.loopPattern2(int[]) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.loopPattern2(int[]) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
static void loopPattern2(int[] array) {
for (int i = array.length - 1; i >= 0; i--) {
@@ -372,13 +372,13 @@
}
- // CHECK-START: void Main.loopPattern3(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.loopPattern3(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.loopPattern3(int[]) BCE (after)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.loopPattern3(int[]) BCE (after)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
static void loopPattern3(int[] array) {
java.util.Random random = new java.util.Random();
@@ -393,29 +393,29 @@
}
- // CHECK-START: void Main.constantNewArray() BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantNewArray() BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.constantNewArray() BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantNewArray() BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
static void constantNewArray() {
int[] array = new int[10];
@@ -437,13 +437,13 @@
return 1;
}
- // CHECK-START: void Main.circularBufferProducer() BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.circularBufferProducer() BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.circularBufferProducer() BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.circularBufferProducer() BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
static void circularBufferProducer() {
byte[] array = new byte[4096];
@@ -455,17 +455,17 @@
}
- // CHECK-START: void Main.pyramid1(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.pyramid1(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.pyramid1(int[]) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.pyramid1(int[]) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
// Set array to something like {0, 1, 2, 3, 2, 1, 0}.
static void pyramid1(int[] array) {
@@ -476,17 +476,17 @@
}
- // CHECK-START: void Main.pyramid2(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.pyramid2(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.pyramid2(int[]) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.pyramid2(int[]) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
// Set array to something like {0, 1, 2, 3, 2, 1, 0}.
static void pyramid2(int[] array) {
@@ -497,17 +497,17 @@
}
- // CHECK-START: void Main.pyramid3(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.pyramid3(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.pyramid3(int[]) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.pyramid3(int[]) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
// Set array to something like {0, 1, 2, 3, 2, 1, 0}.
static void pyramid3(int[] array) {
@@ -518,17 +518,17 @@
}
- // CHECK-START: boolean Main.isPyramid(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: boolean Main.isPyramid(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
- // CHECK-START: boolean Main.isPyramid(int[]) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: boolean Main.isPyramid(int[]) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
static boolean isPyramid(int[] array) {
int i = 0;
@@ -546,43 +546,43 @@
}
- // CHECK-START: void Main.bubbleSort(int[]) GVN (before)
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.bubbleSort(int[]) GVN (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.bubbleSort(int[]) GVN (after)
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: ArrayGet
- // CHECK-NOT: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.bubbleSort(int[]) GVN (after)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: ArrayGet
+ /// CHECK-NOT: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.bubbleSort(int[]) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: ArrayGet
- // CHECK-NOT: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.bubbleSort(int[]) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: ArrayGet
+ /// CHECK-NOT: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
static void bubbleSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
@@ -610,22 +610,22 @@
int sum;
- // CHECK-START: void Main.foo1(int[], int, int) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo1(int[], int, int) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
- // CHECK-START: void Main.foo1(int[], int, int) BCE (after)
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK-NOT: Deoptimize
- // CHECK: Phi
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo1(int[], int, int) BCE (after)
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: Phi
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
void foo1(int[] array, int start, int end) {
// Three HDeoptimize will be added. One for
@@ -639,22 +639,22 @@
}
- // CHECK-START: void Main.foo2(int[], int, int) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo2(int[], int, int) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
- // CHECK-START: void Main.foo2(int[], int, int) BCE (after)
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK-NOT: Deoptimize
- // CHECK: Phi
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo2(int[], int, int) BCE (after)
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: Phi
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
void foo2(int[] array, int start, int end) {
// Three HDeoptimize will be added. One for
@@ -668,21 +668,21 @@
}
- // CHECK-START: void Main.foo3(int[], int) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo3(int[], int) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
- // CHECK-START: void Main.foo3(int[], int) BCE (after)
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK-NOT: Deoptimize
- // CHECK: Phi
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo3(int[], int) BCE (after)
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: Phi
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
void foo3(int[] array, int end) {
// Two HDeoptimize will be added. One for end < array.length,
@@ -694,21 +694,21 @@
}
}
- // CHECK-START: void Main.foo4(int[], int) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo4(int[], int) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
- // CHECK-START: void Main.foo4(int[], int) BCE (after)
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK-NOT: Deoptimize
- // CHECK: Phi
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo4(int[], int) BCE (after)
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: Phi
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
void foo4(int[] array, int end) {
// Two HDeoptimize will be added. One for end <= array.length,
@@ -721,28 +721,28 @@
}
- // CHECK-START: void Main.foo5(int[], int) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo5(int[], int) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
- // CHECK-START: void Main.foo5(int[], int) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK: Deoptimize
- // CHECK-NOT: Deoptimize
- // CHECK: Phi
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo5(int[], int) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: Phi
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
void foo5(int[] array, int end) {
// Bounds check in this loop can be eliminated without deoptimization.
@@ -759,38 +759,38 @@
}
- // CHECK-START: void Main.foo6(int[], int, int) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.foo6(int[], int, int) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.foo6(int[], int, int) BCE (after)
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK-NOT: Deoptimize
- // CHECK: Phi
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.foo6(int[], int, int) BCE (after)
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: Phi
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
void foo6(int[] array, int start, int end) {
// Three HDeoptimize will be added. One for
@@ -803,22 +803,22 @@
}
- // CHECK-START: void Main.foo7(int[], int, int, boolean) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo7(int[], int, int, boolean) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
- // CHECK-START: void Main.foo7(int[], int, int, boolean) BCE (after)
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK-NOT: Deoptimize
- // CHECK: Phi
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo7(int[], int, int, boolean) BCE (after)
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: Phi
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
void foo7(int[] array, int start, int end, boolean lowEnd) {
// Three HDeoptimize will be added. One for
@@ -837,14 +837,14 @@
}
- // CHECK-START: void Main.partialLooping(int[], int, int) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.partialLooping(int[], int, int) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.partialLooping(int[], int, int) BCE (after)
- // CHECK-NOT: Deoptimize
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.partialLooping(int[], int, int) BCE (after)
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
void partialLooping(int[] array, int start, int end) {
// This loop doesn't cover the full range of [start, end) so
@@ -983,8 +983,8 @@
}
// Make sure this method is compiled with optimizing.
- // CHECK-START: void Main.main(java.lang.String[]) register (after)
- // CHECK: ParallelMove
+ /// CHECK-START: void Main.main(java.lang.String[]) register (after)
+ /// CHECK: ParallelMove
public static void main(String[] args) {
sieve(20);
diff --git a/test/450-checker-types/src/Main.java b/test/450-checker-types/src/Main.java
index 640aeb8..e907622 100644
--- a/test/450-checker-types/src/Main.java
+++ b/test/450-checker-types/src/Main.java
@@ -54,50 +54,50 @@
public class Main {
- // CHECK-START: void Main.testSimpleRemove() instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testSimpleRemove() instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testSimpleRemove() instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testSimpleRemove() instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testSimpleRemove() {
Super s = new SubclassA();
((SubclassA)s).g();
}
- // CHECK-START: void Main.testSimpleKeep(Super) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testSimpleKeep(Super) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testSimpleKeep(Super) instruction_simplifier_after_types (after)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testSimpleKeep(Super) instruction_simplifier_after_types (after)
+ /// CHECK: CheckCast
public void testSimpleKeep(Super s) {
((SubclassA)s).f();
}
- // CHECK-START: java.lang.String Main.testClassRemove() instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: java.lang.String Main.testClassRemove() instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: java.lang.String Main.testClassRemove() instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: java.lang.String Main.testClassRemove() instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public String testClassRemove() {
Object s = SubclassA.class;
return ((Class)s).getName();
}
- // CHECK-START: java.lang.String Main.testClassKeep() instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: java.lang.String Main.testClassKeep() instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: java.lang.String Main.testClassKeep() instruction_simplifier_after_types (after)
- // CHECK: CheckCast
+ /// CHECK-START: java.lang.String Main.testClassKeep() instruction_simplifier_after_types (after)
+ /// CHECK: CheckCast
public String testClassKeep() {
Object s = SubclassA.class;
return ((SubclassA)s).h();
}
- // CHECK-START: void Main.testIfRemove(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testIfRemove(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testIfRemove(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testIfRemove(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testIfRemove(int x) {
Super s;
if (x % 2 == 0) {
@@ -108,11 +108,11 @@
((SubclassA)s).g();
}
- // CHECK-START: void Main.testIfKeep(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testIfKeep(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testIfKeep(int) instruction_simplifier_after_types (after)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testIfKeep(int) instruction_simplifier_after_types (after)
+ /// CHECK: CheckCast
public void testIfKeep(int x) {
Super s;
if (x % 2 == 0) {
@@ -123,11 +123,11 @@
((SubclassA)s).g();
}
- // CHECK-START: void Main.testForRemove(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testForRemove(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testForRemove(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testForRemove(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testForRemove(int x) {
Super s = new SubclassA();
for (int i = 0 ; i < x; i++) {
@@ -138,11 +138,11 @@
((SubclassA)s).g();
}
- // CHECK-START: void Main.testForKeep(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testForKeep(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testForKeep(int) instruction_simplifier_after_types (after)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testForKeep(int) instruction_simplifier_after_types (after)
+ /// CHECK: CheckCast
public void testForKeep(int x) {
Super s = new SubclassA();
for (int i = 0 ; i < x; i++) {
@@ -153,11 +153,11 @@
((SubclassC)s).g();
}
- // CHECK-START: void Main.testPhiFromCall(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testPhiFromCall(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testPhiFromCall(int) instruction_simplifier_after_types (after)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testPhiFromCall(int) instruction_simplifier_after_types (after)
+ /// CHECK: CheckCast
public void testPhiFromCall(int i) {
Object x;
if (i % 2 == 0) {
@@ -168,12 +168,12 @@
((SubclassC)x).g();
}
- // CHECK-START: void Main.testInstanceOf(java.lang.Object) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOf(java.lang.Object) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOf(java.lang.Object) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testInstanceOf(java.lang.Object) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testInstanceOf(Object o) {
if (o instanceof SubclassC) {
((SubclassC)o).g();
@@ -183,13 +183,13 @@
}
}
- // CHECK-START: void Main.testInstanceOfKeep(java.lang.Object) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfKeep(java.lang.Object) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOfKeep(java.lang.Object) instruction_simplifier_after_types (after)
- // CHECK: CheckCast
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfKeep(java.lang.Object) instruction_simplifier_after_types (after)
+ /// CHECK: CheckCast
+ /// CHECK: CheckCast
public void testInstanceOfKeep(Object o) {
if (o instanceof SubclassC) {
((SubclassB)o).g();
@@ -199,12 +199,12 @@
}
}
- // CHECK-START: void Main.testInstanceOfNested(java.lang.Object) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfNested(java.lang.Object) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOfNested(java.lang.Object) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testInstanceOfNested(java.lang.Object) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testInstanceOfNested(Object o) {
if (o instanceof SubclassC) {
if (o instanceof SubclassB) {
@@ -215,11 +215,11 @@
}
}
- // CHECK-START: void Main.testInstanceOfWithPhi(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfWithPhi(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOfWithPhi(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testInstanceOfWithPhi(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testInstanceOfWithPhi(int i) {
Object o;
if (i == 0) {
@@ -233,11 +233,11 @@
}
}
- // CHECK-START: void Main.testInstanceOfInFor(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfInFor(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOfInFor(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testInstanceOfInFor(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testInstanceOfInFor(int n) {
Object o = new SubclassA();
for (int i = 0; i < n; i++) {
@@ -250,11 +250,11 @@
}
}
- // CHECK-START: void Main.testInstanceOfSubclass() instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfSubclass() instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOfSubclass() instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testInstanceOfSubclass() instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testInstanceOfSubclass() {
Object o = new SubclassA();
if (o instanceof Super) {
@@ -262,11 +262,11 @@
}
}
- // CHECK-START: void Main.testInstanceOfWithPhiSubclass(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfWithPhiSubclass(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOfWithPhiSubclass(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testInstanceOfWithPhiSubclass(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testInstanceOfWithPhiSubclass(int i) {
Object o;
if (i == 0) {
@@ -280,11 +280,11 @@
}
}
- // CHECK-START: void Main.testInstanceOfWithPhiTop(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfWithPhiTop(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOfWithPhiTop(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testInstanceOfWithPhiTop(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testInstanceOfWithPhiTop(int i) {
Object o;
if (i == 0) {
@@ -298,11 +298,11 @@
}
}
- // CHECK-START: void Main.testInstanceOfSubclassInFor(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfSubclassInFor(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOfSubclassInFor(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testInstanceOfSubclassInFor(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testInstanceOfSubclassInFor(int n) {
Object o = new SubclassA();
for (int i = 0; i < n; i++) {
@@ -315,11 +315,11 @@
}
}
- // CHECK-START: void Main.testInstanceOfTopInFor(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfTopInFor(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOfTopInFor(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testInstanceOfTopInFor(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testInstanceOfTopInFor(int n) {
Object o = new SubclassA();
for (int i = 0; i < n; i++) {
diff --git a/test/455-checker-gvn/src/Main.java b/test/455-checker-gvn/src/Main.java
index e94fc46..9824f27 100644
--- a/test/455-checker-gvn/src/Main.java
+++ b/test/455-checker-gvn/src/Main.java
@@ -19,15 +19,15 @@
System.out.println(foo(3, 4));
}
- // CHECK-START: int Main.foo(int, int) GVN (before)
- // CHECK: Add
- // CHECK: Add
- // CHECK: Add
+ /// CHECK-START: int Main.foo(int, int) GVN (before)
+ /// CHECK: Add
+ /// CHECK: Add
+ /// CHECK: Add
- // CHECK-START: int Main.foo(int, int) GVN (after)
- // CHECK: Add
- // CHECK: Add
- // CHECK-NOT: Add
+ /// CHECK-START: int Main.foo(int, int) GVN (after)
+ /// CHECK: Add
+ /// CHECK: Add
+ /// CHECK-NOT: Add
public static int foo(int x, int y) {
int sum1 = x + y;
diff --git a/test/458-checker-instruction-simplification/src/Main.java b/test/458-checker-instruction-simplification/src/Main.java
index 742210c..ad5fc8e 100644
--- a/test/458-checker-instruction-simplification/src/Main.java
+++ b/test/458-checker-instruction-simplification/src/Main.java
@@ -50,296 +50,296 @@
* Tiny programs exercising optimizations of arithmetic identities.
*/
- // CHECK-START: long Main.Add0(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-DAG: <<Add:j\d+>> Add [<<Const0>>,<<Arg>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: long Main.Add0(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-DAG: <<Add:j\d+>> Add [<<Const0>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: long Main.Add0(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.Add0(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.Add0(long) instruction_simplifier (after)
- // CHECK-NOT: Add
+ /// CHECK-START: long Main.Add0(long) instruction_simplifier (after)
+ /// CHECK-NOT: Add
public static long Add0(long arg) {
return 0 + arg;
}
- // CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
- // CHECK-DAG: <<And:i\d+>> And [<<Arg>>,<<ConstF>>]
- // CHECK-DAG: Return [<<And>>]
+ /// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
+ /// CHECK-DAG: <<And:i\d+>> And [<<Arg>>,<<ConstF>>]
+ /// CHECK-DAG: Return [<<And>>]
- // CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after)
- // CHECK-NOT: And
+ /// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after)
+ /// CHECK-NOT: And
public static int AndAllOnes(int arg) {
return arg & -1;
}
- // CHECK-START: long Main.Div1(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const1:j\d+>> LongConstant 1
- // CHECK-DAG: <<Div:j\d+>> Div [<<Arg>>,<<Const1>>]
- // CHECK-DAG: Return [<<Div>>]
+ /// CHECK-START: long Main.Div1(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:j\d+>> LongConstant 1
+ /// CHECK-DAG: <<Div:j\d+>> Div [<<Arg>>,<<Const1>>]
+ /// CHECK-DAG: Return [<<Div>>]
- // CHECK-START: long Main.Div1(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.Div1(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.Div1(long) instruction_simplifier (after)
- // CHECK-NOT: Div
+ /// CHECK-START: long Main.Div1(long) instruction_simplifier (after)
+ /// CHECK-NOT: Div
public static long Div1(long arg) {
return arg / 1;
}
- // CHECK-START: int Main.DivN1(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<ConstN1:i\d+>> IntConstant -1
- // CHECK-DAG: <<Div:i\d+>> Div [<<Arg>>,<<ConstN1>>]
- // CHECK-DAG: Return [<<Div>>]
+ /// CHECK-START: int Main.DivN1(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstN1:i\d+>> IntConstant -1
+ /// CHECK-DAG: <<Div:i\d+>> Div [<<Arg>>,<<ConstN1>>]
+ /// CHECK-DAG: Return [<<Div>>]
- // CHECK-START: int Main.DivN1(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.DivN1(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
+ /// CHECK-DAG: Return [<<Neg>>]
- // CHECK-START: int Main.DivN1(int) instruction_simplifier (after)
- // CHECK-NOT: Div
+ /// CHECK-START: int Main.DivN1(int) instruction_simplifier (after)
+ /// CHECK-NOT: Div
public static int DivN1(int arg) {
return arg / -1;
}
- // CHECK-START: long Main.Mul1(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const1:j\d+>> LongConstant 1
- // CHECK-DAG: <<Mul:j\d+>> Mul [<<Arg>>,<<Const1>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: long Main.Mul1(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:j\d+>> LongConstant 1
+ /// CHECK-DAG: <<Mul:j\d+>> Mul [<<Arg>>,<<Const1>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: long Main.Mul1(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.Mul1(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.Mul1(long) instruction_simplifier (after)
- // CHECK-NOT: Mul
+ /// CHECK-START: long Main.Mul1(long) instruction_simplifier (after)
+ /// CHECK-NOT: Mul
public static long Mul1(long arg) {
return arg * 1;
}
- // CHECK-START: int Main.MulN1(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<ConstN1:i\d+>> IntConstant -1
- // CHECK-DAG: <<Mul:i\d+>> Mul [<<Arg>>,<<ConstN1>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: int Main.MulN1(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstN1:i\d+>> IntConstant -1
+ /// CHECK-DAG: <<Mul:i\d+>> Mul [<<Arg>>,<<ConstN1>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: int Main.MulN1(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.MulN1(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
+ /// CHECK-DAG: Return [<<Neg>>]
- // CHECK-START: int Main.MulN1(int) instruction_simplifier (after)
- // CHECK-NOT: Mul
+ /// CHECK-START: int Main.MulN1(int) instruction_simplifier (after)
+ /// CHECK-NOT: Mul
public static int MulN1(int arg) {
return arg * -1;
}
- // CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const128:j\d+>> LongConstant 128
- // CHECK-DAG: <<Mul:j\d+>> Mul [<<Arg>>,<<Const128>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const128:j\d+>> LongConstant 128
+ /// CHECK-DAG: <<Mul:j\d+>> Mul [<<Arg>>,<<Const128>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const7:i\d+>> IntConstant 7
- // CHECK-DAG: <<Shl:j\d+>> Shl [<<Arg>>,<<Const7>>]
- // CHECK-DAG: Return [<<Shl>>]
+ /// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const7:i\d+>> IntConstant 7
+ /// CHECK-DAG: <<Shl:j\d+>> Shl [<<Arg>>,<<Const7>>]
+ /// CHECK-DAG: Return [<<Shl>>]
- // CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after)
- // CHECK-NOT: Mul
+ /// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after)
+ /// CHECK-NOT: Mul
public static long MulPowerOfTwo128(long arg) {
return arg * 128;
}
- // CHECK-START: int Main.Or0(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Or:i\d+>> Or [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.Or0(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.Or0(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: int Main.Or0(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: int Main.Or0(int) instruction_simplifier (after)
- // CHECK-NOT: Or
+ /// CHECK-START: int Main.Or0(int) instruction_simplifier (after)
+ /// CHECK-NOT: Or
public static int Or0(int arg) {
return arg | 0;
}
- // CHECK-START: long Main.OrSame(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Or:j\d+>> Or [<<Arg>>,<<Arg>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: long Main.OrSame(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Or:j\d+>> Or [<<Arg>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: long Main.OrSame(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.OrSame(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.OrSame(long) instruction_simplifier (after)
- // CHECK-NOT: Or
+ /// CHECK-START: long Main.OrSame(long) instruction_simplifier (after)
+ /// CHECK-NOT: Or
public static long OrSame(long arg) {
return arg | arg;
}
- // CHECK-START: int Main.Shl0(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Shl:i\d+>> Shl [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<Shl>>]
+ /// CHECK-START: int Main.Shl0(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Shl:i\d+>> Shl [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Shl>>]
- // CHECK-START: int Main.Shl0(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: int Main.Shl0(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: int Main.Shl0(int) instruction_simplifier (after)
- // CHECK-NOT: Shl
+ /// CHECK-START: int Main.Shl0(int) instruction_simplifier (after)
+ /// CHECK-NOT: Shl
public static int Shl0(int arg) {
return arg << 0;
}
- // CHECK-START: int Main.Shl1(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Shl:i\d+>> Shl [<<Arg>>,<<Const1>>]
- // CHECK-DAG: Return [<<Shl>>]
+ /// CHECK-START: int Main.Shl1(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Shl:i\d+>> Shl [<<Arg>>,<<Const1>>]
+ /// CHECK-DAG: Return [<<Shl>>]
- // CHECK-START: int Main.Shl1(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Add:i\d+>> Add [<<Arg>>,<<Arg>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.Shl1(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Arg>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: int Main.Shl1(int) instruction_simplifier (after)
- // CHECK-NOT: Shl
+ /// CHECK-START: int Main.Shl1(int) instruction_simplifier (after)
+ /// CHECK-NOT: Shl
public static int Shl1(int arg) {
return arg << 1;
}
- // CHECK-START: long Main.Shr0(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Shr:j\d+>> Shr [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<Shr>>]
+ /// CHECK-START: long Main.Shr0(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Shr:j\d+>> Shr [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Shr>>]
- // CHECK-START: long Main.Shr0(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.Shr0(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.Shr0(long) instruction_simplifier (after)
- // CHECK-NOT: Shr
+ /// CHECK-START: long Main.Shr0(long) instruction_simplifier (after)
+ /// CHECK-NOT: Shr
public static long Shr0(long arg) {
return arg >> 0;
}
- // CHECK-START: long Main.Sub0(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: long Main.Sub0(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: long Main.Sub0(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.Sub0(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.Sub0(long) instruction_simplifier (after)
- // CHECK-NOT: Sub
+ /// CHECK-START: long Main.Sub0(long) instruction_simplifier (after)
+ /// CHECK-NOT: Sub
public static long Sub0(long arg) {
return arg - 0;
}
- // CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Const0>>,<<Arg>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const0>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
+ /// CHECK-DAG: Return [<<Neg>>]
- // CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after)
- // CHECK-NOT: Sub
+ /// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after)
+ /// CHECK-NOT: Sub
public static int SubAliasNeg(int arg) {
return 0 - arg;
}
- // CHECK-START: long Main.UShr0(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<UShr:j\d+>> UShr [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<UShr>>]
+ /// CHECK-START: long Main.UShr0(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<UShr:j\d+>> UShr [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<UShr>>]
- // CHECK-START: long Main.UShr0(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.UShr0(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.UShr0(long) instruction_simplifier (after)
- // CHECK-NOT: UShr
+ /// CHECK-START: long Main.UShr0(long) instruction_simplifier (after)
+ /// CHECK-NOT: UShr
public static long UShr0(long arg) {
return arg >>> 0;
}
- // CHECK-START: int Main.Xor0(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<Xor>>]
+ /// CHECK-START: int Main.Xor0(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Xor>>]
- // CHECK-START: int Main.Xor0(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: int Main.Xor0(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: int Main.Xor0(int) instruction_simplifier (after)
- // CHECK-NOT: Xor
+ /// CHECK-START: int Main.Xor0(int) instruction_simplifier (after)
+ /// CHECK-NOT: Xor
public static int Xor0(int arg) {
return arg ^ 0;
}
- // CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
- // CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<ConstF>>]
- // CHECK-DAG: Return [<<Xor>>]
+ /// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
+ /// CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<ConstF>>]
+ /// CHECK-DAG: Return [<<Xor>>]
- // CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Not:i\d+>> Not [<<Arg>>]
- // CHECK-DAG: Return [<<Not>>]
+ /// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Not:i\d+>> Not [<<Arg>>]
+ /// CHECK-DAG: Return [<<Not>>]
- // CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after)
- // CHECK-NOT: Xor
+ /// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after)
+ /// CHECK-NOT: Xor
public static int XorAllOnes(int arg) {
return arg ^ -1;
@@ -352,21 +352,21 @@
* `InstructionSimplifierVisitor::TryMoveNegOnInputsAfterBinop`.
*/
- // CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
- // CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-NOT: Neg
- // CHECK-DAG: <<Add:i\d+>> Add [<<Arg1>>,<<Arg2>>]
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Add>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-NOT: Neg
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Arg1>>,<<Arg2>>]
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Add>>]
+ /// CHECK-DAG: Return [<<Neg>>]
public static int AddNegs1(int arg1, int arg2) {
return -arg1 + -arg2;
@@ -383,35 +383,35 @@
* increasing the register pressure by creating or extending live ranges.
*/
- // CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
- // CHECK-DAG: <<Add1:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: <<Add2:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: <<Or:i\d+>> Or [<<Add1>>,<<Add2>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
+ /// CHECK-DAG: <<Add1:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: <<Add2:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Add1>>,<<Add2>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
- // CHECK-DAG: <<Add1:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: <<Add2:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-NOT: Neg
- // CHECK-DAG: <<Or:i\d+>> Or [<<Add1>>,<<Add2>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
+ /// CHECK-DAG: <<Add1:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: <<Add2:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-NOT: Neg
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Add1>>,<<Add2>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.AddNegs2(int, int) GVN (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
- // CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: <<Or:i\d+>> Or [<<Add>>,<<Add>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.AddNegs2(int, int) GVN (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Add>>,<<Add>>]
+ /// CHECK-DAG: Return [<<Or>>]
public static int AddNegs2(int arg1, int arg2) {
int temp1 = -arg1;
@@ -427,30 +427,30 @@
* the loop.
*/
- // CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (before)
- // -------------- Arguments and initial negation operations.
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Neg2:j\d+>> Neg [<<Arg2>>]
- // CHECK: Goto
- // -------------- Loop
- // CHECK: SuspendCheck
- // CHECK: <<Add:j\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK: Goto
+ /// CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (before)
+ // -------------- Arguments and initial negation operations.
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Neg2:j\d+>> Neg [<<Arg2>>]
+ /// CHECK: Goto
+ // -------------- Loop
+ /// CHECK: SuspendCheck
+ /// CHECK: <<Add:j\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK: Goto
- // CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (after)
- // -------------- Arguments and initial negation operations.
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Neg2:j\d+>> Neg [<<Arg2>>]
- // CHECK: Goto
- // -------------- Loop
- // CHECK: SuspendCheck
- // CHECK: <<Add:j\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-NOT: Neg
- // CHECK: Goto
+ /// CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (after)
+ // -------------- Arguments and initial negation operations.
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Neg2:j\d+>> Neg [<<Arg2>>]
+ /// CHECK: Goto
+ // -------------- Loop
+ /// CHECK: SuspendCheck
+ /// CHECK: <<Add:j\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-NOT: Neg
+ /// CHECK: Goto
public static long AddNegs3(long arg1, long arg2) {
long res = 0;
@@ -468,22 +468,22 @@
* The transformation tested is implemented in `InstructionSimplifierVisitor::VisitAdd`.
*/
- // CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Add:j\d+>> Add [<<Neg>>,<<Arg2>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Add:j\d+>> Add [<<Neg>>,<<Arg2>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg2>>,<<Arg1>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg2>>,<<Arg1>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after)
- // CHECK-NOT: Neg
- // CHECK-NOT: Add
+ /// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after)
+ /// CHECK-NOT: Neg
+ /// CHECK-NOT: Add
public static long AddNeg1(long arg1, long arg2) {
return -arg1 + arg2;
@@ -498,26 +498,26 @@
* increasing the register pressure by creating or extending live ranges.
*/
- // CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg2>>]
- // CHECK-DAG: <<Add1:j\d+>> Add [<<Arg1>>,<<Neg>>]
- // CHECK-DAG: <<Add2:j\d+>> Add [<<Arg1>>,<<Neg>>]
- // CHECK-DAG: <<Res:j\d+>> Or [<<Add1>>,<<Add2>>]
- // CHECK-DAG: Return [<<Res>>]
+ /// CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg2>>]
+ /// CHECK-DAG: <<Add1:j\d+>> Add [<<Arg1>>,<<Neg>>]
+ /// CHECK-DAG: <<Add2:j\d+>> Add [<<Arg1>>,<<Neg>>]
+ /// CHECK-DAG: <<Res:j\d+>> Or [<<Add1>>,<<Add2>>]
+ /// CHECK-DAG: Return [<<Res>>]
- // CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg2>>]
- // CHECK-DAG: <<Add1:j\d+>> Add [<<Arg1>>,<<Neg>>]
- // CHECK-DAG: <<Add2:j\d+>> Add [<<Arg1>>,<<Neg>>]
- // CHECK-DAG: <<Res:j\d+>> Or [<<Add1>>,<<Add2>>]
- // CHECK-DAG: Return [<<Res>>]
+ /// CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg2>>]
+ /// CHECK-DAG: <<Add1:j\d+>> Add [<<Arg1>>,<<Neg>>]
+ /// CHECK-DAG: <<Add2:j\d+>> Add [<<Arg1>>,<<Neg>>]
+ /// CHECK-DAG: <<Res:j\d+>> Or [<<Add1>>,<<Add2>>]
+ /// CHECK-DAG: Return [<<Res>>]
- // CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after)
- // CHECK-NOT: Sub
+ /// CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after)
+ /// CHECK-NOT: Sub
public static long AddNeg2(long arg1, long arg2) {
long temp = -arg2;
@@ -529,18 +529,18 @@
* The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNeg`.
*/
- // CHECK-START: long Main.NegNeg1(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg>>]
- // CHECK-DAG: <<Neg2:j\d+>> Neg [<<Neg1>>]
- // CHECK-DAG: Return [<<Neg2>>]
+ /// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg>>]
+ /// CHECK-DAG: <<Neg2:j\d+>> Neg [<<Neg1>>]
+ /// CHECK-DAG: Return [<<Neg2>>]
- // CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after)
- // CHECK-NOT: Neg
+ /// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after)
+ /// CHECK-NOT: Neg
public static long NegNeg1(long arg) {
return -(-arg);
@@ -553,27 +553,27 @@
* and in `InstructionSimplifierVisitor::VisitAdd`.
*/
- // CHECK-START: int Main.NegNeg2(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Neg1>>]
- // CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Neg1>>]
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg>>,<<Arg>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after)
- // CHECK-NOT: Neg
- // CHECK-NOT: Add
+ /// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after)
+ /// CHECK-NOT: Neg
+ /// CHECK-NOT: Add
- // CHECK-START: int Main.NegNeg2(int) constant_folding_after_inlining (after)
- // CHECK: <<Const0:i\d+>> IntConstant 0
- // CHECK-NOT: Neg
- // CHECK-NOT: Add
- // CHECK: Return [<<Const0>>]
+ /// CHECK-START: int Main.NegNeg2(int) constant_folding_after_inlining (after)
+ /// CHECK: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-NOT: Neg
+ /// CHECK-NOT: Add
+ /// CHECK: Return [<<Const0>>]
public static int NegNeg2(int arg) {
int temp = -arg;
@@ -587,20 +587,20 @@
* and in `InstructionSimplifierVisitor::VisitSub`.
*/
- // CHECK-START: long Main.NegNeg3(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg>>]
- // CHECK-DAG: <<Sub:j\d+>> Sub [<<Const0>>,<<Neg>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg>>]
+ /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Const0>>,<<Neg>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after)
- // CHECK-NOT: Neg
- // CHECK-NOT: Sub
+ /// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after)
+ /// CHECK-NOT: Neg
+ /// CHECK-NOT: Sub
public static long NegNeg3(long arg) {
return 0 - -arg;
@@ -612,21 +612,21 @@
* The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNeg`.
*/
- // CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>]
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Sub>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>]
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Sub>>]
+ /// CHECK-DAG: Return [<<Neg>>]
- // CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg2>>,<<Arg1>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg2>>,<<Arg1>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after)
- // CHECK-NOT: Neg
+ /// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after)
+ /// CHECK-NOT: Neg
public static int NegSub1(int arg1, int arg2) {
return -(arg1 - arg2);
@@ -642,23 +642,23 @@
* increasing the register pressure by creating or extending live ranges.
*/
- // CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>]
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Sub>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Sub>>]
- // CHECK-DAG: <<Or:i\d+>> Or [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>]
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Sub>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Sub>>]
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>]
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Sub>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Sub>>]
- // CHECK-DAG: <<Or:i\d+>> Or [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>]
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Sub>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Sub>>]
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: Return [<<Or>>]
public static int NegSub2(int arg1, int arg2) {
int temp = arg1 - arg2;
@@ -670,40 +670,40 @@
* The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNot`.
*/
- // CHECK-START: long Main.NotNot1(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<ConstF1:j\d+>> LongConstant -1
- // CHECK-DAG: <<Xor1:j\d+>> Xor [<<Arg>>,<<ConstF1>>]
- // CHECK-DAG: <<Xor2:j\d+>> Xor [<<Xor1>>,<<ConstF1>>]
- // CHECK-DAG: Return [<<Xor2>>]
+ /// CHECK-START: long Main.NotNot1(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstF1:j\d+>> LongConstant -1
+ /// CHECK-DAG: <<Xor1:j\d+>> Xor [<<Arg>>,<<ConstF1>>]
+ /// CHECK-DAG: <<Xor2:j\d+>> Xor [<<Xor1>>,<<ConstF1>>]
+ /// CHECK-DAG: Return [<<Xor2>>]
- // CHECK-START: long Main.NotNot1(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.NotNot1(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.NotNot1(long) instruction_simplifier (after)
- // CHECK-NOT: Xor
+ /// CHECK-START: long Main.NotNot1(long) instruction_simplifier (after)
+ /// CHECK-NOT: Xor
public static long NotNot1(long arg) {
return ~~arg;
}
- // CHECK-START: int Main.NotNot2(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<ConstF1:i\d+>> IntConstant -1
- // CHECK-DAG: <<Xor1:i\d+>> Xor [<<Arg>>,<<ConstF1>>]
- // CHECK-DAG: <<Xor2:i\d+>> Xor [<<Xor1>>,<<ConstF1>>]
- // CHECK-DAG: <<Add:i\d+>> Add [<<Xor1>>,<<Xor2>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.NotNot2(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstF1:i\d+>> IntConstant -1
+ /// CHECK-DAG: <<Xor1:i\d+>> Xor [<<Arg>>,<<ConstF1>>]
+ /// CHECK-DAG: <<Xor2:i\d+>> Xor [<<Xor1>>,<<ConstF1>>]
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Xor1>>,<<Xor2>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: int Main.NotNot2(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Not:i\d+>> Not [<<Arg>>]
- // CHECK-DAG: <<Add:i\d+>> Add [<<Not>>,<<Arg>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.NotNot2(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Not:i\d+>> Not [<<Arg>>]
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Not>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: int Main.NotNot2(int) instruction_simplifier (after)
- // CHECK-NOT: Xor
+ /// CHECK-START: int Main.NotNot2(int) instruction_simplifier (after)
+ /// CHECK-NOT: Xor
public static int NotNot2(int arg) {
int temp = ~arg;
@@ -715,22 +715,22 @@
* The transformation tested is implemented in `InstructionSimplifierVisitor::VisitSub`.
*/
- // CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Add:i\d+>> Add [<<Arg1>>,<<Arg2>>]
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Add>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Arg1>>,<<Arg2>>]
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Add>>]
+ /// CHECK-DAG: Return [<<Neg>>]
- // CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after)
- // CHECK-NOT: Sub
+ /// CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after)
+ /// CHECK-NOT: Sub
public static int SubNeg1(int arg1, int arg2) {
return -arg1 - arg2;
@@ -746,26 +746,26 @@
* increasing the register pressure by creating or extending live ranges.
*/
- // CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Sub1:i\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK-DAG: <<Sub2:i\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK-DAG: <<Or:i\d+>> Or [<<Sub1>>,<<Sub2>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Sub1:i\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK-DAG: <<Sub2:i\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Sub1>>,<<Sub2>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Sub1:i\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK-DAG: <<Sub2:i\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK-DAG: <<Or:i\d+>> Or [<<Sub1>>,<<Sub2>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Sub1:i\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK-DAG: <<Sub2:i\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Sub1>>,<<Sub2>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after)
- // CHECK-NOT: Add
+ /// CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after)
+ /// CHECK-NOT: Add
public static int SubNeg2(int arg1, int arg2) {
int temp = -arg1;
@@ -779,28 +779,28 @@
* the loop.
*/
- // CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (before)
- // -------------- Arguments and initial negation operation.
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>]
- // CHECK: Goto
- // -------------- Loop
- // CHECK: SuspendCheck
- // CHECK: <<Sub:j\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK: Goto
+ /// CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (before)
+ // -------------- Arguments and initial negation operation.
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>]
+ /// CHECK: Goto
+ // -------------- Loop
+ /// CHECK: SuspendCheck
+ /// CHECK: <<Sub:j\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK: Goto
- // CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (after)
- // -------------- Arguments and initial negation operation.
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: Goto
- // -------------- Loop
- // CHECK: SuspendCheck
- // CHECK: <<Sub:j\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK-NOT: Neg
- // CHECK: Goto
+ /// CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (after)
+ // -------------- Arguments and initial negation operation.
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: Goto
+ // -------------- Loop
+ /// CHECK: SuspendCheck
+ /// CHECK: <<Sub:j\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK-NOT: Neg
+ /// CHECK: Goto
public static long SubNeg3(long arg1, long arg2) {
long res = 0;
@@ -811,117 +811,117 @@
return res;
}
- // CHECK-START: int Main.EqualTrueRhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> Equal [<<Arg>>,<<Const1>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.EqualTrueRhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> Equal [<<Arg>>,<<Const1>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.EqualTrueRhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: If [<<Arg>>]
+ /// CHECK-START: int Main.EqualTrueRhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: If [<<Arg>>]
public static int EqualTrueRhs(boolean arg) {
return (arg != true) ? 3 : 5;
}
- // CHECK-START: int Main.EqualTrueLhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> Equal [<<Const1>>,<<Arg>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.EqualTrueLhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> Equal [<<Const1>>,<<Arg>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.EqualTrueLhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: If [<<Arg>>]
+ /// CHECK-START: int Main.EqualTrueLhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: If [<<Arg>>]
public static int EqualTrueLhs(boolean arg) {
return (true != arg) ? 3 : 5;
}
- // CHECK-START: int Main.EqualFalseRhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Cond:z\d+>> Equal [<<Arg>>,<<Const0>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.EqualFalseRhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Cond:z\d+>> Equal [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.EqualFalseRhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
- // CHECK-DAG: If [<<NotArg>>]
+ /// CHECK-START: int Main.EqualFalseRhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ /// CHECK-DAG: If [<<NotArg>>]
public static int EqualFalseRhs(boolean arg) {
return (arg != false) ? 3 : 5;
}
- // CHECK-START: int Main.EqualFalseLhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Cond:z\d+>> Equal [<<Const0>>,<<Arg>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.EqualFalseLhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Cond:z\d+>> Equal [<<Const0>>,<<Arg>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.EqualFalseLhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
- // CHECK-DAG: If [<<NotArg>>]
+ /// CHECK-START: int Main.EqualFalseLhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ /// CHECK-DAG: If [<<NotArg>>]
public static int EqualFalseLhs(boolean arg) {
return (false != arg) ? 3 : 5;
}
- // CHECK-START: int Main.NotEqualTrueRhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Arg>>,<<Const1>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.NotEqualTrueRhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Arg>>,<<Const1>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.NotEqualTrueRhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
- // CHECK-DAG: If [<<NotArg>>]
+ /// CHECK-START: int Main.NotEqualTrueRhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ /// CHECK-DAG: If [<<NotArg>>]
public static int NotEqualTrueRhs(boolean arg) {
return (arg == true) ? 3 : 5;
}
- // CHECK-START: int Main.NotEqualTrueLhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Const1>>,<<Arg>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.NotEqualTrueLhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Const1>>,<<Arg>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.NotEqualTrueLhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
- // CHECK-DAG: If [<<NotArg>>]
+ /// CHECK-START: int Main.NotEqualTrueLhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ /// CHECK-DAG: If [<<NotArg>>]
public static int NotEqualTrueLhs(boolean arg) {
return (true == arg) ? 3 : 5;
}
- // CHECK-START: int Main.NotEqualFalseRhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Arg>>,<<Const0>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.NotEqualFalseRhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.NotEqualFalseRhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: If [<<Arg>>]
+ /// CHECK-START: int Main.NotEqualFalseRhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: If [<<Arg>>]
public static int NotEqualFalseRhs(boolean arg) {
return (arg == false) ? 3 : 5;
}
- // CHECK-START: int Main.NotEqualFalseLhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Const0>>,<<Arg>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.NotEqualFalseLhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Const0>>,<<Arg>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.NotEqualFalseLhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: If [<<Arg>>]
+ /// CHECK-START: int Main.NotEqualFalseLhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: If [<<Arg>>]
public static int NotEqualFalseLhs(boolean arg) {
return (false == arg) ? 3 : 5;
@@ -933,20 +933,20 @@
* remove the second.
*/
- // CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
- // CHECK-DAG: <<NotNotArg:z\d+>> BooleanNot [<<NotArg>>]
- // CHECK-DAG: Return [<<NotNotArg>>]
+ /// CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ /// CHECK-DAG: <<NotNotArg:z\d+>> BooleanNot [<<NotArg>>]
+ /// CHECK-DAG: Return [<<NotNotArg>>]
- // CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: BooleanNot [<<Arg>>]
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: BooleanNot [<<Arg>>]
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (after)
- // CHECK: BooleanNot
- // CHECK-NOT: BooleanNot
+ /// CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (after)
+ /// CHECK: BooleanNot
+ /// CHECK-NOT: BooleanNot
public static boolean NegateValue(boolean arg) {
return !arg;
@@ -956,76 +956,76 @@
return !(NegateValue(arg));
}
- // CHECK-START: float Main.Div2(float) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:f\d+>> ParameterValue
- // CHECK-DAG: <<Const2:f\d+>> FloatConstant 2
- // CHECK-DAG: <<Div:f\d+>> Div [<<Arg>>,<<Const2>>]
- // CHECK-DAG: Return [<<Div>>]
+ /// CHECK-START: float Main.Div2(float) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:f\d+>> ParameterValue
+ /// CHECK-DAG: <<Const2:f\d+>> FloatConstant 2
+ /// CHECK-DAG: <<Div:f\d+>> Div [<<Arg>>,<<Const2>>]
+ /// CHECK-DAG: Return [<<Div>>]
- // CHECK-START: float Main.Div2(float) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:f\d+>> ParameterValue
- // CHECK-DAG: <<ConstP5:f\d+>> FloatConstant 0.5
- // CHECK-DAG: <<Mul:f\d+>> Mul [<<Arg>>,<<ConstP5>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: float Main.Div2(float) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:f\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstP5:f\d+>> FloatConstant 0.5
+ /// CHECK-DAG: <<Mul:f\d+>> Mul [<<Arg>>,<<ConstP5>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: float Main.Div2(float) instruction_simplifier (after)
- // CHECK-NOT: Div
+ /// CHECK-START: float Main.Div2(float) instruction_simplifier (after)
+ /// CHECK-NOT: Div
public static float Div2(float arg) {
return arg / 2.0f;
}
- // CHECK-START: double Main.Div2(double) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:d\d+>> ParameterValue
- // CHECK-DAG: <<Const2:d\d+>> DoubleConstant 2
- // CHECK-DAG: <<Div:d\d+>> Div [<<Arg>>,<<Const2>>]
- // CHECK-DAG: Return [<<Div>>]
+ /// CHECK-START: double Main.Div2(double) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:d\d+>> ParameterValue
+ /// CHECK-DAG: <<Const2:d\d+>> DoubleConstant 2
+ /// CHECK-DAG: <<Div:d\d+>> Div [<<Arg>>,<<Const2>>]
+ /// CHECK-DAG: Return [<<Div>>]
- // CHECK-START: double Main.Div2(double) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:d\d+>> ParameterValue
- // CHECK-DAG: <<ConstP5:d\d+>> DoubleConstant 0.5
- // CHECK-DAG: <<Mul:d\d+>> Mul [<<Arg>>,<<ConstP5>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: double Main.Div2(double) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:d\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstP5:d\d+>> DoubleConstant 0.5
+ /// CHECK-DAG: <<Mul:d\d+>> Mul [<<Arg>>,<<ConstP5>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: double Main.Div2(double) instruction_simplifier (after)
- // CHECK-NOT: Div
+ /// CHECK-START: double Main.Div2(double) instruction_simplifier (after)
+ /// CHECK-NOT: Div
public static double Div2(double arg) {
return arg / 2.0;
}
- // CHECK-START: float Main.DivMP25(float) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:f\d+>> ParameterValue
- // CHECK-DAG: <<ConstMP25:f\d+>> FloatConstant -0.25
- // CHECK-DAG: <<Div:f\d+>> Div [<<Arg>>,<<ConstMP25>>]
- // CHECK-DAG: Return [<<Div>>]
+ /// CHECK-START: float Main.DivMP25(float) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:f\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstMP25:f\d+>> FloatConstant -0.25
+ /// CHECK-DAG: <<Div:f\d+>> Div [<<Arg>>,<<ConstMP25>>]
+ /// CHECK-DAG: Return [<<Div>>]
- // CHECK-START: float Main.DivMP25(float) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:f\d+>> ParameterValue
- // CHECK-DAG: <<ConstM4:f\d+>> FloatConstant -4
- // CHECK-DAG: <<Mul:f\d+>> Mul [<<Arg>>,<<ConstM4>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: float Main.DivMP25(float) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:f\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstM4:f\d+>> FloatConstant -4
+ /// CHECK-DAG: <<Mul:f\d+>> Mul [<<Arg>>,<<ConstM4>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: float Main.DivMP25(float) instruction_simplifier (after)
- // CHECK-NOT: Div
+ /// CHECK-START: float Main.DivMP25(float) instruction_simplifier (after)
+ /// CHECK-NOT: Div
public static float DivMP25(float arg) {
return arg / -0.25f;
}
- // CHECK-START: double Main.DivMP25(double) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:d\d+>> ParameterValue
- // CHECK-DAG: <<ConstMP25:d\d+>> DoubleConstant -0.25
- // CHECK-DAG: <<Div:d\d+>> Div [<<Arg>>,<<ConstMP25>>]
- // CHECK-DAG: Return [<<Div>>]
+ /// CHECK-START: double Main.DivMP25(double) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:d\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstMP25:d\d+>> DoubleConstant -0.25
+ /// CHECK-DAG: <<Div:d\d+>> Div [<<Arg>>,<<ConstMP25>>]
+ /// CHECK-DAG: Return [<<Div>>]
- // CHECK-START: double Main.DivMP25(double) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:d\d+>> ParameterValue
- // CHECK-DAG: <<ConstM4:d\d+>> DoubleConstant -4
- // CHECK-DAG: <<Mul:d\d+>> Mul [<<Arg>>,<<ConstM4>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: double Main.DivMP25(double) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:d\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstM4:d\d+>> DoubleConstant -4
+ /// CHECK-DAG: <<Mul:d\d+>> Mul [<<Arg>>,<<ConstM4>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: double Main.DivMP25(double) instruction_simplifier (after)
- // CHECK-NOT: Div
+ /// CHECK-START: double Main.DivMP25(double) instruction_simplifier (after)
+ /// CHECK-NOT: Div
public static double DivMP25(double arg) {
return arg / -0.25f;
}
diff --git a/test/462-checker-inlining-across-dex-files/src/Main.java b/test/462-checker-inlining-across-dex-files/src/Main.java
index 218c7ce..64979ca 100644
--- a/test/462-checker-inlining-across-dex-files/src/Main.java
+++ b/test/462-checker-inlining-across-dex-files/src/Main.java
@@ -21,105 +21,105 @@
public class Main {
- // CHECK-START: void Main.inlineEmptyMethod() inliner (before)
- // CHECK-DAG: <<Invoke:v\d+>> InvokeStaticOrDirect
- // CHECK-DAG: ReturnVoid
+ /// CHECK-START: void Main.inlineEmptyMethod() inliner (before)
+ /// CHECK-DAG: <<Invoke:v\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: ReturnVoid
- // CHECK-START: void Main.inlineEmptyMethod() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main.inlineEmptyMethod() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static void inlineEmptyMethod() {
OtherDex.emptyMethod();
}
- // CHECK-START: int Main.inlineReturnIntMethod() inliner (before)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.inlineReturnIntMethod() inliner (before)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: int Main.inlineReturnIntMethod() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineReturnIntMethod() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
- // CHECK-START: int Main.inlineReturnIntMethod() inliner (after)
- // CHECK-DAG: <<Const38:i\d+>> IntConstant 38
- // CHECK-DAG: Return [<<Const38>>]
+ /// CHECK-START: int Main.inlineReturnIntMethod() inliner (after)
+ /// CHECK-DAG: <<Const38:i\d+>> IntConstant 38
+ /// CHECK-DAG: Return [<<Const38>>]
public static int inlineReturnIntMethod() {
return OtherDex.returnIntMethod();
}
- // CHECK-START: int Main.dontInlineOtherDexStatic() inliner (before)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.dontInlineOtherDexStatic() inliner (before)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: int Main.dontInlineOtherDexStatic() inliner (after)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.dontInlineOtherDexStatic() inliner (after)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
public static int dontInlineOtherDexStatic() {
return OtherDex.returnOtherDexStatic();
}
- // CHECK-START: int Main.inlineMainStatic() inliner (before)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.inlineMainStatic() inliner (before)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: int Main.inlineMainStatic() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineMainStatic() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
- // CHECK-START: int Main.inlineMainStatic() inliner (after)
- // CHECK-DAG: <<Static:i\d+>> StaticFieldGet
- // CHECK-DAG: Return [<<Static>>]
+ /// CHECK-START: int Main.inlineMainStatic() inliner (after)
+ /// CHECK-DAG: <<Static:i\d+>> StaticFieldGet
+ /// CHECK-DAG: Return [<<Static>>]
public static int inlineMainStatic() {
return OtherDex.returnMainStatic();
}
- // CHECK-START: int Main.dontInlineRecursiveCall() inliner (before)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.dontInlineRecursiveCall() inliner (before)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: int Main.dontInlineRecursiveCall() inliner (after)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.dontInlineRecursiveCall() inliner (after)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
public static int dontInlineRecursiveCall() {
return OtherDex.recursiveCall();
}
- // CHECK-START: java.lang.String Main.dontInlineReturnString() inliner (before)
- // CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: java.lang.String Main.dontInlineReturnString() inliner (before)
+ /// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: java.lang.String Main.dontInlineReturnString() inliner (after)
- // CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: java.lang.String Main.dontInlineReturnString() inliner (after)
+ /// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
public static String dontInlineReturnString() {
return OtherDex.returnString();
}
- // CHECK-START: java.lang.Class Main.dontInlineOtherDexClass() inliner (before)
- // CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: java.lang.Class Main.dontInlineOtherDexClass() inliner (before)
+ /// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: java.lang.Class Main.dontInlineOtherDexClass() inliner (after)
- // CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: java.lang.Class Main.dontInlineOtherDexClass() inliner (after)
+ /// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
public static Class dontInlineOtherDexClass() {
return OtherDex.returnOtherDexClass();
}
- // CHECK-START: java.lang.Class Main.inlineMainClass() inliner (before)
- // CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: java.lang.Class Main.inlineMainClass() inliner (before)
+ /// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: java.lang.Class Main.inlineMainClass() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: java.lang.Class Main.inlineMainClass() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
- // CHECK-START: java.lang.Class Main.inlineMainClass() inliner (after)
- // CHECK-DAG: Return [<<Class:l\d+>>]
- // CHECK-DAG: <<Class>> LoadClass
+ /// CHECK-START: java.lang.Class Main.inlineMainClass() inliner (after)
+ /// CHECK-DAG: Return [<<Class:l\d+>>]
+ /// CHECK-DAG: <<Class>> LoadClass
// Note: There are two LoadClass instructions. We obtain the correct
// instruction id by matching the Return's input list first.
@@ -127,28 +127,28 @@
return OtherDex.returnMainClass();
}
- // CHECK-START: java.lang.Class Main.dontInlineOtherDexClassStaticCall() inliner (before)
- // CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: java.lang.Class Main.dontInlineOtherDexClassStaticCall() inliner (before)
+ /// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: java.lang.Class Main.dontInlineOtherDexClassStaticCall() inliner (after)
- // CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: java.lang.Class Main.dontInlineOtherDexClassStaticCall() inliner (after)
+ /// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
public static Class dontInlineOtherDexClassStaticCall() {
return OtherDex.returnOtherDexClassStaticCall();
}
- // CHECK-START: java.lang.Class Main.inlineOtherDexCallingMain() inliner (before)
- // CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: java.lang.Class Main.inlineOtherDexCallingMain() inliner (before)
+ /// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: java.lang.Class Main.inlineOtherDexCallingMain() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: java.lang.Class Main.inlineOtherDexCallingMain() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
- // CHECK-START: java.lang.Class Main.inlineOtherDexCallingMain() inliner (after)
- // CHECK-DAG: Return [<<Class:l\d+>>]
- // CHECK-DAG: <<Class>> LoadClass
+ /// CHECK-START: java.lang.Class Main.inlineOtherDexCallingMain() inliner (after)
+ /// CHECK-DAG: Return [<<Class:l\d+>>]
+ /// CHECK-DAG: <<Class>> LoadClass
// Note: There are two LoadClass instructions. We obtain the correct
// instruction id by matching the Return's input list first.
diff --git a/test/463-checker-boolean-simplifier/src/Main.java b/test/463-checker-boolean-simplifier/src/Main.java
index e237448..0b75930 100644
--- a/test/463-checker-boolean-simplifier/src/Main.java
+++ b/test/463-checker-boolean-simplifier/src/Main.java
@@ -37,33 +37,33 @@
* empty branches removed.
*/
- // CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (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) boolean_simplifier (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) boolean_simplifier (before)
- // CHECK: Goto
- // CHECK: Goto
- // CHECK: Goto
- // CHECK-NOT: Goto
+ /// CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (before)
+ /// CHECK: Goto
+ /// CHECK: Goto
+ /// CHECK: Goto
+ /// CHECK-NOT: Goto
- // CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (after)
- // CHECK-DAG: <<Param:z\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<NotParam:z\d+>> BooleanNot [<<Param>>]
- // CHECK-DAG: Return [<<NotParam>>]
+ /// CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (after)
+ /// CHECK-DAG: <<Param:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<NotParam:z\d+>> BooleanNot [<<Param>>]
+ /// CHECK-DAG: Return [<<NotParam>>]
- // CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (after)
- // CHECK-NOT: If
- // CHECK-NOT: Phi
+ /// CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (after)
+ /// CHECK-NOT: If
+ /// CHECK-NOT: Phi
- // CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (after)
- // CHECK: Goto
- // CHECK-NOT: Goto
+ /// CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (after)
+ /// CHECK: Goto
+ /// CHECK-NOT: Goto
public static boolean BooleanNot(boolean x) {
return !x;
@@ -74,23 +74,23 @@
* and 0 when False.
*/
- // CHECK-START: boolean Main.GreaterThan(int, int) boolean_simplifier (before)
- // CHECK-DAG: <<ParamX:i\d+>> ParameterValue
- // CHECK-DAG: <<ParamY:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> GreaterThan [<<ParamX>>,<<ParamY>>]
- // CHECK-DAG: If [<<Cond>>]
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Const0>>,<<Const1>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: boolean Main.GreaterThan(int, int) boolean_simplifier (before)
+ /// CHECK-DAG: <<ParamX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ParamY:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> GreaterThan [<<ParamX>>,<<ParamY>>]
+ /// CHECK-DAG: If [<<Cond>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Const0>>,<<Const1>>]
+ /// CHECK-DAG: Return [<<Phi>>]
- // CHECK-START: boolean Main.GreaterThan(int, int) boolean_simplifier (after)
- // CHECK-DAG: <<ParamX:i\d+>> ParameterValue
- // CHECK-DAG: <<ParamY:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> GreaterThan [<<ParamX>>,<<ParamY>>]
- // CHECK-DAG: Return [<<Cond>>]
+ /// CHECK-START: boolean Main.GreaterThan(int, int) boolean_simplifier (after)
+ /// CHECK-DAG: <<ParamX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ParamY:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> GreaterThan [<<ParamX>>,<<ParamY>>]
+ /// CHECK-DAG: Return [<<Cond>>]
public static boolean GreaterThan(int x, int y) {
return (x <= y) ? false : true;
@@ -101,26 +101,26 @@
* and 1 when False.
*/
- // CHECK-START: boolean Main.LessThan(int, int) boolean_simplifier (before)
- // CHECK-DAG: <<ParamX:i\d+>> ParameterValue
- // CHECK-DAG: <<ParamY:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> GreaterThanOrEqual [<<ParamX>>,<<ParamY>>]
- // CHECK-DAG: If [<<Cond>>]
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Const1>>,<<Const0>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: boolean Main.LessThan(int, int) boolean_simplifier (before)
+ /// CHECK-DAG: <<ParamX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ParamY:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> GreaterThanOrEqual [<<ParamX>>,<<ParamY>>]
+ /// CHECK-DAG: If [<<Cond>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Const1>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Phi>>]
- // CHECK-START: boolean Main.LessThan(int, int) boolean_simplifier (after)
- // CHECK-DAG: <<ParamX:i\d+>> ParameterValue
- // CHECK-DAG: <<ParamY:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> LessThan [<<ParamX>>,<<ParamY>>]
- // CHECK-DAG: Return [<<Cond>>]
+ /// CHECK-START: boolean Main.LessThan(int, int) boolean_simplifier (after)
+ /// CHECK-DAG: <<ParamX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ParamY:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> LessThan [<<ParamX>>,<<ParamY>>]
+ /// CHECK-DAG: Return [<<Cond>>]
- // CHECK-START: boolean Main.LessThan(int, int) boolean_simplifier (after)
- // CHECK-NOT: GreaterThanOrEqual
+ /// CHECK-START: boolean Main.LessThan(int, int) boolean_simplifier (after)
+ /// CHECK-NOT: GreaterThanOrEqual
public static boolean LessThan(int x, int y) {
return (x < y) ? true : false;
@@ -131,57 +131,57 @@
* Note that Phis are discovered retrospectively.
*/
- // CHECK-START: boolean Main.ValuesOrdered(int, int, int) boolean_simplifier (before)
- // CHECK-DAG: <<ParamX:i\d+>> ParameterValue
- // CHECK-DAG: <<ParamY:i\d+>> ParameterValue
- // CHECK-DAG: <<ParamZ:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<CondXY:z\d+>> GreaterThan [<<ParamX>>,<<ParamY>>]
- // CHECK-DAG: If [<<CondXY>>]
- // CHECK-DAG: <<CondYZ:z\d+>> GreaterThan [<<ParamY>>,<<ParamZ>>]
- // CHECK-DAG: If [<<CondYZ>>]
- // CHECK-DAG: <<CondXYZ:z\d+>> NotEqual [<<PhiXY:i\d+>>,<<PhiYZ:i\d+>>]
- // CHECK-DAG: If [<<CondXYZ>>]
- // CHECK-DAG: Return [<<PhiXYZ:i\d+>>]
- // CHECK-DAG: <<PhiXY>> Phi [<<Const1>>,<<Const0>>]
- // CHECK-DAG: <<PhiYZ>> Phi [<<Const1>>,<<Const0>>]
- // CHECK-DAG: <<PhiXYZ>> Phi [<<Const1>>,<<Const0>>]
+ /// CHECK-START: boolean Main.ValuesOrdered(int, int, int) boolean_simplifier (before)
+ /// CHECK-DAG: <<ParamX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ParamY:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ParamZ:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<CondXY:z\d+>> GreaterThan [<<ParamX>>,<<ParamY>>]
+ /// CHECK-DAG: If [<<CondXY>>]
+ /// CHECK-DAG: <<CondYZ:z\d+>> GreaterThan [<<ParamY>>,<<ParamZ>>]
+ /// CHECK-DAG: If [<<CondYZ>>]
+ /// CHECK-DAG: <<CondXYZ:z\d+>> NotEqual [<<PhiXY:i\d+>>,<<PhiYZ:i\d+>>]
+ /// CHECK-DAG: If [<<CondXYZ>>]
+ /// CHECK-DAG: Return [<<PhiXYZ:i\d+>>]
+ /// CHECK-DAG: <<PhiXY>> Phi [<<Const1>>,<<Const0>>]
+ /// CHECK-DAG: <<PhiYZ>> Phi [<<Const1>>,<<Const0>>]
+ /// CHECK-DAG: <<PhiXYZ>> Phi [<<Const1>>,<<Const0>>]
- // CHECK-START: boolean Main.ValuesOrdered(int, int, int) boolean_simplifier (after)
- // CHECK-DAG: <<ParamX:i\d+>> ParameterValue
- // CHECK-DAG: <<ParamY:i\d+>> ParameterValue
- // CHECK-DAG: <<ParamZ:i\d+>> ParameterValue
- // CHECK-DAG: <<CmpXY:z\d+>> LessThanOrEqual [<<ParamX>>,<<ParamY>>]
- // CHECK-DAG: <<CmpYZ:z\d+>> LessThanOrEqual [<<ParamY>>,<<ParamZ>>]
- // CHECK-DAG: <<CmpXYZ:z\d+>> Equal [<<CmpXY>>,<<CmpYZ>>]
- // CHECK-DAG: Return [<<CmpXYZ>>]
+ /// CHECK-START: boolean Main.ValuesOrdered(int, int, int) boolean_simplifier (after)
+ /// CHECK-DAG: <<ParamX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ParamY:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ParamZ:i\d+>> ParameterValue
+ /// CHECK-DAG: <<CmpXY:z\d+>> LessThanOrEqual [<<ParamX>>,<<ParamY>>]
+ /// CHECK-DAG: <<CmpYZ:z\d+>> LessThanOrEqual [<<ParamY>>,<<ParamZ>>]
+ /// CHECK-DAG: <<CmpXYZ:z\d+>> Equal [<<CmpXY>>,<<CmpYZ>>]
+ /// CHECK-DAG: Return [<<CmpXYZ>>]
public static boolean ValuesOrdered(int x, int y, int z) {
return (x <= y) == (y <= z);
}
- // CHECK-START: int Main.NegatedCondition(boolean) boolean_simplifier (before)
- // CHECK-DAG: <<Param:z\d+>> ParameterValue
- // CHECK-DAG: <<Const42:i\d+>> IntConstant 42
- // CHECK-DAG: <<Const43:i\d+>> IntConstant 43
- // CHECK-DAG: <<NotParam:z\d+>> BooleanNot [<<Param>>]
- // CHECK-DAG: If [<<NotParam>>]
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Const42>>,<<Const43>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: int Main.NegatedCondition(boolean) boolean_simplifier (before)
+ /// CHECK-DAG: <<Param:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42
+ /// CHECK-DAG: <<Const43:i\d+>> IntConstant 43
+ /// CHECK-DAG: <<NotParam:z\d+>> BooleanNot [<<Param>>]
+ /// CHECK-DAG: If [<<NotParam>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Const42>>,<<Const43>>]
+ /// CHECK-DAG: Return [<<Phi>>]
- // CHECK-START: int Main.NegatedCondition(boolean) boolean_simplifier (after)
- // CHECK-DAG: <<Param:z\d+>> ParameterValue
- // CHECK-DAG: <<Const42:i\d+>> IntConstant 42
- // CHECK-DAG: <<Const43:i\d+>> IntConstant 43
- // CHECK-DAG: If [<<Param>>]
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Const42>>,<<Const43>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: int Main.NegatedCondition(boolean) boolean_simplifier (after)
+ /// CHECK-DAG: <<Param:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42
+ /// CHECK-DAG: <<Const43:i\d+>> IntConstant 43
+ /// CHECK-DAG: If [<<Param>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Const42>>,<<Const43>>]
+ /// CHECK-DAG: Return [<<Phi>>]
// Note: The fact that branches are swapped is verified by running the test.
- // CHECK-START: int Main.NegatedCondition(boolean) boolean_simplifier (after)
- // CHECK-NOT: BooleanNot
+ /// CHECK-START: int Main.NegatedCondition(boolean) boolean_simplifier (after)
+ /// CHECK-NOT: BooleanNot
public static int NegatedCondition(boolean x) {
if (x != false) {
diff --git a/test/464-checker-inline-sharpen-calls/src/Main.java b/test/464-checker-inline-sharpen-calls/src/Main.java
index e451f70..876496f 100644
--- a/test/464-checker-inline-sharpen-calls/src/Main.java
+++ b/test/464-checker-inline-sharpen-calls/src/Main.java
@@ -19,27 +19,27 @@
public void invokeVirtual() {
}
- // CHECK-START: void Main.inlineSharpenInvokeVirtual(Main) inliner (before)
- // CHECK-DAG: <<Invoke:v\d+>> InvokeStaticOrDirect
- // CHECK-DAG: ReturnVoid
+ /// CHECK-START: void Main.inlineSharpenInvokeVirtual(Main) inliner (before)
+ /// CHECK-DAG: <<Invoke:v\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: ReturnVoid
- // CHECK-START: void Main.inlineSharpenInvokeVirtual(Main) inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main.inlineSharpenInvokeVirtual(Main) inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static void inlineSharpenInvokeVirtual(Main m) {
m.invokeVirtual();
}
- // CHECK-START: int Main.inlineSharpenStringInvoke() inliner (before)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.inlineSharpenStringInvoke() inliner (before)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: int Main.inlineSharpenStringInvoke() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineSharpenStringInvoke() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
- // CHECK-START: int Main.inlineSharpenStringInvoke() inliner (after)
- // CHECK-DAG: <<Field:i\d+>> InstanceFieldGet
- // CHECK-DAG: Return [<<Field>>]
+ /// CHECK-START: int Main.inlineSharpenStringInvoke() inliner (after)
+ /// CHECK-DAG: <<Field:i\d+>> InstanceFieldGet
+ /// CHECK-DAG: Return [<<Field>>]
public static int inlineSharpenStringInvoke() {
return "Foo".length();
diff --git a/test/465-checker-clinit-gvn/src/Main.java b/test/465-checker-clinit-gvn/src/Main.java
index ac2863c..704e9fe 100644
--- a/test/465-checker-clinit-gvn/src/Main.java
+++ b/test/465-checker-clinit-gvn/src/Main.java
@@ -26,31 +26,31 @@
public final class Main {
- // CHECK-START: int Main.accessTwoStatics() GVN (before)
- // CHECK-DAG: <<Class1:l\d+>> LoadClass
- // CHECK-DAG: ClinitCheck [<<Class1>>]
- // CHECK-DAG: <<Class2:l\d+>> LoadClass
- // CHECK-DAG: ClinitCheck [<<Class2>>]
+ /// CHECK-START: int Main.accessTwoStatics() GVN (before)
+ /// CHECK-DAG: <<Class1:l\d+>> LoadClass
+ /// CHECK-DAG: ClinitCheck [<<Class1>>]
+ /// CHECK-DAG: <<Class2:l\d+>> LoadClass
+ /// CHECK-DAG: ClinitCheck [<<Class2>>]
- // CHECK-START: int Main.accessTwoStatics() GVN (after)
- // CHECK-DAG: <<Class:l\d+>> LoadClass
- // CHECK-DAG: ClinitCheck [<<Class>>]
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: int Main.accessTwoStatics() GVN (after)
+ /// CHECK-DAG: <<Class:l\d+>> LoadClass
+ /// CHECK-DAG: ClinitCheck [<<Class>>]
+ /// CHECK-NOT: ClinitCheck
public static int accessTwoStatics() {
return OtherClass.b - OtherClass.a;
}
- // CHECK-START: int Main.accessTwoStaticsCallInBetween() GVN (before)
- // CHECK-DAG: <<Class1:l\d+>> LoadClass
- // CHECK-DAG: ClinitCheck [<<Class1>>]
- // CHECK-DAG: <<Class2:l\d+>> LoadClass
- // CHECK-DAG: ClinitCheck [<<Class2>>]
+ /// CHECK-START: int Main.accessTwoStaticsCallInBetween() GVN (before)
+ /// CHECK-DAG: <<Class1:l\d+>> LoadClass
+ /// CHECK-DAG: ClinitCheck [<<Class1>>]
+ /// CHECK-DAG: <<Class2:l\d+>> LoadClass
+ /// CHECK-DAG: ClinitCheck [<<Class2>>]
- // CHECK-START: int Main.accessTwoStaticsCallInBetween() GVN (after)
- // CHECK-DAG: <<Class:l\d+>> LoadClass
- // CHECK-DAG: ClinitCheck [<<Class>>]
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: int Main.accessTwoStaticsCallInBetween() GVN (after)
+ /// CHECK-DAG: <<Class:l\d+>> LoadClass
+ /// CHECK-DAG: ClinitCheck [<<Class>>]
+ /// CHECK-NOT: ClinitCheck
public static int accessTwoStaticsCallInBetween() {
int b = OtherClass.b;
diff --git a/test/468-checker-bool-simplifier-regression/smali/TestCase.smali b/test/468-checker-bool-simplifier-regression/smali/TestCase.smali
index 33e6dc3..da1c5ec 100644
--- a/test/468-checker-bool-simplifier-regression/smali/TestCase.smali
+++ b/test/468-checker-bool-simplifier-regression/smali/TestCase.smali
@@ -18,18 +18,18 @@
.field public static value:Z
-# CHECK-START: boolean TestCase.testCase() boolean_simplifier (before)
-# CHECK-DAG: <<Const0:i\d+>> IntConstant 0
-# CHECK-DAG: <<Const1:i\d+>> IntConstant 1
-# CHECK-DAG: <<Value:z\d+>> StaticFieldGet
-# CHECK-DAG: If [<<Value>>]
-# CHECK-DAG: <<Phi:i\d+>> Phi [<<Const1>>,<<Const0>>]
-# CHECK-DAG: Return [<<Phi>>]
+## CHECK-START: boolean TestCase.testCase() boolean_simplifier (before)
+## CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+## CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+## CHECK-DAG: <<Value:z\d+>> StaticFieldGet
+## CHECK-DAG: If [<<Value>>]
+## CHECK-DAG: <<Phi:i\d+>> Phi [<<Const1>>,<<Const0>>]
+## CHECK-DAG: Return [<<Phi>>]
-# CHECK-START: boolean TestCase.testCase() boolean_simplifier (after)
-# CHECK-DAG: <<Value:z\d+>> StaticFieldGet
-# CHECK-DAG: <<Not:z\d+>> BooleanNot [<<Value>>]
-# CHECK-DAG: Return [<<Not>>]
+## CHECK-START: boolean TestCase.testCase() boolean_simplifier (after)
+## CHECK-DAG: <<Value:z\d+>> StaticFieldGet
+## CHECK-DAG: <<Not:z\d+>> BooleanNot [<<Value>>]
+## CHECK-DAG: Return [<<Not>>]
.method public static testCase()Z
.registers 2
diff --git a/test/473-checker-inliner-constants/src/Main.java b/test/473-checker-inliner-constants/src/Main.java
index 79d89b0..85f6565 100644
--- a/test/473-checker-inliner-constants/src/Main.java
+++ b/test/473-checker-inliner-constants/src/Main.java
@@ -16,13 +16,13 @@
public class Main {
- // CHECK-START: java.lang.Object Main.InlineNullConstant() inliner (before)
- // CHECK: NullConstant
- // CHECK-NOT: NullConstant
+ /// CHECK-START: java.lang.Object Main.InlineNullConstant() inliner (before)
+ /// CHECK: NullConstant
+ /// CHECK-NOT: NullConstant
- // CHECK-START: java.lang.Object Main.InlineNullConstant() inliner (after)
- // CHECK: NullConstant
- // CHECK-NOT: NullConstant
+ /// CHECK-START: java.lang.Object Main.InlineNullConstant() inliner (after)
+ /// CHECK: NullConstant
+ /// CHECK-NOT: NullConstant
public static Object returnNullConstant(Object x) {
return null;
@@ -32,13 +32,13 @@
return returnNullConstant(null);
}
- // CHECK-START: int Main.InlineIntConstant() inliner (before)
- // CHECK: IntConstant 42
- // CHECK-NOT: IntConstant 42
+ /// CHECK-START: int Main.InlineIntConstant() inliner (before)
+ /// CHECK: IntConstant 42
+ /// CHECK-NOT: IntConstant 42
- // CHECK-START: int Main.InlineIntConstant() inliner (after)
- // CHECK: IntConstant 42
- // CHECK-NOT: IntConstant 42
+ /// CHECK-START: int Main.InlineIntConstant() inliner (after)
+ /// CHECK: IntConstant 42
+ /// CHECK-NOT: IntConstant 42
public static int returnIntConstant(int x) {
return 42;
@@ -48,13 +48,13 @@
return returnIntConstant(42);
}
- // CHECK-START: long Main.InlineLongConstant() inliner (before)
- // CHECK: LongConstant 42
- // CHECK-NOT: LongConstant 42
+ /// CHECK-START: long Main.InlineLongConstant() inliner (before)
+ /// CHECK: LongConstant 42
+ /// CHECK-NOT: LongConstant 42
- // CHECK-START: long Main.InlineLongConstant() inliner (after)
- // CHECK: LongConstant 42
- // CHECK-NOT: LongConstant 42
+ /// CHECK-START: long Main.InlineLongConstant() inliner (after)
+ /// CHECK: LongConstant 42
+ /// CHECK-NOT: LongConstant 42
public static long returnLongConstant(long x) {
return 42L;
diff --git a/test/474-checker-boolean-input/src/Main.java b/test/474-checker-boolean-input/src/Main.java
index 490f7f9..86d0f7c 100644
--- a/test/474-checker-boolean-input/src/Main.java
+++ b/test/474-checker-boolean-input/src/Main.java
@@ -27,9 +27,9 @@
* we implement a suitable type analysis.
*/
- // CHECK-START: boolean Main.TestPhiAsBoolean(int) boolean_simplifier (after)
- // CHECK-DAG: <<Phi:i\d+>> Phi
- // CHECK-DAG: BooleanNot [<<Phi>>]
+ /// CHECK-START: boolean Main.TestPhiAsBoolean(int) boolean_simplifier (after)
+ /// CHECK-DAG: <<Phi:i\d+>> Phi
+ /// CHECK-DAG: BooleanNot [<<Phi>>]
public static boolean f1;
public static boolean f2;
@@ -47,9 +47,9 @@
* we implement a suitable type analysis.
*/
- // CHECK-START: boolean Main.TestAndAsBoolean(boolean, boolean) boolean_simplifier (after)
- // CHECK-DAG: <<And:i\d+>> And
- // CHECK-DAG: BooleanNot [<<And>>]
+ /// CHECK-START: boolean Main.TestAndAsBoolean(boolean, boolean) boolean_simplifier (after)
+ /// CHECK-DAG: <<And:i\d+>> And
+ /// CHECK-DAG: BooleanNot [<<And>>]
public static boolean InlineAnd(boolean x, boolean y) {
return x & y;
@@ -64,9 +64,9 @@
* we implement a suitable type analysis.
*/
- // CHECK-START: boolean Main.TestOrAsBoolean(boolean, boolean) boolean_simplifier (after)
- // CHECK-DAG: <<Or:i\d+>> Or
- // CHECK-DAG: BooleanNot [<<Or>>]
+ /// CHECK-START: boolean Main.TestOrAsBoolean(boolean, boolean) boolean_simplifier (after)
+ /// CHECK-DAG: <<Or:i\d+>> Or
+ /// CHECK-DAG: BooleanNot [<<Or>>]
public static boolean InlineOr(boolean x, boolean y) {
return x | y;
@@ -81,9 +81,9 @@
* we implement a suitable type analysis.
*/
- // CHECK-START: boolean Main.TestXorAsBoolean(boolean, boolean) boolean_simplifier (after)
- // CHECK-DAG: <<Xor:i\d+>> Xor
- // CHECK-DAG: BooleanNot [<<Xor>>]
+ /// CHECK-START: boolean Main.TestXorAsBoolean(boolean, boolean) boolean_simplifier (after)
+ /// CHECK-DAG: <<Xor:i\d+>> Xor
+ /// CHECK-DAG: BooleanNot [<<Xor>>]
public static boolean InlineXor(boolean x, boolean y) {
return x ^ y;
diff --git a/test/476-checker-ctor-memory-barrier/src/Main.java b/test/476-checker-ctor-memory-barrier/src/Main.java
index f24dc4a..e709ba0 100644
--- a/test/476-checker-ctor-memory-barrier/src/Main.java
+++ b/test/476-checker-ctor-memory-barrier/src/Main.java
@@ -17,8 +17,8 @@
// TODO: Add more tests after we can inline functions with calls.
class ClassWithoutFinals {
- // CHECK-START: void ClassWithoutFinals.<init>() register (after)
- // CHECK-NOT: MemoryBarrier kind:StoreStore
+ /// CHECK-START: void ClassWithoutFinals.<init>() register (after)
+ /// CHECK-NOT: MemoryBarrier kind:StoreStore
public ClassWithoutFinals() {}
}
@@ -26,9 +26,9 @@
public final int x;
public ClassWithFinals obj;
- // CHECK-START: void ClassWithFinals.<init>(boolean) register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void ClassWithFinals.<init>(boolean) register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
public ClassWithFinals(boolean cond) {
x = 0;
if (cond) {
@@ -37,17 +37,17 @@
}
}
- // CHECK-START: void ClassWithFinals.<init>() register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void ClassWithFinals.<init>() register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
public ClassWithFinals() {
x = 0;
}
- // CHECK-START: void ClassWithFinals.<init>(int) register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void ClassWithFinals.<init>(int) register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
public ClassWithFinals(int x) {
// This should have two barriers:
// - one for the constructor
@@ -58,33 +58,33 @@
}
class InheritFromClassWithFinals extends ClassWithFinals {
- // CHECK-START: void InheritFromClassWithFinals.<init>() register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void InheritFromClassWithFinals.<init>() register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
- // CHECK-START: void InheritFromClassWithFinals.<init>() register (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void InheritFromClassWithFinals.<init>() register (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public InheritFromClassWithFinals() {
// Should inline the super constructor.
}
- // CHECK-START: void InheritFromClassWithFinals.<init>(boolean) register (after)
- // CHECK: InvokeStaticOrDirect
+ /// CHECK-START: void InheritFromClassWithFinals.<init>(boolean) register (after)
+ /// CHECK: InvokeStaticOrDirect
- // CHECK-START: void InheritFromClassWithFinals.<init>(boolean) register (after)
- // CHECK-NOT: MemoryBarrier kind:StoreStore
+ /// CHECK-START: void InheritFromClassWithFinals.<init>(boolean) register (after)
+ /// CHECK-NOT: MemoryBarrier kind:StoreStore
public InheritFromClassWithFinals(boolean cond) {
super(cond);
// should not inline the super constructor
}
- // CHECK-START: void InheritFromClassWithFinals.<init>(int) register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK: ReturnVoid
+ /// CHECK-START: void InheritFromClassWithFinals.<init>(int) register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK: ReturnVoid
- // CHECK-START: void InheritFromClassWithFinals.<init>(int) register (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void InheritFromClassWithFinals.<init>(int) register (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public InheritFromClassWithFinals(int unused) {
// Should inline the super constructor and insert a memory barrier.
@@ -96,35 +96,35 @@
class HaveFinalsAndInheritFromClassWithFinals extends ClassWithFinals {
final int y;
- // CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>() register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>() register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
- // CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>() register (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>() register (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public HaveFinalsAndInheritFromClassWithFinals() {
// Should inline the super constructor and remove the memory barrier.
y = 0;
}
- // CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>(boolean) register (after)
- // CHECK: InvokeStaticOrDirect
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>(boolean) register (after)
+ /// CHECK: InvokeStaticOrDirect
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
public HaveFinalsAndInheritFromClassWithFinals(boolean cond) {
super(cond);
// should not inline the super constructor
y = 0;
}
- // CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>(int) register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>(int) register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
- // CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>(int) register (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>(int) register (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public HaveFinalsAndInheritFromClassWithFinals(int unused) {
// Should inline the super constructor and keep just one memory barrier.
y = 0;
@@ -138,52 +138,52 @@
public class Main {
- // CHECK-START: ClassWithFinals Main.noInlineNoConstructorBarrier() register (after)
- // CHECK: InvokeStaticOrDirect
+ /// CHECK-START: ClassWithFinals Main.noInlineNoConstructorBarrier() register (after)
+ /// CHECK: InvokeStaticOrDirect
- // CHECK-START: ClassWithFinals Main.noInlineNoConstructorBarrier() register (after)
- // CHECK-NOT: MemoryBarrier kind:StoreStore
+ /// CHECK-START: ClassWithFinals Main.noInlineNoConstructorBarrier() register (after)
+ /// CHECK-NOT: MemoryBarrier kind:StoreStore
public static ClassWithFinals noInlineNoConstructorBarrier() {
return new ClassWithFinals(false);
}
- // CHECK-START: void Main.inlineNew() register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void Main.inlineNew() register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
- // CHECK-START: void Main.inlineNew() register (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main.inlineNew() register (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static void inlineNew() {
new ClassWithFinals();
}
- // CHECK-START: void Main.inlineNew1() register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void Main.inlineNew1() register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
- // CHECK-START: void Main.inlineNew1() register (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main.inlineNew1() register (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static void inlineNew1() {
new InheritFromClassWithFinals();
}
- // CHECK-START: void Main.inlineNew2() register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void Main.inlineNew2() register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
- // CHECK-START: void Main.inlineNew2() register (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main.inlineNew2() register (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static void inlineNew2() {
new HaveFinalsAndInheritFromClassWithFinals();
}
- // CHECK-START: void Main.inlineNew3() register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void Main.inlineNew3() register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
- // CHECK-START: void Main.inlineNew3() register (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main.inlineNew3() register (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static void inlineNew3() {
new HaveFinalsAndInheritFromClassWithFinals();
new HaveFinalsAndInheritFromClassWithFinals();
diff --git a/test/477-checker-bound-type/src/Main.java b/test/477-checker-bound-type/src/Main.java
index b30028d..fe52e83 100644
--- a/test/477-checker-bound-type/src/Main.java
+++ b/test/477-checker-bound-type/src/Main.java
@@ -17,8 +17,8 @@
public class Main {
- // CHECK-START: java.lang.Object Main.boundTypeForIf(java.lang.Object) reference_type_propagation (after)
- // CHECK: BoundType
+ /// CHECK-START: java.lang.Object Main.boundTypeForIf(java.lang.Object) reference_type_propagation (after)
+ /// CHECK: BoundType
public static Object boundTypeForIf(Object a) {
if (a != null) {
return a.toString();
@@ -27,8 +27,8 @@
}
}
- // CHECK-START: java.lang.Object Main.boundTypeForInstanceOf(java.lang.Object) reference_type_propagation (after)
- // CHECK: BoundType
+ /// CHECK-START: java.lang.Object Main.boundTypeForInstanceOf(java.lang.Object) reference_type_propagation (after)
+ /// CHECK: BoundType
public static Object boundTypeForInstanceOf(Object a) {
if (a instanceof Main) {
return (Main)a;
@@ -37,8 +37,8 @@
}
}
- // CHECK-START: java.lang.Object Main.noBoundTypeForIf(java.lang.Object) reference_type_propagation (after)
- // CHECK-NOT: BoundType
+ /// CHECK-START: java.lang.Object Main.noBoundTypeForIf(java.lang.Object) reference_type_propagation (after)
+ /// CHECK-NOT: BoundType
public static Object noBoundTypeForIf(Object a) {
if (a == null) {
return new Object();
@@ -47,8 +47,8 @@
}
}
- // CHECK-START: java.lang.Object Main.noBoundTypeForInstanceOf(java.lang.Object) reference_type_propagation (after)
- // CHECK-NOT: BoundType
+ /// CHECK-START: java.lang.Object Main.noBoundTypeForInstanceOf(java.lang.Object) reference_type_propagation (after)
+ /// CHECK-NOT: BoundType
public static Object noBoundTypeForInstanceOf(Object a) {
if (a instanceof Main) {
return new Object();
diff --git a/test/478-checker-clinit-check-pruning/src/Main.java b/test/478-checker-clinit-check-pruning/src/Main.java
index e8739b8..d5592aa 100644
--- a/test/478-checker-clinit-check-pruning/src/Main.java
+++ b/test/478-checker-clinit-check-pruning/src/Main.java
@@ -23,17 +23,17 @@
* removed before register allocation & code generation.
*/
- // CHECK-START: void Main.invokeStaticInlined() builder (after)
- // CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
- // CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
- // CHECK-DAG: InvokeStaticOrDirect [<<ClinitCheck>>]
+ /// CHECK-START: void Main.invokeStaticInlined() builder (after)
+ /// CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
+ /// CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
+ /// CHECK-DAG: InvokeStaticOrDirect [<<ClinitCheck>>]
- // CHECK-START: void Main.invokeStaticInlined() inliner (after)
- // CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
- // CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
+ /// CHECK-START: void Main.invokeStaticInlined() inliner (after)
+ /// CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
+ /// CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
- // CHECK-START: void Main.invokeStaticInlined() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main.invokeStaticInlined() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
// The following checks ensure the clinit check instruction added by
// the builder is pruned by the PrepareForRegisterAllocation, while
@@ -41,12 +41,12 @@
// graph is not dumped after (nor before) this step, we check the
// CFG as it is before the next pass (liveness analysis) instead.
- // CHECK-START: void Main.invokeStaticInlined() liveness (before)
- // CHECK-DAG: LoadClass gen_clinit_check:true
+ /// CHECK-START: void Main.invokeStaticInlined() liveness (before)
+ /// CHECK-DAG: LoadClass gen_clinit_check:true
- // CHECK-START: void Main.invokeStaticInlined() liveness (before)
- // CHECK-NOT: ClinitCheck
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main.invokeStaticInlined() liveness (before)
+ /// CHECK-NOT: ClinitCheck
+ /// CHECK-NOT: InvokeStaticOrDirect
static void invokeStaticInlined() {
ClassWithClinit1.$opt$inline$StaticMethod();
@@ -66,15 +66,15 @@
* initialization check of the called method's declaring class.
*/
- // CHECK-START: void Main.invokeStaticNotInlined() builder (after)
- // CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
- // CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
- // CHECK-DAG: InvokeStaticOrDirect [<<ClinitCheck>>]
+ /// CHECK-START: void Main.invokeStaticNotInlined() builder (after)
+ /// CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
+ /// CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
+ /// CHECK-DAG: InvokeStaticOrDirect [<<ClinitCheck>>]
- // CHECK-START: void Main.invokeStaticNotInlined() inliner (after)
- // CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
- // CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
- // CHECK-DAG: InvokeStaticOrDirect [<<ClinitCheck>>]
+ /// CHECK-START: void Main.invokeStaticNotInlined() inliner (after)
+ /// CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
+ /// CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
+ /// CHECK-DAG: InvokeStaticOrDirect [<<ClinitCheck>>]
// The following checks ensure the clinit check and load class
// instructions added by the builder are pruned by the
@@ -82,12 +82,12 @@
// dumped after (nor before) this step, we check the CFG as it is
// before the next pass (liveness analysis) instead.
- // CHECK-START: void Main.invokeStaticNotInlined() liveness (before)
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: void Main.invokeStaticNotInlined() liveness (before)
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: void Main.invokeStaticNotInlined() liveness (before)
- // CHECK-NOT: LoadClass
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: void Main.invokeStaticNotInlined() liveness (before)
+ /// CHECK-NOT: LoadClass
+ /// CHECK-NOT: ClinitCheck
static void invokeStaticNotInlined() {
ClassWithClinit2.staticMethod();
@@ -114,17 +114,17 @@
* explicit clinit check.
*/
- // CHECK-START: void Main$ClassWithClinit3.invokeStaticInlined() builder (after)
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: void Main$ClassWithClinit3.invokeStaticInlined() builder (after)
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: void Main$ClassWithClinit3.invokeStaticInlined() builder (after)
- // CHECK-NOT: LoadClass
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: void Main$ClassWithClinit3.invokeStaticInlined() builder (after)
+ /// CHECK-NOT: LoadClass
+ /// CHECK-NOT: ClinitCheck
- // CHECK-START: void Main$ClassWithClinit3.invokeStaticInlined() inliner (after)
- // CHECK-NOT: LoadClass
- // CHECK-NOT: ClinitCheck
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main$ClassWithClinit3.invokeStaticInlined() inliner (after)
+ /// CHECK-NOT: LoadClass
+ /// CHECK-NOT: ClinitCheck
+ /// CHECK-NOT: InvokeStaticOrDirect
static class ClassWithClinit3 {
static void invokeStaticInlined() {
@@ -149,19 +149,19 @@
* require an explicit clinit check.
*/
- // CHECK-START: void Main$ClassWithClinit4.invokeStaticNotInlined() builder (after)
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: void Main$ClassWithClinit4.invokeStaticNotInlined() builder (after)
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: void Main$ClassWithClinit4.invokeStaticNotInlined() builder (after)
- // CHECK-NOT: LoadClass
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: void Main$ClassWithClinit4.invokeStaticNotInlined() builder (after)
+ /// CHECK-NOT: LoadClass
+ /// CHECK-NOT: ClinitCheck
- // CHECK-START: void Main$ClassWithClinit4.invokeStaticNotInlined() inliner (after)
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: void Main$ClassWithClinit4.invokeStaticNotInlined() inliner (after)
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: void Main$ClassWithClinit4.invokeStaticNotInlined() inliner (after)
- // CHECK-NOT: LoadClass
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: void Main$ClassWithClinit4.invokeStaticNotInlined() inliner (after)
+ /// CHECK-NOT: LoadClass
+ /// CHECK-NOT: ClinitCheck
static class ClassWithClinit4 {
static void invokeStaticNotInlined() {
@@ -192,17 +192,17 @@
* explicit clinit check.
*/
- // CHECK-START: void Main$SubClassOfClassWithClinit5.invokeStaticInlined() builder (after)
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: void Main$SubClassOfClassWithClinit5.invokeStaticInlined() builder (after)
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: void Main$SubClassOfClassWithClinit5.invokeStaticInlined() builder (after)
- // CHECK-NOT: LoadClass
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: void Main$SubClassOfClassWithClinit5.invokeStaticInlined() builder (after)
+ /// CHECK-NOT: LoadClass
+ /// CHECK-NOT: ClinitCheck
- // CHECK-START: void Main$SubClassOfClassWithClinit5.invokeStaticInlined() inliner (after)
- // CHECK-NOT: LoadClass
- // CHECK-NOT: ClinitCheck
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main$SubClassOfClassWithClinit5.invokeStaticInlined() inliner (after)
+ /// CHECK-NOT: LoadClass
+ /// CHECK-NOT: ClinitCheck
+ /// CHECK-NOT: InvokeStaticOrDirect
static class ClassWithClinit5 {
static void $opt$inline$StaticMethod() {
@@ -225,19 +225,19 @@
* explicit clinit check.
*/
- // CHECK-START: void Main$SubClassOfClassWithClinit6.invokeStaticNotInlined() builder (after)
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: void Main$SubClassOfClassWithClinit6.invokeStaticNotInlined() builder (after)
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: void Main$SubClassOfClassWithClinit6.invokeStaticNotInlined() builder (after)
- // CHECK-NOT: LoadClass
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: void Main$SubClassOfClassWithClinit6.invokeStaticNotInlined() builder (after)
+ /// CHECK-NOT: LoadClass
+ /// CHECK-NOT: ClinitCheck
- // CHECK-START: void Main$SubClassOfClassWithClinit6.invokeStaticNotInlined() inliner (after)
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: void Main$SubClassOfClassWithClinit6.invokeStaticNotInlined() inliner (after)
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: void Main$SubClassOfClassWithClinit6.invokeStaticNotInlined() inliner (after)
- // CHECK-NOT: LoadClass
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: void Main$SubClassOfClassWithClinit6.invokeStaticNotInlined() inliner (after)
+ /// CHECK-NOT: LoadClass
+ /// CHECK-NOT: ClinitCheck
static class ClassWithClinit6 {
static boolean doThrow = false;
@@ -266,14 +266,14 @@
* we don't do generate a clinit check.
*/
- // CHECK-START: void Main.noClinitBecauseOfInvokeStatic() liveness (before)
- // CHECK-DAG: <<IntConstant:i\d+>> IntConstant 0
- // CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
- // CHECK-DAG: InvokeStaticOrDirect
- // CHECK-DAG: StaticFieldSet [<<LoadClass>>,<<IntConstant>>]
+ /// CHECK-START: void Main.noClinitBecauseOfInvokeStatic() liveness (before)
+ /// CHECK-DAG: <<IntConstant:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
+ /// CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-DAG: StaticFieldSet [<<LoadClass>>,<<IntConstant>>]
- // CHECK-START: void Main.noClinitBecauseOfInvokeStatic() liveness (before)
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: void Main.noClinitBecauseOfInvokeStatic() liveness (before)
+ /// CHECK-NOT: ClinitCheck
static void noClinitBecauseOfInvokeStatic() {
ClassWithClinit2.staticMethod();
@@ -285,14 +285,14 @@
* will generate a clinit check.
*/
- // CHECK-START: void Main.clinitBecauseOfFieldAccess() liveness (before)
- // CHECK-DAG: <<IntConstant:i\d+>> IntConstant 0
- // CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:true
- // CHECK-DAG: StaticFieldSet [<<LoadClass>>,<<IntConstant>>]
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: void Main.clinitBecauseOfFieldAccess() liveness (before)
+ /// CHECK-DAG: <<IntConstant:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:true
+ /// CHECK-DAG: StaticFieldSet [<<LoadClass>>,<<IntConstant>>]
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: void Main.clinitBecauseOfFieldAccess() liveness (before)
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: void Main.clinitBecauseOfFieldAccess() liveness (before)
+ /// CHECK-NOT: ClinitCheck
static void clinitBecauseOfFieldAccess() {
ClassWithClinit2.doThrow = false;
ClassWithClinit2.staticMethod();
diff --git a/test/478-checker-inliner-nested-loop/src/Main.java b/test/478-checker-inliner-nested-loop/src/Main.java
index df583d9..aa02349 100644
--- a/test/478-checker-inliner-nested-loop/src/Main.java
+++ b/test/478-checker-inliner-nested-loop/src/Main.java
@@ -33,12 +33,12 @@
return result;
}
- // CHECK-START: int Main.NestedLoop(int, int) inliner (before)
- // CHECK-NOT: Mul
+ /// CHECK-START: int Main.NestedLoop(int, int) inliner (before)
+ /// CHECK-NOT: Mul
- // CHECK-START: int Main.NestedLoop(int, int) inliner (after)
- // CHECK: Mul
- // CHECK-NOT: Mul
+ /// CHECK-START: int Main.NestedLoop(int, int) inliner (after)
+ /// CHECK: Mul
+ /// CHECK-NOT: Mul
public static int NestedLoop(int max_x, int max_y) {
int total = 0;
diff --git a/test/480-checker-dead-blocks/src/Main.java b/test/480-checker-dead-blocks/src/Main.java
index b76755e..4cc1634 100644
--- a/test/480-checker-dead-blocks/src/Main.java
+++ b/test/480-checker-dead-blocks/src/Main.java
@@ -30,25 +30,25 @@
return false;
}
- // CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination_final (before)
- // CHECK-DAG: <<ArgX:i\d+>> ParameterValue
- // CHECK-DAG: <<ArgY:i\d+>> ParameterValue
- // CHECK-DAG: If
- // CHECK-DAG: <<Add:i\d+>> Add [<<ArgX>>,<<ArgY>>]
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<ArgX>>,<<ArgY>>]
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination_final (before)
+ /// CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ArgY:i\d+>> ParameterValue
+ /// CHECK-DAG: If
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<ArgX>>,<<ArgY>>]
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<ArgX>>,<<ArgY>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
+ /// CHECK-DAG: Return [<<Phi>>]
- // CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination_final (after)
- // CHECK-DAG: <<ArgX:i\d+>> ParameterValue
- // CHECK-DAG: <<ArgY:i\d+>> ParameterValue
- // CHECK-DAG: <<Add:i\d+>> Add [<<ArgX>>,<<ArgY>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination_final (after)
+ /// CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ArgY:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<ArgX>>,<<ArgY>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination_final (after)
- // CHECK-NOT: If
- // CHECK-NOT: Sub
- // CHECK-NOT: Phi
+ /// CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination_final (after)
+ /// CHECK-NOT: If
+ /// CHECK-NOT: Sub
+ /// CHECK-NOT: Phi
public static int testTrueBranch(int x, int y) {
int z;
@@ -60,25 +60,25 @@
return z;
}
- // CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination_final (before)
- // CHECK-DAG: <<ArgX:i\d+>> ParameterValue
- // CHECK-DAG: <<ArgY:i\d+>> ParameterValue
- // CHECK-DAG: If
- // CHECK-DAG: <<Add:i\d+>> Add [<<ArgX>>,<<ArgY>>]
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<ArgX>>,<<ArgY>>]
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination_final (before)
+ /// CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ArgY:i\d+>> ParameterValue
+ /// CHECK-DAG: If
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<ArgX>>,<<ArgY>>]
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<ArgX>>,<<ArgY>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
+ /// CHECK-DAG: Return [<<Phi>>]
- // CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination_final (after)
- // CHECK-DAG: <<ArgX:i\d+>> ParameterValue
- // CHECK-DAG: <<ArgY:i\d+>> ParameterValue
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<ArgX>>,<<ArgY>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination_final (after)
+ /// CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ArgY:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<ArgX>>,<<ArgY>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination_final (after)
- // CHECK-NOT: If
- // CHECK-NOT: Add
- // CHECK-NOT: Phi
+ /// CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination_final (after)
+ /// CHECK-NOT: If
+ /// CHECK-NOT: Add
+ /// CHECK-NOT: Phi
public static int testFalseBranch(int x, int y) {
int z;
@@ -90,11 +90,11 @@
return z;
}
- // CHECK-START: int Main.testRemoveLoop(int) dead_code_elimination_final (before)
- // CHECK: Mul
+ /// CHECK-START: int Main.testRemoveLoop(int) dead_code_elimination_final (before)
+ /// CHECK: Mul
- // CHECK-START: int Main.testRemoveLoop(int) dead_code_elimination_final (after)
- // CHECK-NOT: Mul
+ /// CHECK-START: int Main.testRemoveLoop(int) dead_code_elimination_final (after)
+ /// CHECK-NOT: Mul
public static int testRemoveLoop(int x) {
if (inlineFalse()) {
@@ -105,13 +105,13 @@
return x;
}
- // CHECK-START: int Main.testInfiniteLoop(int) dead_code_elimination_final (before)
- // CHECK-DAG: Return
- // CHECK-DAG: Exit
+ /// CHECK-START: int Main.testInfiniteLoop(int) dead_code_elimination_final (before)
+ /// CHECK-DAG: Return
+ /// CHECK-DAG: Exit
- // CHECK-START: int Main.testInfiniteLoop(int) dead_code_elimination_final (after)
- // CHECK-NOT: Return
- // CHECK-NOT: Exit
+ /// CHECK-START: int Main.testInfiniteLoop(int) dead_code_elimination_final (after)
+ /// CHECK-NOT: Return
+ /// CHECK-NOT: Exit
public static int testInfiniteLoop(int x) {
while (inlineTrue()) {
@@ -120,17 +120,17 @@
return x;
}
- // CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (before)
- // CHECK-DAG: If
- // CHECK-DAG: Add
+ /// CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (before)
+ /// CHECK-DAG: If
+ /// CHECK-DAG: Add
- // CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (after)
- // CHECK-NOT: If
- // CHECK-NOT: Add
+ /// CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (after)
+ /// CHECK-NOT: If
+ /// CHECK-NOT: Add
public static int testDeadLoop(int x) {
while (inlineFalse()) {
@@ -139,18 +139,18 @@
return x;
}
- // CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (before)
- // CHECK-DAG: If
- // CHECK-DAG: If
- // CHECK-DAG: Add
+ /// CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (before)
+ /// CHECK-DAG: If
+ /// CHECK-DAG: If
+ /// CHECK-DAG: Add
- // CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (after)
- // CHECK-NOT: If
- // CHECK-NOT: Add
+ /// CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (after)
+ /// CHECK-NOT: If
+ /// CHECK-NOT: Add
public static int testUpdateLoopInformation(int x) {
// Use of Or in the condition generates a dead loop where not all of its
@@ -161,16 +161,16 @@
return x;
}
- // CHECK-START: int Main.testRemoveSuspendCheck(int, int) dead_code_elimination_final (before)
- // CHECK: SuspendCheck
- // CHECK: SuspendCheck
- // CHECK: SuspendCheck
- // CHECK-NOT: SuspendCheck
+ /// CHECK-START: int Main.testRemoveSuspendCheck(int, int) dead_code_elimination_final (before)
+ /// CHECK: SuspendCheck
+ /// CHECK: SuspendCheck
+ /// CHECK: SuspendCheck
+ /// CHECK-NOT: SuspendCheck
- // CHECK-START: int Main.testRemoveSuspendCheck(int, int) dead_code_elimination_final (after)
- // CHECK: SuspendCheck
- // CHECK: SuspendCheck
- // CHECK-NOT: SuspendCheck
+ /// CHECK-START: int Main.testRemoveSuspendCheck(int, int) dead_code_elimination_final (after)
+ /// CHECK: SuspendCheck
+ /// CHECK: SuspendCheck
+ /// CHECK-NOT: SuspendCheck
public static int testRemoveSuspendCheck(int x, int y) {
// Inner loop will leave behind the header with its SuspendCheck. DCE must
diff --git a/test/482-checker-loop-back-edge-use/src/Main.java b/test/482-checker-loop-back-edge-use/src/Main.java
index f579692..5754723 100644
--- a/test/482-checker-loop-back-edge-use/src/Main.java
+++ b/test/482-checker-loop-back-edge-use/src/Main.java
@@ -17,17 +17,17 @@
public class Main {
- // CHECK-START: void Main.loop1(boolean) liveness (after)
- // CHECK: ParameterValue liveness:2 ranges:{[2,22)} uses:[17,22]
- // CHECK: Goto liveness:20
+ /// CHECK-START: void Main.loop1(boolean) liveness (after)
+ /// CHECK: ParameterValue liveness:2 ranges:{[2,22)} uses:[17,22]
+ /// CHECK: Goto liveness:20
public static void loop1(boolean incoming) {
while (incoming) {}
}
- // CHECK-START: void Main.loop2(boolean) liveness (after)
- // CHECK: ParameterValue liveness:4 ranges:{[4,44)} uses:[35,40,44]
- // CHECK: Goto liveness:38
- // CHECK: Goto liveness:42
+ /// CHECK-START: void Main.loop2(boolean) liveness (after)
+ /// CHECK: ParameterValue liveness:4 ranges:{[4,44)} uses:[35,40,44]
+ /// CHECK: Goto liveness:38
+ /// CHECK: Goto liveness:42
public static void loop2(boolean incoming) {
while (true) {
System.out.println("foo");
@@ -35,12 +35,12 @@
}
}
- // CHECK-START: void Main.loop3(boolean) liveness (after)
- // CHECK: ParameterValue liveness:4 ranges:{[4,62)} uses:[58,62]
- // CHECK: Goto liveness:60
+ /// CHECK-START: void Main.loop3(boolean) liveness (after)
+ /// CHECK: ParameterValue liveness:4 ranges:{[4,62)} uses:[58,62]
+ /// CHECK: Goto liveness:60
- // CHECK-START: void Main.loop3(boolean) liveness (after)
- // CHECK-NOT: Goto liveness:56
+ /// CHECK-START: void Main.loop3(boolean) liveness (after)
+ /// CHECK-NOT: Goto liveness:56
public static void loop3(boolean incoming) {
// 'incoming' only needs a use at the outer loop's back edge.
while (System.currentTimeMillis() != 42) {
@@ -49,11 +49,11 @@
}
}
- // CHECK-START: void Main.loop4(boolean) liveness (after)
- // CHECK: ParameterValue liveness:4 ranges:{[4,24)} uses:[24]
+ /// CHECK-START: void Main.loop4(boolean) liveness (after)
+ /// CHECK: ParameterValue liveness:4 ranges:{[4,24)} uses:[24]
- // CHECK-START: void Main.loop4(boolean) liveness (after)
- // CHECK-NOT: Goto liveness:22
+ /// CHECK-START: void Main.loop4(boolean) liveness (after)
+ /// CHECK-NOT: Goto liveness:22
public static void loop4(boolean incoming) {
// 'incoming' has no loop use, so should not have back edge uses.
System.out.println(incoming);
@@ -62,10 +62,10 @@
}
}
- // CHECK-START: void Main.loop5(boolean) liveness (after)
- // CHECK: ParameterValue liveness:4 ranges:{[4,52)} uses:[35,44,48,52]
- // CHECK: Goto liveness:46
- // CHECK: Goto liveness:50
+ /// CHECK-START: void Main.loop5(boolean) liveness (after)
+ /// CHECK: ParameterValue liveness:4 ranges:{[4,52)} uses:[35,44,48,52]
+ /// CHECK: Goto liveness:46
+ /// CHECK: Goto liveness:50
public static void loop5(boolean incoming) {
// 'incoming' must have a use at both back edges.
while (Runtime.getRuntime() != null) {
@@ -75,12 +75,12 @@
}
}
- // CHECK-START: void Main.loop6(boolean) liveness (after)
- // CHECK: ParameterValue liveness:4 ranges:{[4,48)} uses:[26,48]
- // CHECK: Goto liveness:46
+ /// CHECK-START: void Main.loop6(boolean) liveness (after)
+ /// CHECK: ParameterValue liveness:4 ranges:{[4,48)} uses:[26,48]
+ /// CHECK: Goto liveness:46
- // CHECK-START: void Main.loop6(boolean) liveness (after)
- // CHECK-NOT: Goto liveness:24
+ /// CHECK-START: void Main.loop6(boolean) liveness (after)
+ /// CHECK-NOT: Goto liveness:24
public static void loop6(boolean incoming) {
// 'incoming' must have a use only at the first loop's back edge.
while (true) {
@@ -89,10 +89,10 @@
}
}
- // CHECK-START: void Main.loop7(boolean) liveness (after)
- // CHECK: ParameterValue liveness:4 ranges:{[4,52)} uses:[34,43,48,52]
- // CHECK: Goto liveness:46
- // CHECK: Goto liveness:50
+ /// CHECK-START: void Main.loop7(boolean) liveness (after)
+ /// CHECK: ParameterValue liveness:4 ranges:{[4,52)} uses:[34,43,48,52]
+ /// CHECK: Goto liveness:46
+ /// CHECK: Goto liveness:50
public static void loop7(boolean incoming) {
// 'incoming' must have a use at both back edges.
while (Runtime.getRuntime() != null) {
@@ -101,10 +101,10 @@
}
}
- // CHECK-START: void Main.loop8() liveness (after)
- // CHECK: StaticFieldGet liveness:14 ranges:{[14,46)} uses:[37,42,46]
- // CHECK: Goto liveness:40
- // CHECK: Goto liveness:44
+ /// CHECK-START: void Main.loop8() liveness (after)
+ /// CHECK: StaticFieldGet liveness:14 ranges:{[14,46)} uses:[37,42,46]
+ /// CHECK: Goto liveness:40
+ /// CHECK: Goto liveness:44
public static void loop8() {
// 'incoming' must have a use at both back edges.
boolean incoming = field;
@@ -113,9 +113,9 @@
}
}
- // CHECK-START: void Main.loop9() liveness (after)
- // CHECK: StaticFieldGet liveness:24 ranges:{[24,38)} uses:[33,38]
- // CHECK: Goto liveness:40
+ /// CHECK-START: void Main.loop9() liveness (after)
+ /// CHECK: StaticFieldGet liveness:24 ranges:{[24,38)} uses:[33,38]
+ /// CHECK: Goto liveness:40
public static void loop9() {
while (Runtime.getRuntime() != null) {
// 'incoming' must only have a use in the inner loop.
diff --git a/test/484-checker-register-hints/src/Main.java b/test/484-checker-register-hints/src/Main.java
index 33952d9..3715ca2 100644
--- a/test/484-checker-register-hints/src/Main.java
+++ b/test/484-checker-register-hints/src/Main.java
@@ -16,21 +16,21 @@
public class Main {
- // CHECK-START: void Main.test1(boolean, int, int, int, int, int) register (after)
- // CHECK: name "B0"
- // CHECK-NOT: ParallelMove
- // CHECK: name "B1"
- // CHECK-NOT: end_block
- // CHECK: If
- // CHECK-NOT: ParallelMove
- // CHECK: name "B3"
- // CHECK-NOT: end_block
- // CHECK: ArraySet
+ /// CHECK-START: void Main.test1(boolean, int, int, int, int, int) register (after)
+ /// CHECK: name "B0"
+ /// CHECK-NOT: ParallelMove
+ /// CHECK: name "B1"
+ /// CHECK-NOT: end_block
+ /// CHECK: If
+ /// CHECK-NOT: ParallelMove
+ /// CHECK: name "B3"
+ /// CHECK-NOT: end_block
+ /// CHECK: ArraySet
// We could check here that there is a parallel move, but it's only valid
// for some architectures (for example x86), as other architectures may
// not do move at all.
- // CHECK: end_block
- // CHECK-NOT: ParallelMove
+ /// CHECK: end_block
+ /// CHECK-NOT: ParallelMove
public static void test1(boolean z, int a, int b, int c, int d, int m) {
int e = live1;
@@ -51,21 +51,21 @@
live1 = e + f + g;
}
- // CHECK-START: void Main.test2(boolean, int, int, int, int, int) register (after)
- // CHECK: name "B0"
- // CHECK-NOT: ParallelMove
- // CHECK: name "B1"
- // CHECK-NOT: end_block
- // CHECK: If
- // CHECK-NOT: ParallelMove
- // CHECK: name "B3"
- // CHECK-NOT: end_block
- // CHECK: ArraySet
+ /// CHECK-START: void Main.test2(boolean, int, int, int, int, int) register (after)
+ /// CHECK: name "B0"
+ /// CHECK-NOT: ParallelMove
+ /// CHECK: name "B1"
+ /// CHECK-NOT: end_block
+ /// CHECK: If
+ /// CHECK-NOT: ParallelMove
+ /// CHECK: name "B3"
+ /// CHECK-NOT: end_block
+ /// CHECK: ArraySet
// We could check here that there is a parallel move, but it's only valid
// for some architectures (for example x86), as other architectures may
// not do move at all.
- // CHECK: end_block
- // CHECK-NOT: ParallelMove
+ /// CHECK: end_block
+ /// CHECK-NOT: ParallelMove
public static void test2(boolean z, int a, int b, int c, int d, int m) {
int e = live1;
@@ -85,21 +85,21 @@
live1 = e + f + g;
}
- // CHECK-START: void Main.test3(boolean, int, int, int, int, int) register (after)
- // CHECK: name "B0"
- // CHECK-NOT: ParallelMove
- // CHECK: name "B1"
- // CHECK-NOT: end_block
- // CHECK: If
- // CHECK-NOT: ParallelMove
- // CHECK: name "B6"
- // CHECK-NOT: end_block
- // CHECK: ArraySet
+ /// CHECK-START: void Main.test3(boolean, int, int, int, int, int) register (after)
+ /// CHECK: name "B0"
+ /// CHECK-NOT: ParallelMove
+ /// CHECK: name "B1"
+ /// CHECK-NOT: end_block
+ /// CHECK: If
+ /// CHECK-NOT: ParallelMove
+ /// CHECK: name "B6"
+ /// CHECK-NOT: end_block
+ /// CHECK: ArraySet
// We could check here that there is a parallel move, but it's only valid
// for some architectures (for example x86), as other architectures may
// not do move at all.
- // CHECK: end_block
- // CHECK-NOT: ParallelMove
+ /// CHECK: end_block
+ /// CHECK-NOT: ParallelMove
public static void test3(boolean z, int a, int b, int c, int d, int m) {
// Same version as test2, but with branches reversed, to ensure
diff --git a/test/485-checker-dce-loop-update/smali/TestCase.smali b/test/485-checker-dce-loop-update/smali/TestCase.smali
index 487a5df..da27bf6 100644
--- a/test/485-checker-dce-loop-update/smali/TestCase.smali
+++ b/test/485-checker-dce-loop-update/smali/TestCase.smali
@@ -23,27 +23,27 @@
.end method
-# CHECK-START: int TestCase.testSingleExit(int, boolean) dead_code_elimination_final (before)
-# CHECK-DAG: <<ArgX:i\d+>> ParameterValue
-# CHECK-DAG: <<ArgY:z\d+>> ParameterValue
-# CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
-# CHECK-DAG: <<Cst5:i\d+>> IntConstant 5
-# CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
-# CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
-# CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
-# CHECK-DAG: If [<<Cst1>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add5>> Add [<<PhiX>>,<<Cst5>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
-# CHECK-DAG: Return [<<PhiX>>] loop:none
+## CHECK-START: int TestCase.testSingleExit(int, boolean) dead_code_elimination_final (before)
+## CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+## CHECK-DAG: <<ArgY:z\d+>> ParameterValue
+## CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
+## CHECK-DAG: <<Cst5:i\d+>> IntConstant 5
+## CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
+## CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
+## CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
+## CHECK-DAG: If [<<Cst1>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add5>> Add [<<PhiX>>,<<Cst5>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
+## CHECK-DAG: Return [<<PhiX>>] loop:none
-# CHECK-START: int TestCase.testSingleExit(int, boolean) dead_code_elimination_final (after)
-# CHECK-DAG: <<ArgX:i\d+>> ParameterValue
-# CHECK-DAG: <<ArgY:z\d+>> ParameterValue
-# CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
-# CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<AddX:i\d+>>] loop:<<HeaderY:B\d+>>
-# CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
-# CHECK-DAG: <<AddX>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
-# CHECK-DAG: Return [<<PhiX>>] loop:none
+## CHECK-START: int TestCase.testSingleExit(int, boolean) dead_code_elimination_final (after)
+## CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+## CHECK-DAG: <<ArgY:z\d+>> ParameterValue
+## CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
+## CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<AddX:i\d+>>] loop:<<HeaderY:B\d+>>
+## CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
+## CHECK-DAG: <<AddX>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
+## CHECK-DAG: Return [<<PhiX>>] loop:none
.method public static testSingleExit(IZ)I
.registers 3
@@ -73,31 +73,31 @@
.end method
-# CHECK-START: int TestCase.testMultipleExits(int, boolean, boolean) dead_code_elimination_final (before)
-# CHECK-DAG: <<ArgX:i\d+>> ParameterValue
-# CHECK-DAG: <<ArgY:z\d+>> ParameterValue
-# CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
-# CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
-# CHECK-DAG: <<Cst5:i\d+>> IntConstant 5
-# CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
-# CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
-# CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
-# CHECK-DAG: If [<<ArgZ>>] loop:<<HeaderY>>
-# CHECK-DAG: If [<<Cst1>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add5>> Add [<<PhiX>>,<<Cst5>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
-# CHECK-DAG: Return [<<PhiX>>] loop:none
+## CHECK-START: int TestCase.testMultipleExits(int, boolean, boolean) dead_code_elimination_final (before)
+## CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+## CHECK-DAG: <<ArgY:z\d+>> ParameterValue
+## CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
+## CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
+## CHECK-DAG: <<Cst5:i\d+>> IntConstant 5
+## CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
+## CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
+## CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
+## CHECK-DAG: If [<<ArgZ>>] loop:<<HeaderY>>
+## CHECK-DAG: If [<<Cst1>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add5>> Add [<<PhiX>>,<<Cst5>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
+## CHECK-DAG: Return [<<PhiX>>] loop:none
-# CHECK-START: int TestCase.testMultipleExits(int, boolean, boolean) dead_code_elimination_final (after)
-# CHECK-DAG: <<ArgX:i\d+>> ParameterValue
-# CHECK-DAG: <<ArgY:z\d+>> ParameterValue
-# CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
-# CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
-# CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
-# CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
-# CHECK-DAG: If [<<ArgZ>>] loop:none
-# CHECK-DAG: Return [<<PhiX>>] loop:none
+## CHECK-START: int TestCase.testMultipleExits(int, boolean, boolean) dead_code_elimination_final (after)
+## CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+## CHECK-DAG: <<ArgY:z\d+>> ParameterValue
+## CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
+## CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
+## CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
+## CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
+## CHECK-DAG: If [<<ArgZ>>] loop:none
+## CHECK-DAG: Return [<<PhiX>>] loop:none
.method public static testMultipleExits(IZZ)I
.registers 4
@@ -129,37 +129,37 @@
.end method
-# CHECK-START: int TestCase.testExitPredecessors(int, boolean, boolean) dead_code_elimination_final (before)
-# CHECK-DAG: <<ArgX:i\d+>> ParameterValue
-# CHECK-DAG: <<ArgY:z\d+>> ParameterValue
-# CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
-# CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
-# CHECK-DAG: <<Cst5:i\d+>> IntConstant 5
-# CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
-# CHECK-DAG: <<Cst9:i\d+>> IntConstant 9
-# CHECK-DAG: <<PhiX1:i\d+>> Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
-# CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
-# CHECK-DAG: If [<<ArgZ>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Mul9:i\d+>> Mul [<<PhiX1>>,<<Cst9>>] loop:<<HeaderY>>
-# CHECK-DAG: <<PhiX2:i\d+>> Phi [<<Mul9>>,<<PhiX1>>] loop:<<HeaderY>>
-# CHECK-DAG: If [<<Cst1>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add5>> Add [<<PhiX2>>,<<Cst5>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add7>> Add [<<PhiX1>>,<<Cst7>>] loop:<<HeaderY>>
-# CHECK-DAG: Return [<<PhiX2>>] loop:none
+## CHECK-START: int TestCase.testExitPredecessors(int, boolean, boolean) dead_code_elimination_final (before)
+## CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+## CHECK-DAG: <<ArgY:z\d+>> ParameterValue
+## CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
+## CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
+## CHECK-DAG: <<Cst5:i\d+>> IntConstant 5
+## CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
+## CHECK-DAG: <<Cst9:i\d+>> IntConstant 9
+## CHECK-DAG: <<PhiX1:i\d+>> Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
+## CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
+## CHECK-DAG: If [<<ArgZ>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Mul9:i\d+>> Mul [<<PhiX1>>,<<Cst9>>] loop:<<HeaderY>>
+## CHECK-DAG: <<PhiX2:i\d+>> Phi [<<Mul9>>,<<PhiX1>>] loop:<<HeaderY>>
+## CHECK-DAG: If [<<Cst1>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add5>> Add [<<PhiX2>>,<<Cst5>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add7>> Add [<<PhiX1>>,<<Cst7>>] loop:<<HeaderY>>
+## CHECK-DAG: Return [<<PhiX2>>] loop:none
-# CHECK-START: int TestCase.testExitPredecessors(int, boolean, boolean) dead_code_elimination_final (after)
-# CHECK-DAG: <<ArgX:i\d+>> ParameterValue
-# CHECK-DAG: <<ArgY:z\d+>> ParameterValue
-# CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
-# CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
-# CHECK-DAG: <<Cst9:i\d+>> IntConstant 9
-# CHECK-DAG: <<PhiX1:i\d+>> Phi [<<ArgX>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
-# CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add7>> Add [<<PhiX1>>,<<Cst7>>] loop:<<HeaderY>>
-# CHECK-DAG: If [<<ArgZ>>] loop:none
-# CHECK-DAG: <<Mul9:i\d+>> Mul [<<PhiX1>>,<<Cst9>>] loop:none
-# CHECK-DAG: <<PhiX2:i\d+>> Phi [<<Mul9>>,<<PhiX1>>] loop:none
-# CHECK-DAG: Return [<<PhiX2>>] loop:none
+## CHECK-START: int TestCase.testExitPredecessors(int, boolean, boolean) dead_code_elimination_final (after)
+## CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+## CHECK-DAG: <<ArgY:z\d+>> ParameterValue
+## CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
+## CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
+## CHECK-DAG: <<Cst9:i\d+>> IntConstant 9
+## CHECK-DAG: <<PhiX1:i\d+>> Phi [<<ArgX>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
+## CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add7>> Add [<<PhiX1>>,<<Cst7>>] loop:<<HeaderY>>
+## CHECK-DAG: If [<<ArgZ>>] loop:none
+## CHECK-DAG: <<Mul9:i\d+>> Mul [<<PhiX1>>,<<Cst9>>] loop:none
+## CHECK-DAG: <<PhiX2:i\d+>> Phi [<<Mul9>>,<<PhiX1>>] loop:none
+## CHECK-DAG: Return [<<PhiX2>>] loop:none
.method public static testExitPredecessors(IZZ)I
.registers 4
@@ -196,48 +196,48 @@
.end method
-# CHECK-START: int TestCase.testInnerLoop(int, boolean, boolean) dead_code_elimination_final (before)
-# CHECK-DAG: <<ArgX:i\d+>> ParameterValue
-# CHECK-DAG: <<ArgY:z\d+>> ParameterValue
-# CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
-# CHECK-DAG: <<Cst0:i\d+>> IntConstant 0
-# CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
-# CHECK-DAG: <<Cst5:i\d+>> IntConstant 5
-# CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
+## CHECK-START: int TestCase.testInnerLoop(int, boolean, boolean) dead_code_elimination_final (before)
+## CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+## CHECK-DAG: <<ArgY:z\d+>> ParameterValue
+## CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
+## CHECK-DAG: <<Cst0:i\d+>> IntConstant 0
+## CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
+## CHECK-DAG: <<Cst5:i\d+>> IntConstant 5
+## CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
#
-# CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
-# CHECK-DAG: <<PhiZ1:i\d+>> Phi [<<ArgZ>>,<<XorZ:i\d+>>,<<PhiZ1>>] loop:<<HeaderY>>
-# CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
+## CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
+## CHECK-DAG: <<PhiZ1:i\d+>> Phi [<<ArgZ>>,<<XorZ:i\d+>>,<<PhiZ1>>] loop:<<HeaderY>>
+## CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
#
-# ### Inner loop ###
-# CHECK-DAG: <<PhiZ2:i\d+>> Phi [<<PhiZ1>>,<<XorZ>>] loop:<<HeaderZ:B\d+>>
-# CHECK-DAG: <<XorZ>> Xor [<<PhiZ2>>,<<Cst1>>] loop:<<HeaderZ>>
-# CHECK-DAG: <<CondZ:z\d+>> Equal [<<XorZ>>,<<Cst0>>] loop:<<HeaderZ>>
-# CHECK-DAG: If [<<CondZ>>] loop:<<HeaderZ>>
+# ### Inner loop ###
+## CHECK-DAG: <<PhiZ2:i\d+>> Phi [<<PhiZ1>>,<<XorZ>>] loop:<<HeaderZ:B\d+>>
+## CHECK-DAG: <<XorZ>> Xor [<<PhiZ2>>,<<Cst1>>] loop:<<HeaderZ>>
+## CHECK-DAG: <<CondZ:z\d+>> Equal [<<XorZ>>,<<Cst0>>] loop:<<HeaderZ>>
+## CHECK-DAG: If [<<CondZ>>] loop:<<HeaderZ>>
#
-# CHECK-DAG: <<Add5>> Add [<<PhiX>>,<<Cst5>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
-# CHECK-DAG: Return [<<PhiX>>] loop:none
+## CHECK-DAG: <<Add5>> Add [<<PhiX>>,<<Cst5>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
+## CHECK-DAG: Return [<<PhiX>>] loop:none
-# CHECK-START: int TestCase.testInnerLoop(int, boolean, boolean) dead_code_elimination_final (after)
-# CHECK-DAG: <<ArgX:i\d+>> ParameterValue
-# CHECK-DAG: <<ArgY:z\d+>> ParameterValue
-# CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
-# CHECK-DAG: <<Cst0:i\d+>> IntConstant 0
-# CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
-# CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
+## CHECK-START: int TestCase.testInnerLoop(int, boolean, boolean) dead_code_elimination_final (after)
+## CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+## CHECK-DAG: <<ArgY:z\d+>> ParameterValue
+## CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
+## CHECK-DAG: <<Cst0:i\d+>> IntConstant 0
+## CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
+## CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
#
-# CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
-# CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
+## CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
+## CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
#
-# ### Inner loop ###
-# CHECK-DAG: <<PhiZ:i\d+>> Phi [<<ArgZ>>,<<XorZ:i\d+>>] loop:<<HeaderZ:B\d+>>
-# CHECK-DAG: <<XorZ>> Xor [<<PhiZ>>,<<Cst1>>] loop:<<HeaderZ>>
-# CHECK-DAG: <<CondZ:z\d+>> Equal [<<XorZ>>,<<Cst0>>] loop:<<HeaderZ>>
-# CHECK-DAG: If [<<CondZ>>] loop:<<HeaderZ>>
+# ### Inner loop ###
+## CHECK-DAG: <<PhiZ:i\d+>> Phi [<<ArgZ>>,<<XorZ:i\d+>>] loop:<<HeaderZ:B\d+>>
+## CHECK-DAG: <<XorZ>> Xor [<<PhiZ>>,<<Cst1>>] loop:<<HeaderZ>>
+## CHECK-DAG: <<CondZ:z\d+>> Equal [<<XorZ>>,<<Cst0>>] loop:<<HeaderZ>>
+## CHECK-DAG: If [<<CondZ>>] loop:<<HeaderZ>>
#
-# CHECK-DAG: Return [<<PhiX>>] loop:none
+## CHECK-DAG: Return [<<PhiX>>] loop:none
.method public static testInnerLoop(IZZ)I
.registers 4
diff --git a/test/486-checker-must-do-null-check/src/Main.java b/test/486-checker-must-do-null-check/src/Main.java
index f285566..ea72718 100644
--- a/test/486-checker-must-do-null-check/src/Main.java
+++ b/test/486-checker-must-do-null-check/src/Main.java
@@ -15,8 +15,8 @@
*/
public class Main {
- // CHECK-START: void Main.InstanceOfPreChecked(java.lang.Object) instruction_simplifier (after)
- // CHECK: InstanceOf must_do_null_check:false
+ /// CHECK-START: void Main.InstanceOfPreChecked(java.lang.Object) instruction_simplifier (after)
+ /// CHECK: InstanceOf must_do_null_check:false
public void InstanceOfPreChecked(Object o) throws Exception {
o.toString();
if (o instanceof Main) {
@@ -24,23 +24,23 @@
}
}
- // CHECK-START: void Main.InstanceOf(java.lang.Object) instruction_simplifier (after)
- // CHECK: InstanceOf must_do_null_check:true
+ /// CHECK-START: void Main.InstanceOf(java.lang.Object) instruction_simplifier (after)
+ /// CHECK: InstanceOf must_do_null_check:true
public void InstanceOf(Object o) throws Exception {
if (o instanceof Main) {
throw new Exception();
}
}
- // CHECK-START: void Main.CheckCastPreChecked(java.lang.Object) instruction_simplifier (after)
- // CHECK: CheckCast must_do_null_check:false
+ /// CHECK-START: void Main.CheckCastPreChecked(java.lang.Object) instruction_simplifier (after)
+ /// CHECK: CheckCast must_do_null_check:false
public void CheckCastPreChecked(Object o) {
o.toString();
((Main)o).Bar();
}
- // CHECK-START: void Main.CheckCast(java.lang.Object) instruction_simplifier (after)
- // CHECK: CheckCast must_do_null_check:true
+ /// CHECK-START: void Main.CheckCast(java.lang.Object) instruction_simplifier (after)
+ /// CHECK: CheckCast must_do_null_check:true
public void CheckCast(Object o) {
((Main)o).Bar();
}
diff --git a/tools/checker/file_format/checker/parser.py b/tools/checker/file_format/checker/parser.py
index 4eed391..33735cb 100644
--- a/tools/checker/file_format/checker/parser.py
+++ b/tools/checker/file_format/checker/parser.py
@@ -12,18 +12,22 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+from common.logger import Logger
from file_format.common import SplitStream
from file_format.checker.struct import CheckerFile, TestCase, TestAssertion, RegexExpression
import re
+def __isCheckerLine(line):
+ return line.startswith("///") or line.startswith("##")
+
def __extractLine(prefix, line):
""" Attempts to parse a check line. The regex searches for a comment symbol
followed by the CHECK keyword, given attribute and a colon at the very
beginning of the line. Whitespaces are ignored.
"""
rIgnoreWhitespace = r"\s*"
- rCommentSymbols = [r"//", r"#"]
+ rCommentSymbols = [r"///", r"##"]
regexPrefix = rIgnoreWhitespace + \
r"(" + r"|".join(rCommentSymbols) + r")" + \
rIgnoreWhitespace + \
@@ -37,13 +41,16 @@
else:
return None
-def __processLine(line, lineNo, prefix):
+def __processLine(line, lineNo, prefix, fileName):
""" This function is invoked on each line of the check file and returns a pair
which instructs the parser how the line should be handled. If the line is
to be included in the current check group, it is returned in the first
value. If the line starts a new check group, the name of the group is
returned in the second value.
"""
+ if not __isCheckerLine(line):
+ return None, None
+
# Lines beginning with 'CHECK-START' start a new test case.
startLine = __extractLine(prefix + "-START", line)
if startLine is not None:
@@ -69,8 +76,7 @@
if notLine is not None:
return (notLine, TestAssertion.Variant.Not, lineNo), None
- # Other lines are ignored.
- return None, None
+ Logger.fail("Checker assertion could not be parsed", fileName, lineNo)
def __isMatchAtStart(match):
""" Tests if the given Match occurred at the beginning of the line. """
@@ -137,9 +143,9 @@
def ParseCheckerStream(fileName, prefix, stream):
checkerFile = CheckerFile(fileName)
- fnProcessLine = lambda line, lineNo: __processLine(line, lineNo, prefix)
+ fnProcessLine = lambda line, lineNo: __processLine(line, lineNo, prefix, fileName)
fnLineOutsideChunk = lambda line, lineNo: \
- Logger.fail("C1visualizer line not inside a group", fileName, lineNo)
+ Logger.fail("Checker line not inside a group", fileName, lineNo)
for caseName, caseLines, startLineNo in SplitStream(stream, fnProcessLine, fnLineOutsideChunk):
testCase = TestCase(checkerFile, caseName, startLineNo)
for caseLine in caseLines:
diff --git a/tools/checker/file_format/checker/test.py b/tools/checker/file_format/checker/test.py
index 453deed..ff24cc1 100644
--- a/tools/checker/file_format/checker/test.py
+++ b/tools/checker/file_format/checker/test.py
@@ -26,43 +26,56 @@
class CheckerParser_PrefixTest(unittest.TestCase):
def tryParse(self, string):
- checkerText = u"// CHECK-START: pass\n" + ToUnicode(string)
- checkFile = ParseCheckerStream("<test-file>", "CHECK", io.StringIO(checkerText))
+ checkerText = u"/// CHECK-START: pass\n" + ToUnicode(string)
+ return ParseCheckerStream("<test-file>", "CHECK", io.StringIO(checkerText))
+
+ def assertParses(self, string):
+ checkFile = self.tryParse(string)
self.assertEqual(len(checkFile.testCases), 1)
- testCase = checkFile.testCases[0]
- return len(testCase.assertions) != 0
+ self.assertNotEqual(len(checkFile.testCases[0].assertions), 0)
+
+ def assertIgnored(self, string):
+ checkFile = self.tryParse(string)
+ self.assertEqual(len(checkFile.testCases), 1)
+ self.assertEqual(len(checkFile.testCases[0].assertions), 0)
+
+ def assertInvalid(self, string):
+ with self.assertRaises(CheckerException):
+ self.tryParse(string)
+
+ def test_ValidFormat(self):
+ self.assertParses("///CHECK:foo")
+ self.assertParses("##CHECK:bar")
def test_InvalidFormat(self):
- self.assertFalse(self.tryParse("CHECK"))
- self.assertFalse(self.tryParse(":CHECK"))
- self.assertFalse(self.tryParse("CHECK:"))
- self.assertFalse(self.tryParse("//CHECK"))
- self.assertFalse(self.tryParse("#CHECK"))
+ self.assertIgnored("CHECK")
+ self.assertIgnored(":CHECK")
+ self.assertIgnored("CHECK:")
+ self.assertIgnored("//CHECK")
+ self.assertIgnored("#CHECK")
+ self.assertInvalid("///CHECK")
+ self.assertInvalid("##CHECK")
- self.assertTrue(self.tryParse("//CHECK:foo"))
- self.assertTrue(self.tryParse("#CHECK:bar"))
-
- def test_InvalidLabel(self):
- self.assertFalse(self.tryParse("//ACHECK:foo"))
- self.assertFalse(self.tryParse("#ACHECK:foo"))
+ def test_InvalidPrefix(self):
+ self.assertInvalid("///ACHECK:foo")
+ self.assertInvalid("##ACHECK:foo")
def test_NotFirstOnTheLine(self):
- self.assertFalse(self.tryParse("A// CHECK: foo"))
- self.assertFalse(self.tryParse("A # CHECK: foo"))
- self.assertFalse(self.tryParse("// // CHECK: foo"))
- self.assertFalse(self.tryParse("# # CHECK: foo"))
+ self.assertIgnored("A/// CHECK: foo")
+ self.assertIgnored("A # CHECK: foo")
+ self.assertInvalid("/// /// CHECK: foo")
+ self.assertInvalid("## ## CHECK: foo")
def test_WhitespaceAgnostic(self):
- self.assertTrue(self.tryParse(" //CHECK: foo"))
- self.assertTrue(self.tryParse("// CHECK: foo"))
- self.assertTrue(self.tryParse(" //CHECK: foo"))
- self.assertTrue(self.tryParse("// CHECK: foo"))
-
+ self.assertParses(" ///CHECK: foo")
+ self.assertParses("/// CHECK: foo")
+ self.assertParses(" ///CHECK: foo")
+ self.assertParses("/// CHECK: foo")
class CheckerParser_RegexExpressionTest(unittest.TestCase):
def parseAssertion(self, string, variant=""):
- checkerText = u"// CHECK-START: pass\n// CHECK" + ToUnicode(variant) + u": " + ToUnicode(string)
+ checkerText = u"/// CHECK-START: pass\n/// CHECK" + ToUnicode(variant) + u": " + ToUnicode(string)
checkerFile = ParseCheckerStream("<test-file>", "CHECK", io.StringIO(checkerText))
self.assertEqual(len(checkerFile.testCases), 1)
testCase = checkerFile.testCases[0]
@@ -204,9 +217,9 @@
def test_SingleGroup(self):
self.assertParsesTo(
"""
- // CHECK-START: Example Group
- // CHECK: foo
- // CHECK: bar
+ /// CHECK-START: Example Group
+ /// CHECK: foo
+ /// CHECK: bar
""",
[ ( "Example Group", [ ("foo", TestAssertion.Variant.InOrder),
("bar", TestAssertion.Variant.InOrder) ] ) ])
@@ -214,12 +227,12 @@
def test_MultipleGroups(self):
self.assertParsesTo(
"""
- // CHECK-START: Example Group1
- // CHECK: foo
- // CHECK: bar
- // CHECK-START: Example Group2
- // CHECK: abc
- // CHECK: def
+ /// CHECK-START: Example Group1
+ /// CHECK: foo
+ /// CHECK: bar
+ /// CHECK-START: Example Group2
+ /// CHECK: abc
+ /// CHECK: def
""",
[ ( "Example Group1", [ ("foo", TestAssertion.Variant.InOrder),
("bar", TestAssertion.Variant.InOrder) ] ),
@@ -229,14 +242,14 @@
def test_AssertionVariants(self):
self.assertParsesTo(
"""
- // CHECK-START: Example Group
- // CHECK: foo1
- // CHECK: foo2
- // CHECK-NEXT: foo3
- // CHECK-NEXT: foo4
- // CHECK-NOT: bar
- // CHECK-DAG: abc
- // CHECK-DAG: def
+ /// CHECK-START: Example Group
+ /// CHECK: foo1
+ /// CHECK: foo2
+ /// CHECK-NEXT: foo3
+ /// CHECK-NEXT: foo4
+ /// CHECK-NOT: bar
+ /// CHECK-DAG: abc
+ /// CHECK-DAG: def
""",
[ ( "Example Group", [ ("foo1", TestAssertion.Variant.InOrder),
("foo2", TestAssertion.Variant.InOrder),
@@ -250,20 +263,20 @@
with self.assertRaises(CheckerException):
self.parse(
"""
- // CHECK-START: Example Group
- // CHECK-DAG: foo
- // CHECK-NEXT: bar
+ /// CHECK-START: Example Group
+ /// CHECK-DAG: foo
+ /// CHECK-NEXT: bar
""")
with self.assertRaises(CheckerException):
self.parse(
"""
- // CHECK-START: Example Group
- // CHECK-NOT: foo
- // CHECK-NEXT: bar
+ /// CHECK-START: Example Group
+ /// CHECK-NOT: foo
+ /// CHECK-NEXT: bar
""")
with self.assertRaises(CheckerException):
self.parse(
"""
- // CHECK-START: Example Group
- // CHECK-NEXT: bar
+ /// CHECK-START: Example Group
+ /// CHECK-NEXT: bar
""")
diff --git a/tools/checker/match/test.py b/tools/checker/match/test.py
index 348c1d2..ca748c7 100644
--- a/tools/checker/match/test.py
+++ b/tools/checker/match/test.py
@@ -105,7 +105,7 @@
def assertMatches(self, checkerString, c1String):
checkerString = \
"""
- // CHECK-START: MyMethod MyPass
+ /// CHECK-START: MyMethod MyPass
""" + checkerString
c1String = \
"""
@@ -131,18 +131,18 @@
self.assertMatches(checkerString, c1String)
def test_Text(self):
- self.assertMatches("// CHECK: foo bar", "foo bar")
- self.assertDoesNotMatch("// CHECK: foo bar", "abc def")
+ self.assertMatches("/// CHECK: foo bar", "foo bar")
+ self.assertDoesNotMatch("/// CHECK: foo bar", "abc def")
def test_Pattern(self):
- self.assertMatches("// CHECK: abc {{de.}}", "abc de#")
- self.assertDoesNotMatch("// CHECK: abc {{de.}}", "abc d#f")
+ self.assertMatches("/// CHECK: abc {{de.}}", "abc de#")
+ self.assertDoesNotMatch("/// CHECK: abc {{de.}}", "abc d#f")
def test_Variables(self):
self.assertMatches(
"""
- // CHECK: foo<<X:.>>bar
- // CHECK: abc<<X>>def
+ /// CHECK: foo<<X:.>>bar
+ /// CHECK: abc<<X>>def
""",
"""
foo0bar
@@ -150,9 +150,9 @@
""")
self.assertMatches(
"""
- // CHECK: foo<<X:([0-9]+)>>bar
- // CHECK: abc<<X>>def
- // CHECK: ### <<X>> ###
+ /// CHECK: foo<<X:([0-9]+)>>bar
+ /// CHECK: abc<<X>>def
+ /// CHECK: ### <<X>> ###
""",
"""
foo1234bar
@@ -161,8 +161,8 @@
""")
self.assertDoesNotMatch(
"""
- // CHECK: foo<<X:([0-9]+)>>bar
- // CHECK: abc<<X>>def
+ /// CHECK: foo<<X:([0-9]+)>>bar
+ /// CHECK: abc<<X>>def
""",
"""
foo1234bar
@@ -170,16 +170,16 @@
""")
def test_WholeWordMustMatch(self):
- self.assertMatches("// CHECK: b{{.}}r", "abc bar def")
- self.assertDoesNotMatch("// CHECK: b{{.}}r", "abc Xbar def")
- self.assertDoesNotMatch("// CHECK: b{{.}}r", "abc barX def")
- self.assertDoesNotMatch("// CHECK: b{{.}}r", "abc b r def")
+ self.assertMatches("/// CHECK: b{{.}}r", "abc bar def")
+ self.assertDoesNotMatch("/// CHECK: b{{.}}r", "abc Xbar def")
+ self.assertDoesNotMatch("/// CHECK: b{{.}}r", "abc barX def")
+ self.assertDoesNotMatch("/// CHECK: b{{.}}r", "abc b r def")
def test_InOrderAssertions(self):
self.assertMatches(
"""
- // CHECK: foo
- // CHECK: bar
+ /// CHECK: foo
+ /// CHECK: bar
""",
"""
foo
@@ -187,8 +187,8 @@
""")
self.assertDoesNotMatch(
"""
- // CHECK: foo
- // CHECK: bar
+ /// CHECK: foo
+ /// CHECK: bar
""",
"""
bar
@@ -198,10 +198,10 @@
def test_NextLineAssertions(self):
self.assertMatches(
"""
- // CHECK: foo
- // CHECK-NEXT: bar
- // CHECK-NEXT: abc
- // CHECK: def
+ /// CHECK: foo
+ /// CHECK-NEXT: bar
+ /// CHECK-NEXT: abc
+ /// CHECK: def
""",
"""
foo
@@ -211,9 +211,9 @@
""")
self.assertMatches(
"""
- // CHECK: foo
- // CHECK-NEXT: bar
- // CHECK: def
+ /// CHECK: foo
+ /// CHECK-NEXT: bar
+ /// CHECK: def
""",
"""
foo
@@ -223,8 +223,8 @@
""")
self.assertDoesNotMatch(
"""
- // CHECK: foo
- // CHECK-NEXT: bar
+ /// CHECK: foo
+ /// CHECK-NEXT: bar
""",
"""
foo
@@ -234,8 +234,8 @@
self.assertDoesNotMatch(
"""
- // CHECK: foo
- // CHECK-NEXT: bar
+ /// CHECK: foo
+ /// CHECK-NEXT: bar
""",
"""
bar
@@ -246,8 +246,8 @@
def test_DagAssertions(self):
self.assertMatches(
"""
- // CHECK-DAG: foo
- // CHECK-DAG: bar
+ /// CHECK-DAG: foo
+ /// CHECK-DAG: bar
""",
"""
foo
@@ -255,8 +255,8 @@
""")
self.assertMatches(
"""
- // CHECK-DAG: foo
- // CHECK-DAG: bar
+ /// CHECK-DAG: foo
+ /// CHECK-DAG: bar
""",
"""
bar
@@ -266,10 +266,10 @@
def test_DagAssertionsScope(self):
self.assertMatches(
"""
- // CHECK: foo
- // CHECK-DAG: abc
- // CHECK-DAG: def
- // CHECK: bar
+ /// CHECK: foo
+ /// CHECK-DAG: abc
+ /// CHECK-DAG: def
+ /// CHECK: bar
""",
"""
foo
@@ -279,10 +279,10 @@
""")
self.assertDoesNotMatch(
"""
- // CHECK: foo
- // CHECK-DAG: abc
- // CHECK-DAG: def
- // CHECK: bar
+ /// CHECK: foo
+ /// CHECK-DAG: abc
+ /// CHECK-DAG: def
+ /// CHECK: bar
""",
"""
foo
@@ -292,10 +292,10 @@
""")
self.assertDoesNotMatch(
"""
- // CHECK: foo
- // CHECK-DAG: abc
- // CHECK-DAG: def
- // CHECK: bar
+ /// CHECK: foo
+ /// CHECK-DAG: abc
+ /// CHECK-DAG: def
+ /// CHECK: bar
""",
"""
foo
@@ -307,7 +307,7 @@
def test_NotAssertions(self):
self.assertMatches(
"""
- // CHECK-NOT: foo
+ /// CHECK-NOT: foo
""",
"""
abc
@@ -315,7 +315,7 @@
""")
self.assertDoesNotMatch(
"""
- // CHECK-NOT: foo
+ /// CHECK-NOT: foo
""",
"""
abc foo
@@ -323,8 +323,8 @@
""")
self.assertDoesNotMatch(
"""
- // CHECK-NOT: foo
- // CHECK-NOT: bar
+ /// CHECK-NOT: foo
+ /// CHECK-NOT: bar
""",
"""
abc
@@ -334,9 +334,9 @@
def test_NotAssertionsScope(self):
self.assertMatches(
"""
- // CHECK: abc
- // CHECK-NOT: foo
- // CHECK: def
+ /// CHECK: abc
+ /// CHECK-NOT: foo
+ /// CHECK: def
""",
"""
abc
@@ -344,9 +344,9 @@
""")
self.assertMatches(
"""
- // CHECK: abc
- // CHECK-NOT: foo
- // CHECK: def
+ /// CHECK: abc
+ /// CHECK-NOT: foo
+ /// CHECK: def
""",
"""
abc
@@ -355,9 +355,9 @@
""")
self.assertDoesNotMatch(
"""
- // CHECK: abc
- // CHECK-NOT: foo
- // CHECK: def
+ /// CHECK: abc
+ /// CHECK-NOT: foo
+ /// CHECK: def
""",
"""
abc
@@ -368,8 +368,8 @@
def test_LineOnlyMatchesOnce(self):
self.assertMatches(
"""
- // CHECK-DAG: foo
- // CHECK-DAG: foo
+ /// CHECK-DAG: foo
+ /// CHECK-DAG: foo
""",
"""
foo
@@ -378,8 +378,8 @@
""")
self.assertDoesNotMatch(
"""
- // CHECK-DAG: foo
- // CHECK-DAG: foo
+ /// CHECK-DAG: foo
+ /// CHECK-DAG: foo
""",
"""
foo