diff options
| author | 2015-05-28 11:14:54 +0100 | |
|---|---|---|
| committer | 2015-05-28 11:57:49 +0100 | |
| commit | a06d66a4ee60926127b9498b7ff0b3e37a24fccf (patch) | |
| tree | 87ec5d72211d5c3446e1d80ee71eda77faffd6b3 /test | |
| 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
Diffstat (limited to 'test')
26 files changed, 2260 insertions, 2260 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(); } |