diff options
| author | 2015-05-28 11:14:54 +0100 | |
|---|---|---|
| committer | 2015-05-28 11:57:49 +0100 | |
| commit | a06d66a4ee60926127b9498b7ff0b3e37a24fccf (patch) | |
| tree | 87ec5d72211d5c3446e1d80ee71eda77faffd6b3 | |
| parent | b4e2fbbed28c3bcdb8fd0fee5a201ba78e1edf28 (diff) | |
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
29 files changed, 2399 insertions, 2380 deletions
diff --git a/test/441-checker-inliner/src/Main.java b/test/441-checker-inliner/src/Main.java index 8894d4e5ce..df969a488e 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 (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 (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>>] 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 c258db9c45..b7863be6ce 100644 --- a/test/442-checker-constant-folding/src/Main.java +++ b/test/442-checker-constant-folding/src/Main.java @@ -51,14 +51,14 @@ public class Main { * 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 @@ public class Main { * 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 @@ public class Main { * 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 @@ public class Main { * 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 @@ public class Main { * 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 @@ public class Main { * 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 @@ public class Main { * 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 @@ public class Main { * (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 @@ public class Main { * 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 501d79c9a4..6ac0cad7e8 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 96918d3e3a..42f9a11092 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 9ed66d64e3..de00a09256 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 @@ public class Main { 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 9d022b95be..e3fdffdd46 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 @@ public class Main { } } - // 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 @@ public class Main { 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 f90d85dac3..8960df896b 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 (after) - // CHECK-NOT: BoundsCheck - // CHECK: ArraySet - // CHECK-NOT: 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 static int sieve(int size) { int primeCount = 0; @@ -47,25 +47,25 @@ public class Main { } - // 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 (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 static void narrow(int[] array, int offset) { if (offset < 0) { @@ -108,18 +108,18 @@ public class Main { } - // 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 @@ public class Main { } - // 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 (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 static void constantIndexing2(int[] array) { array[1] = 1; @@ -160,45 +160,45 @@ public class Main { } - // 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 (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 static int[] constantIndexing3(int[] array1, int[] array2, boolean copy) { if (!copy) { @@ -212,14 +212,14 @@ public class Main { } - // 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 @@ public class Main { } - // 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 @@ public class Main { 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 (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 (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 static void loopPattern1(int[] array) { for (int i = 0; i < array.length; i++) { @@ -316,33 +316,33 @@ public class Main { } - // 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 (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 static void loopPattern2(int[] array) { for (int i = array.length - 1; i >= 0; i--) { @@ -372,13 +372,13 @@ public class Main { } - // 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 @@ public class Main { } - // 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 (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 static void constantNewArray() { int[] array = new int[10]; @@ -437,13 +437,13 @@ public class Main { 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 @@ public class Main { } - // 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 @@ public class Main { } - // 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 @@ public class Main { } - // 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 @@ public class Main { } - // 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 @@ public class Main { } - // 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[]) 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[]) 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[]) 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 @@ public class Main { 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 (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 (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 void foo1(int[] array, int start, int end) { // Three HDeoptimize will be added. One for @@ -639,22 +639,22 @@ public class Main { } - // 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 @@ public class Main { } - // 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 @@ public class Main { } } - // 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 (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 void foo4(int[] array, int end) { // Two HDeoptimize will be added. One for end <= array.length, @@ -721,28 +721,28 @@ public class Main { } - // 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 (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 void foo5(int[] array, int end) { // Bounds check in this loop can be eliminated without deoptimization. @@ -759,38 +759,38 @@ public class Main { } - // 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 (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 void foo6(int[] array, int start, int end) { // Three HDeoptimize will be added. One for @@ -803,22 +803,22 @@ public class Main { } - // 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 @@ public class Main { } - // 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 @@ public class Main { } // 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 640aeb834b..e907622fd6 100644 --- a/test/450-checker-types/src/Main.java +++ b/test/450-checker-types/src/Main.java @@ -54,50 +54,50 @@ class SubclassB extends Super { 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 @@ public class Main { ((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 @@ public class Main { ((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 @@ public class Main { ((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 @@ public class Main { ((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 @@ public class Main { ((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 @@ public class Main { } } - // 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 @@ public class Main { } } - // 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 @@ public class Main { } } - // 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 @@ public class Main { } } - // 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 @@ public class Main { } } - // 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 @@ public class Main { } } - // 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 @@ public class Main { } } - // 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 @@ public class Main { } } - // 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 @@ public class Main { } } - // 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 e94fc46654..9824f27815 100644 --- a/test/455-checker-gvn/src/Main.java +++ b/test/455-checker-gvn/src/Main.java @@ -19,15 +19,15 @@ public class Main { 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 742210c8fd..ad5fc8ef93 100644 --- a/test/458-checker-instruction-simplification/src/Main.java +++ b/test/458-checker-instruction-simplification/src/Main.java @@ -50,296 +50,296 @@ public class Main { * 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 @@ public class Main { * `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 (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 (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>>] public static int AddNegs1(int arg1, int arg2) { return -arg1 + -arg2; @@ -383,35 +383,35 @@ public class Main { * 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 (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) 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) 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 @@ public class Main { * 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 (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 (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 public static long AddNegs3(long arg1, long arg2) { long res = 0; @@ -468,22 +468,22 @@ public class Main { * 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 @@ public class Main { * 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 (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 (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-NOT: Sub public static long AddNeg2(long arg1, long arg2) { long temp = -arg2; @@ -529,18 +529,18 @@ public class Main { * 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 @@ public class Main { * 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 @@ public class Main { * 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 @@ public class Main { * 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 @@ public class Main { * 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 (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 (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>>] public static int NegSub2(int arg1, int arg2) { int temp = arg1 - arg2; @@ -670,40 +670,40 @@ public class Main { * 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 @@ public class Main { * 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 @@ public class Main { * 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 (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 (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-NOT: Add public static int SubNeg2(int arg1, int arg2) { int temp = -arg1; @@ -779,28 +779,28 @@ public class Main { * 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 (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 (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 public static long SubNeg3(long arg1, long arg2) { long res = 0; @@ -811,117 +811,117 @@ public class Main { 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 @@ public class Main { * 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 @@ public class Main { 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 218c7cee12..64979ca7ab 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 @@ class AAA { 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 @@ public class Main { 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 e2374480c6..0b75930146 100644 --- a/test/463-checker-boolean-simplifier/src/Main.java +++ b/test/463-checker-boolean-simplifier/src/Main.java @@ -37,33 +37,33 @@ public class Main { * 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: 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-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 (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 (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: Goto + /// CHECK-NOT: Goto public static boolean BooleanNot(boolean x) { return !x; @@ -74,23 +74,23 @@ public class Main { * 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 (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 (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>>] public static boolean GreaterThan(int x, int y) { return (x <= y) ? false : true; @@ -101,26 +101,26 @@ public class Main { * 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 (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 (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-NOT: GreaterThanOrEqual public static boolean LessThan(int x, int y) { return (x < y) ? true : false; @@ -131,57 +131,57 @@ public class Main { * 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 (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 (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>>] 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 (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 (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>>] // 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 e451f703c2..876496fdc4 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 final class Main { 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 ac2863ceb4..704e9fe123 100644 --- a/test/465-checker-clinit-gvn/src/Main.java +++ b/test/465-checker-clinit-gvn/src/Main.java @@ -26,31 +26,31 @@ class OtherClass { 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 33e6dc3d1e..da1c5ec802 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 79d89b0cfe..85f6565503 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 @@ public class Main { 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 @@ public class Main { 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 490f7f9cbc..86d0f7c916 100644 --- a/test/474-checker-boolean-input/src/Main.java +++ b/test/474-checker-boolean-input/src/Main.java @@ -27,9 +27,9 @@ public class Main { * 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 @@ public class Main { * 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 @@ public class Main { * 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 @@ public class Main { * 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 f24dc4abae..e709ba0902 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 @@ class ClassWithFinals { 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 @@ class ClassWithFinals { } } - // 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 ClassWithFinals { } 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 InheritFromClassWithFinals extends ClassWithFinals { 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 @@ class HaveFinalsAndInheritFromClassWithFinals extends ClassWithFinals { 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 b30028ddd4..fe52e83664 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 @@ public class Main { } } - // 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 @@ public class Main { } } - // 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 @@ public class Main { } } - // 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 e8739b8d85..d5592aa49b 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 @@ public class Main { * 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 @@ public class Main { // 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 @@ public class Main { * 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 @@ public class Main { // 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 @@ public class Main { * 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 @@ public class Main { * 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 @@ public class Main { * 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 @@ public class Main { * 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 @@ public class Main { * 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 @@ public class Main { * 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 df583d9302..aa023491a5 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 @@ public class Main { 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 b76755e07c..4cc16344a4 100644 --- a/test/480-checker-dead-blocks/src/Main.java +++ b/test/480-checker-dead-blocks/src/Main.java @@ -30,25 +30,25 @@ public class Main { 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 (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 (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-NOT: If + /// CHECK-NOT: Sub + /// CHECK-NOT: Phi public static int testTrueBranch(int x, int y) { int z; @@ -60,25 +60,25 @@ public class Main { 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 (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 (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-NOT: If + /// CHECK-NOT: Add + /// CHECK-NOT: Phi public static int testFalseBranch(int x, int y) { int z; @@ -90,11 +90,11 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 f5796927f5..5754723d8a 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 @@ public class Main { } } - // 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 @@ public class Main { } } - // 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 @@ public class Main { } } - // 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 @@ public class Main { } } - // 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 @@ public class Main { } } - // 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 @@ public class Main { } } - // 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 @@ public class Main { } } - // 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 33952d9f7e..3715ca2b14 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 @@ public class Main { 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 @@ public class Main { 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 487a5dfbff..da27bf6cf1 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 (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 (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 .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 (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 (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 .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 (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 (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 .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-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: <<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-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 f285566ea7..ea72718ae0 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 @@ public class Main { } } - // 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 4eed39129f..33735cbea0 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 @@ def __extractLine(prefix, line): 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 @@ def __processLine(line, lineNo, prefix): 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 ParseCheckerAssertion(parent, line, variant, lineNo): 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 453deedf46..ff24cc1239 100644 --- a/tools/checker/file_format/checker/test.py +++ b/tools/checker/file_format/checker/test.py @@ -26,43 +26,56 @@ CheckerException = SystemExit 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 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")) + def assertIgnored(self, string): + checkFile = self.tryParse(string) + self.assertEqual(len(checkFile.testCases), 1) + self.assertEqual(len(checkFile.testCases[0].assertions), 0) - self.assertTrue(self.tryParse("//CHECK:foo")) - self.assertTrue(self.tryParse("#CHECK:bar")) + def assertInvalid(self, string): + with self.assertRaises(CheckerException): + self.tryParse(string) - def test_InvalidLabel(self): - self.assertFalse(self.tryParse("//ACHECK:foo")) - self.assertFalse(self.tryParse("#ACHECK:foo")) + def test_ValidFormat(self): + self.assertParses("///CHECK:foo") + self.assertParses("##CHECK:bar") + + def test_InvalidFormat(self): + self.assertIgnored("CHECK") + self.assertIgnored(":CHECK") + self.assertIgnored("CHECK:") + self.assertIgnored("//CHECK") + self.assertIgnored("#CHECK") + self.assertInvalid("///CHECK") + self.assertInvalid("##CHECK") + + 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 @@ class CheckerParser_FileLayoutTest(unittest.TestCase): 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 @@ class CheckerParser_FileLayoutTest(unittest.TestCase): 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 @@ class CheckerParser_FileLayoutTest(unittest.TestCase): 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 @@ class CheckerParser_FileLayoutTest(unittest.TestCase): 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 348c1d2b30..ca748c7726 100644 --- a/tools/checker/match/test.py +++ b/tools/checker/match/test.py @@ -105,7 +105,7 @@ class MatchFiles_Test(unittest.TestCase): def assertMatches(self, checkerString, c1String): checkerString = \ """ - // CHECK-START: MyMethod MyPass + /// CHECK-START: MyMethod MyPass """ + checkerString c1String = \ """ @@ -131,18 +131,18 @@ class MatchFiles_Test(unittest.TestCase): 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 @@ class MatchFiles_Test(unittest.TestCase): """) 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 @@ class MatchFiles_Test(unittest.TestCase): """) 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 @@ class MatchFiles_Test(unittest.TestCase): """) 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 @@ class MatchFiles_Test(unittest.TestCase): """) self.assertDoesNotMatch( """ - // CHECK: foo - // CHECK: bar + /// CHECK: foo + /// CHECK: bar """, """ bar @@ -198,10 +198,10 @@ class MatchFiles_Test(unittest.TestCase): 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 @@ class MatchFiles_Test(unittest.TestCase): """) self.assertMatches( """ - // CHECK: foo - // CHECK-NEXT: bar - // CHECK: def + /// CHECK: foo + /// CHECK-NEXT: bar + /// CHECK: def """, """ foo @@ -223,8 +223,8 @@ class MatchFiles_Test(unittest.TestCase): """) self.assertDoesNotMatch( """ - // CHECK: foo - // CHECK-NEXT: bar + /// CHECK: foo + /// CHECK-NEXT: bar """, """ foo @@ -234,8 +234,8 @@ class MatchFiles_Test(unittest.TestCase): self.assertDoesNotMatch( """ - // CHECK: foo - // CHECK-NEXT: bar + /// CHECK: foo + /// CHECK-NEXT: bar """, """ bar @@ -246,8 +246,8 @@ class MatchFiles_Test(unittest.TestCase): def test_DagAssertions(self): self.assertMatches( """ - // CHECK-DAG: foo - // CHECK-DAG: bar + /// CHECK-DAG: foo + /// CHECK-DAG: bar """, """ foo @@ -255,8 +255,8 @@ class MatchFiles_Test(unittest.TestCase): """) self.assertMatches( """ - // CHECK-DAG: foo - // CHECK-DAG: bar + /// CHECK-DAG: foo + /// CHECK-DAG: bar """, """ bar @@ -266,10 +266,10 @@ class MatchFiles_Test(unittest.TestCase): 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 @@ class MatchFiles_Test(unittest.TestCase): """) 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 @@ class MatchFiles_Test(unittest.TestCase): """) 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 @@ class MatchFiles_Test(unittest.TestCase): def test_NotAssertions(self): self.assertMatches( """ - // CHECK-NOT: foo + /// CHECK-NOT: foo """, """ abc @@ -315,7 +315,7 @@ class MatchFiles_Test(unittest.TestCase): """) self.assertDoesNotMatch( """ - // CHECK-NOT: foo + /// CHECK-NOT: foo """, """ abc foo @@ -323,8 +323,8 @@ class MatchFiles_Test(unittest.TestCase): """) self.assertDoesNotMatch( """ - // CHECK-NOT: foo - // CHECK-NOT: bar + /// CHECK-NOT: foo + /// CHECK-NOT: bar """, """ abc @@ -334,9 +334,9 @@ class MatchFiles_Test(unittest.TestCase): 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 @@ class MatchFiles_Test(unittest.TestCase): """) self.assertMatches( """ - // CHECK: abc - // CHECK-NOT: foo - // CHECK: def + /// CHECK: abc + /// CHECK-NOT: foo + /// CHECK: def """, """ abc @@ -355,9 +355,9 @@ class MatchFiles_Test(unittest.TestCase): """) self.assertDoesNotMatch( """ - // CHECK: abc - // CHECK-NOT: foo - // CHECK: def + /// CHECK: abc + /// CHECK-NOT: foo + /// CHECK: def """, """ abc @@ -368,8 +368,8 @@ class MatchFiles_Test(unittest.TestCase): def test_LineOnlyMatchesOnce(self): self.assertMatches( """ - // CHECK-DAG: foo - // CHECK-DAG: foo + /// CHECK-DAG: foo + /// CHECK-DAG: foo """, """ foo @@ -378,8 +378,8 @@ class MatchFiles_Test(unittest.TestCase): """) self.assertDoesNotMatch( """ - // CHECK-DAG: foo - // CHECK-DAG: foo + /// CHECK-DAG: foo + /// CHECK-DAG: foo """, """ foo |