ART: Print C1vis lists as [v1,...,vN]
Checker interprets whitespace as a don't-care placeholder, making it
easier to write assertions which test only parts of the output (e.g.
"//CHECK: Add liveness:44" does not test the inputs or any other
attributes apart from "liveness").
However, since the GraphVisualizer prints lists with elements
separated by spaces ("[ v1 ... vN ]"), this allows for false positives
caused by an occurrence elsewhere in the output. For example, the
assertion: "//CHECK: [ x y ]" will match "[ x y ]" but also
"[ x a y b ]" or even "[ x ] abc [ y ]".
Switching to comma-separated lists works around this issue.
This patch updates all test files, fixes one false positive that this
change revealed (test 442, line 337) and two occurrences of a wrong
match (test 462, lines 121, 149).
Bug: 21189305
Change-Id: I3b22503be3d92529dac0b13f66bccbcfabea6721
diff --git a/compiler/optimizing/graph_visualizer.cc b/compiler/optimizing/graph_visualizer.cc
index e0a9c6f..7ea1240 100644
--- a/compiler/optimizing/graph_visualizer.cc
+++ b/compiler/optimizing/graph_visualizer.cc
@@ -58,7 +58,7 @@
if (is_empty_) {
is_empty_ = false;
} else {
- sstream_ << " ";
+ sstream_ << ",";
}
return sstream_;
}
@@ -71,7 +71,7 @@
};
std::ostream& operator<<(std::ostream& os, const StringList& list) {
- return os << "[ " << list.sstream_.str() << " ]";
+ return os << "[" << list.sstream_.str() << "]";
}
/**
diff --git a/test/441-checker-inliner/src/Main.java b/test/441-checker-inliner/src/Main.java
index 1c3855f..8894d4e 100644
--- a/test/441-checker-inliner/src/Main.java
+++ b/test/441-checker-inliner/src/Main.java
@@ -19,7 +19,7 @@
// CHECK-START: void Main.InlineVoid() inliner (before)
// CHECK-DAG: <<Const42:i\d+>> IntConstant 42
// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-DAG: InvokeStaticOrDirect [ <<Const42>> ]
+ // CHECK-DAG: InvokeStaticOrDirect [<<Const42>>]
// CHECK-START: void Main.InlineVoid() inliner (after)
// CHECK-NOT: InvokeStaticOrDirect
@@ -31,12 +31,12 @@
// 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-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-DAG: Return [<<Param>>]
public static int InlineParameter(int a) {
return returnParameter(a);
@@ -44,12 +44,12 @@
// 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-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-DAG: Return [<<Param>>]
public static long InlineWideParameter(long a) {
return returnWideParameter(a);
@@ -57,12 +57,12 @@
// 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-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-DAG: Return [<<Param>>]
public static Object InlineReferenceParameter(Object o) {
return returnReferenceParameter(o);
@@ -70,11 +70,11 @@
// CHECK-START: int Main.InlineInt() inliner (before)
// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Result>> ]
+ // CHECK-DAG: Return [<<Result>>]
// CHECK-START: int Main.InlineInt() inliner (after)
// CHECK-DAG: <<Const4:i\d+>> IntConstant 4
- // CHECK-DAG: Return [ <<Const4>> ]
+ // CHECK-DAG: Return [<<Const4>>]
public static int InlineInt() {
return returnInt();
@@ -82,11 +82,11 @@
// CHECK-START: long Main.InlineWide() inliner (before)
// CHECK-DAG: <<Result:j\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Result>> ]
+ // CHECK-DAG: Return [<<Result>>]
// CHECK-START: long Main.InlineWide() inliner (after)
// CHECK-DAG: <<Const8:j\d+>> LongConstant 8
- // CHECK-DAG: Return [ <<Const8>> ]
+ // CHECK-DAG: Return [<<Const8>>]
public static long InlineWide() {
return returnWide();
@@ -96,13 +96,13 @@
// 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-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-DAG: <<Add:i\d+>> Add [<<Const3>>,<<Const5>>]
+ // CHECK-DAG: Return [<<Add>>]
public static int InlineAdd() {
return returnAdd(3, 5);
@@ -110,14 +110,14 @@
// CHECK-START: int Main.InlineFieldAccess() inliner (before)
// CHECK-DAG: <<After:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<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-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
@@ -130,19 +130,19 @@
// 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-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-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 9a2e4fc..c258db9 100644
--- a/test/442-checker-constant-folding/src/Main.java
+++ b/test/442-checker-constant-folding/src/Main.java
@@ -53,12 +53,12 @@
// 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-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-DAG: Return [<<ConstN42>>]
public static int IntNegation() {
int x, y;
@@ -75,12 +75,12 @@
// 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-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-DAG: Return [<<Const3>>]
public static int IntAddition1() {
int a, b, c;
@@ -100,14 +100,14 @@
// 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-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-DAG: Return [<<Const14>>]
public static int IntAddition2() {
int a, b, c;
@@ -129,12 +129,12 @@
// 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-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-DAG: Return [<<Const4>>]
public static int IntSubtraction() {
int a, b, c;
@@ -152,12 +152,12 @@
// 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-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-DAG: Return [<<Const3>>]
public static long LongAddition() {
long a, b, c;
@@ -175,12 +175,12 @@
// 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-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-DAG: Return [<<Const4>>]
public static long LongSubtraction() {
long a, b, c;
@@ -197,12 +197,12 @@
// 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-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-DAG: If [<<Const1>>]
public static int StaticCondition() {
int a, b, c;
@@ -227,16 +227,16 @@
// 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-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-DAG: <<Phi:i\d+>> Phi [<<Const7>>,<<Const3>>]
+ // CHECK-DAG: Return [<<Phi>>]
public static int JumpsAndConditionals(boolean cond) {
int a, b, c;
@@ -256,14 +256,14 @@
// 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-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-DAG: Return [<<Const0>>]
public static int And0(int arg) {
return arg & 0;
@@ -272,14 +272,14 @@
// 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-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-DAG: Return [<<Const0>>]
public static long Mul0(long arg) {
return arg * 0;
@@ -288,13 +288,13 @@
// 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-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-DAG: Return [<<ConstF>>]
public static int OrAllOnes(int arg) {
return arg | -1;
@@ -303,14 +303,14 @@
// 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-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-DAG: Return [<<Const0>>]
public static long Rem0(long arg) {
return 0 % arg;
@@ -319,13 +319,13 @@
// 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-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-DAG: Return [<<Const0>>]
public static int Rem1(int arg) {
return arg % 1;
@@ -334,14 +334,14 @@
// 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 [ <<Arg>> ]
- // CHECK-DAG: <<Rem:j\d+>> Rem [ <<Arg>> <<DivZeroCheck>> ]
- // CHECK-DAG: Return [ <<Rem>> ]
+ // 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-DAG: Return [<<Const0>>]
public static long RemN1(long arg) {
return arg % -1;
@@ -350,14 +350,14 @@
// 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-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-DAG: Return [<<Const0>>]
public static int Shl0(int arg) {
return 0 << arg;
@@ -366,14 +366,14 @@
// 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-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-DAG: Return [<<Const0>>]
public static long Shr0(int arg) {
return (long)0 >> arg;
@@ -381,14 +381,14 @@
// 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-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-DAG: Return [<<Const0>>]
public static long SubSameLong(long arg) {
return arg - arg;
@@ -397,14 +397,14 @@
// 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-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-DAG: Return [<<Const0>>]
public static int UShr0(int arg) {
return 0 >>> arg;
@@ -412,14 +412,14 @@
// 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-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-DAG: Return [<<Const0>>]
public static int XorSameInt(int arg) {
return arg ^ arg;
@@ -430,16 +430,16 @@
// 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-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-DAG: If [<<Const1>>]
// CHECK-START: boolean Main.CmpFloatGreaterThanNaN(float) constant_folding (after)
// CHECK-NOT: Compare
@@ -454,16 +454,16 @@
// 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-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-DAG: If [<<Const1>>]
// CHECK-START: boolean Main.CmpDoubleLessThanNaN(double) constant_folding (after)
// CHECK-NOT: Compare
@@ -475,12 +475,12 @@
// 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-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-DAG: Return [<<Const33>>]
public static int ReturnInt33() {
long imm = 33L;
@@ -489,12 +489,12 @@
// 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-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-DAG: Return [<<ConstMax>>]
public static int ReturnIntMax() {
float imm = 1.0e34f;
@@ -503,12 +503,12 @@
// 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-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-DAG: Return [<<Const0>>]
public static int ReturnInt0() {
double imm = Double.NaN;
@@ -517,12 +517,12 @@
// 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-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-DAG: Return [<<Const33>>]
public static long ReturnLong33() {
int imm = 33;
@@ -531,12 +531,12 @@
// 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-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-DAG: Return [<<Const34>>]
public static long ReturnLong34() {
float imm = 34.0f;
@@ -545,12 +545,12 @@
// 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-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-DAG: Return [<<Const0>>]
public static long ReturnLong0() {
double imm = -Double.NaN;
@@ -559,12 +559,12 @@
// 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-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-DAG: Return [<<Const33>>]
public static float ReturnFloat33() {
int imm = 33;
@@ -573,12 +573,12 @@
// 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-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-DAG: Return [<<Const34>>]
public static float ReturnFloat34() {
long imm = 34L;
@@ -587,12 +587,12 @@
// 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-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-DAG: Return [<<Const>>]
public static float ReturnFloat99P25() {
double imm = 99.25;
@@ -601,12 +601,12 @@
// 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-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-DAG: Return [<<Const33>>]
public static double ReturnDouble33() {
int imm = 33;
@@ -615,12 +615,12 @@
// 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-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-DAG: Return [<<Const34>>]
public static double ReturnDouble34() {
long imm = 34L;
@@ -629,12 +629,12 @@
// 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-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-DAG: Return [<<Const>>]
public static double ReturnDouble99P25() {
float imm = 99.25f;
diff --git a/test/445-checker-licm/src/Main.java b/test/445-checker-licm/src/Main.java
index ce2ab9a..96918d3 100644
--- a/test/445-checker-licm/src/Main.java
+++ b/test/445-checker-licm/src/Main.java
@@ -89,7 +89,7 @@
// 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-DAG: ArrayLength [<<NullCheck>>] loop:{{B\d+}}
// CHECK-START: int Main.arrayLength(int[]) licm (after)
// CHECK-NOT: NullCheck loop:{{B\d+}}
@@ -97,7 +97,7 @@
// CHECK-START: int Main.arrayLength(int[]) licm (after)
// CHECK-DAG: <<NullCheck:l\d+>> NullCheck loop:none
- // CHECK-DAG: ArrayLength [ <<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 5d4ddf8..9ed66d6 100644
--- a/test/446-checker-inliner2/src/Main.java
+++ b/test/446-checker-inliner2/src/Main.java
@@ -18,14 +18,14 @@
// CHECK-START: int Main.inlineInstanceCall(Main) inliner (before)
// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Invoke>> ]
+ // CHECK-DAG: Return [<<Invoke>>]
// 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-DAG: Return [<<Field>>]
public static int inlineInstanceCall(Main m) {
return m.foo();
@@ -39,14 +39,14 @@
// CHECK-START: int Main.inlineNestedCall() inliner (before)
// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Invoke>> ]
+ // CHECK-DAG: Return [<<Invoke>>]
// 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-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 34faafa..9d022b9 100644
--- a/test/447-checker-inliner3/src/Main.java
+++ b/test/447-checker-inliner3/src/Main.java
@@ -18,7 +18,7 @@
// CHECK-START: int Main.inlineIfThenElse() inliner (before)
// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Invoke>> ]
+ // CHECK-DAG: Return [<<Invoke>>]
// CHECK-START: int Main.inlineIfThenElse() inliner (after)
// CHECK-NOT: InvokeStaticOrDirect
diff --git a/test/458-checker-instruction-simplification/src/Main.java b/test/458-checker-instruction-simplification/src/Main.java
index ebad8e5..742210c 100644
--- a/test/458-checker-instruction-simplification/src/Main.java
+++ b/test/458-checker-instruction-simplification/src/Main.java
@@ -53,12 +53,12 @@
// 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-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-DAG: Return [<<Arg>>]
// CHECK-START: long Main.Add0(long) instruction_simplifier (after)
// CHECK-NOT: Add
@@ -70,12 +70,12 @@
// 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-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-DAG: Return [<<Arg>>]
// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after)
// CHECK-NOT: And
@@ -87,12 +87,12 @@
// 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-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-DAG: Return [<<Arg>>]
// CHECK-START: long Main.Div1(long) instruction_simplifier (after)
// CHECK-NOT: Div
@@ -104,13 +104,13 @@
// 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-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-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
+ // CHECK-DAG: Return [<<Neg>>]
// CHECK-START: int Main.DivN1(int) instruction_simplifier (after)
// CHECK-NOT: Div
@@ -122,12 +122,12 @@
// 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-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-DAG: Return [<<Arg>>]
// CHECK-START: long Main.Mul1(long) instruction_simplifier (after)
// CHECK-NOT: Mul
@@ -139,13 +139,13 @@
// 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-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-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
+ // CHECK-DAG: Return [<<Neg>>]
// CHECK-START: int Main.MulN1(int) instruction_simplifier (after)
// CHECK-NOT: Mul
@@ -157,14 +157,14 @@
// 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-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-DAG: <<Shl:j\d+>> Shl [<<Arg>>,<<Const7>>]
+ // CHECK-DAG: Return [<<Shl>>]
// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after)
// CHECK-NOT: Mul
@@ -176,12 +176,12 @@
// 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-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-DAG: Return [<<Arg>>]
// CHECK-START: int Main.Or0(int) instruction_simplifier (after)
// CHECK-NOT: Or
@@ -192,12 +192,12 @@
// 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-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-DAG: Return [<<Arg>>]
// CHECK-START: long Main.OrSame(long) instruction_simplifier (after)
// CHECK-NOT: Or
@@ -209,12 +209,12 @@
// 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-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-DAG: Return [<<Arg>>]
// CHECK-START: int Main.Shl0(int) instruction_simplifier (after)
// CHECK-NOT: Shl
@@ -226,13 +226,13 @@
// 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-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-DAG: <<Add:i\d+>> Add [<<Arg>>,<<Arg>>]
+ // CHECK-DAG: Return [<<Add>>]
// CHECK-START: int Main.Shl1(int) instruction_simplifier (after)
// CHECK-NOT: Shl
@@ -244,12 +244,12 @@
// 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-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-DAG: Return [<<Arg>>]
// CHECK-START: long Main.Shr0(long) instruction_simplifier (after)
// CHECK-NOT: Shr
@@ -261,12 +261,12 @@
// 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-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-DAG: Return [<<Arg>>]
// CHECK-START: long Main.Sub0(long) instruction_simplifier (after)
// CHECK-NOT: Sub
@@ -278,13 +278,13 @@
// 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-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-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
+ // CHECK-DAG: Return [<<Neg>>]
// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after)
// CHECK-NOT: Sub
@@ -296,12 +296,12 @@
// 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-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-DAG: Return [<<Arg>>]
// CHECK-START: long Main.UShr0(long) instruction_simplifier (after)
// CHECK-NOT: UShr
@@ -313,12 +313,12 @@
// 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-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-DAG: Return [<<Arg>>]
// CHECK-START: int Main.Xor0(int) instruction_simplifier (after)
// CHECK-NOT: Xor
@@ -330,13 +330,13 @@
// 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-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-DAG: <<Not:i\d+>> Not [<<Arg>>]
+ // CHECK-DAG: Return [<<Not>>]
// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after)
// CHECK-NOT: Xor
@@ -355,18 +355,18 @@
// 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-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-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;
@@ -386,32 +386,32 @@
// 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-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-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-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-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;
@@ -431,24 +431,24 @@
// -------------- 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-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: <<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-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: <<Add:j\d+>> Add [<<Neg1>>,<<Neg2>>]
// CHECK-NOT: Neg
// CHECK: Goto
@@ -471,15 +471,15 @@
// 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-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-DAG: <<Sub:j\d+>> Sub [<<Arg2>>,<<Arg1>>]
+ // CHECK-DAG: Return [<<Sub>>]
// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after)
// CHECK-NOT: Neg
@@ -501,20 +501,20 @@
// 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-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-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
@@ -531,13 +531,13 @@
// 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-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-DAG: Return [<<Arg>>]
// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after)
// CHECK-NOT: Neg
@@ -555,15 +555,15 @@
// 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-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-DAG: <<Sub:i\d+>> Sub [<<Arg>>,<<Arg>>]
+ // CHECK-DAG: Return [<<Sub>>]
// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after)
// CHECK-NOT: Neg
@@ -573,7 +573,7 @@
// CHECK: <<Const0:i\d+>> IntConstant 0
// CHECK-NOT: Neg
// CHECK-NOT: Add
- // CHECK: Return [ <<Const0>> ]
+ // CHECK: Return [<<Const0>>]
public static int NegNeg2(int arg) {
int temp = -arg;
@@ -590,13 +590,13 @@
// 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-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-DAG: Return [<<Arg>>]
// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after)
// CHECK-NOT: Neg
@@ -615,15 +615,15 @@
// 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-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-DAG: <<Sub:i\d+>> Sub [<<Arg2>>,<<Arg1>>]
+ // CHECK-DAG: Return [<<Sub>>]
// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after)
// CHECK-NOT: Neg
@@ -645,20 +645,20 @@
// 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-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-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;
@@ -673,13 +673,13 @@
// 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-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-DAG: Return [<<Arg>>]
// CHECK-START: long Main.NotNot1(long) instruction_simplifier (after)
// CHECK-NOT: Xor
@@ -691,16 +691,16 @@
// 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-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-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
@@ -718,16 +718,16 @@
// 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-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-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
@@ -749,20 +749,20 @@
// 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-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-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
@@ -783,22 +783,22 @@
// -------------- 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: <<Neg:j\d+>> Neg [<<Arg1>>]
// CHECK: Goto
// -------------- Loop
// CHECK: SuspendCheck
- // CHECK: <<Sub:j\d+>> Sub [ <<Neg>> <<Arg2>> ]
+ // 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: <<Neg:j\d+>> Neg [<<Arg1>>]
// CHECK-DAG: Goto
// -------------- Loop
// CHECK: SuspendCheck
- // CHECK: <<Sub:j\d+>> Sub [ <<Neg>> <<Arg2>> ]
+ // CHECK: <<Sub:j\d+>> Sub [<<Neg>>,<<Arg2>>]
// CHECK-NOT: Neg
// CHECK: Goto
@@ -814,12 +814,12 @@
// 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-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-DAG: If [<<Arg>>]
public static int EqualTrueRhs(boolean arg) {
return (arg != true) ? 3 : 5;
@@ -828,12 +828,12 @@
// 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-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-DAG: If [<<Arg>>]
public static int EqualTrueLhs(boolean arg) {
return (true != arg) ? 3 : 5;
@@ -842,13 +842,13 @@
// 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-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-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ // CHECK-DAG: If [<<NotArg>>]
public static int EqualFalseRhs(boolean arg) {
return (arg != false) ? 3 : 5;
@@ -857,13 +857,13 @@
// 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-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-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ // CHECK-DAG: If [<<NotArg>>]
public static int EqualFalseLhs(boolean arg) {
return (false != arg) ? 3 : 5;
@@ -872,13 +872,13 @@
// 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-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-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ // CHECK-DAG: If [<<NotArg>>]
public static int NotEqualTrueRhs(boolean arg) {
return (arg == true) ? 3 : 5;
@@ -887,13 +887,13 @@
// 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-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-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ // CHECK-DAG: If [<<NotArg>>]
public static int NotEqualTrueLhs(boolean arg) {
return (true == arg) ? 3 : 5;
@@ -902,12 +902,12 @@
// 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-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-DAG: If [<<Arg>>]
public static int NotEqualFalseRhs(boolean arg) {
return (arg == false) ? 3 : 5;
@@ -916,12 +916,12 @@
// 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-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-DAG: If [<<Arg>>]
public static int NotEqualFalseLhs(boolean arg) {
return (false == arg) ? 3 : 5;
@@ -935,14 +935,14 @@
// 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-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-DAG: BooleanNot [<<Arg>>]
+ // CHECK-DAG: Return [<<Arg>>]
// CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (after)
// CHECK: BooleanNot
@@ -959,14 +959,14 @@
// 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-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-DAG: <<Mul:f\d+>> Mul [<<Arg>>,<<ConstP5>>]
+ // CHECK-DAG: Return [<<Mul>>]
// CHECK-START: float Main.Div2(float) instruction_simplifier (after)
// CHECK-NOT: Div
@@ -978,14 +978,14 @@
// 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-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-DAG: <<Mul:d\d+>> Mul [<<Arg>>,<<ConstP5>>]
+ // CHECK-DAG: Return [<<Mul>>]
// CHECK-START: double Main.Div2(double) instruction_simplifier (after)
// CHECK-NOT: Div
@@ -996,14 +996,14 @@
// 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-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-DAG: <<Mul:f\d+>> Mul [<<Arg>>,<<ConstM4>>]
+ // CHECK-DAG: Return [<<Mul>>]
// CHECK-START: float Main.DivMP25(float) instruction_simplifier (after)
// CHECK-NOT: Div
@@ -1015,14 +1015,14 @@
// 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-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-DAG: <<Mul:d\d+>> Mul [<<Arg>>,<<ConstM4>>]
+ // CHECK-DAG: Return [<<Mul>>]
// CHECK-START: double Main.DivMP25(double) instruction_simplifier (after)
// CHECK-NOT: Div
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 5ebf3d1..3d583b4 100644
--- a/test/462-checker-inlining-across-dex-files/src/Main.java
+++ b/test/462-checker-inlining-across-dex-files/src/Main.java
@@ -34,14 +34,14 @@
// CHECK-START: int Main.inlineReturnIntMethod() inliner (before)
// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Invoke>> ]
+ // CHECK-DAG: Return [<<Invoke>>]
// 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-DAG: Return [<<Const38>>]
public static int inlineReturnIntMethod() {
return OtherDex.returnIntMethod();
@@ -49,11 +49,11 @@
// CHECK-START: int Main.dontInlineOtherDexStatic() inliner (before)
// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Invoke>> ]
+ // CHECK-DAG: Return [<<Invoke>>]
// CHECK-START: int Main.dontInlineOtherDexStatic() inliner (after)
// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Invoke>> ]
+ // CHECK-DAG: Return [<<Invoke>>]
public static int dontInlineOtherDexStatic() {
return OtherDex.returnOtherDexStatic();
@@ -61,14 +61,14 @@
// CHECK-START: int Main.inlineMainStatic() inliner (before)
// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Invoke>> ]
+ // CHECK-DAG: Return [<<Invoke>>]
// 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-DAG: Return [<<Static>>]
public static int inlineMainStatic() {
return OtherDex.returnMainStatic();
@@ -76,11 +76,11 @@
// CHECK-START: int Main.dontInlineRecursiveCall() inliner (before)
// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Invoke>> ]
+ // CHECK-DAG: Return [<<Invoke>>]
// CHECK-START: int Main.dontInlineRecursiveCall() inliner (after)
// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Invoke>> ]
+ // CHECK-DAG: Return [<<Invoke>>]
public static int dontInlineRecursiveCall() {
return OtherDex.recursiveCall();
@@ -88,11 +88,11 @@
// CHECK-START: java.lang.String Main.dontInlineReturnString() inliner (before)
// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Invoke>> ]
+ // CHECK-DAG: Return [<<Invoke>>]
// CHECK-START: java.lang.String Main.dontInlineReturnString() inliner (after)
// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Invoke>> ]
+ // CHECK-DAG: Return [<<Invoke>>]
public static String dontInlineReturnString() {
return OtherDex.returnString();
@@ -100,11 +100,11 @@
// CHECK-START: java.lang.Class Main.dontInlineOtherDexClass() inliner (before)
// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Invoke>> ]
+ // CHECK-DAG: Return [<<Invoke>>]
// CHECK-START: java.lang.Class Main.dontInlineOtherDexClass() inliner (after)
// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Invoke>> ]
+ // CHECK-DAG: Return [<<Invoke>>]
public static Class dontInlineOtherDexClass() {
return OtherDex.returnOtherDexClass();
@@ -112,14 +112,15 @@
// CHECK-START: java.lang.Class Main.inlineMainClass() inliner (before)
// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Invoke>> ]
+ // 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-DAG: <<Class:l\d+>> LoadClass
- // CHECK-DAG: Return [ <<Class>> ]
+ // CHECK-DAG: Return [<<Class:l\d+>>]
+ // CHECK-DAG: <<Class>> LoadClass
+ // Note: Verify backwards because there are two LoadClass instructions
public static Class inlineMainClass() {
return OtherDex.returnMainClass();
@@ -127,11 +128,11 @@
// CHECK-START: java.lang.Class Main.dontInlineOtherDexClassStaticCall() inliner (before)
// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Invoke>> ]
+ // CHECK-DAG: Return [<<Invoke>>]
// CHECK-START: java.lang.Class Main.dontInlineOtherDexClassStaticCall() inliner (after)
// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Invoke>> ]
+ // CHECK-DAG: Return [<<Invoke>>]
public static Class dontInlineOtherDexClassStaticCall() {
return OtherDex.returnOtherDexClassStaticCall();
@@ -139,14 +140,15 @@
// CHECK-START: java.lang.Class Main.inlineOtherDexCallingMain() inliner (before)
// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Invoke>> ]
+ // 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-DAG: <<Class:l\d+>> LoadClass
- // CHECK-DAG: Return [ <<Class>> ]
+ // CHECK-DAG: Return [<<Class:l\d+>>]
+ // CHECK-DAG: <<Class>> LoadClass
+ // Note: Verify backwards because there are two LoadClass instructions
public static Class inlineOtherDexCallingMain() {
return OtherDex.returnOtherDexCallingMain();
diff --git a/test/463-checker-boolean-simplifier/src/Main.java b/test/463-checker-boolean-simplifier/src/Main.java
index 3f3110f..e237448 100644
--- a/test/463-checker-boolean-simplifier/src/Main.java
+++ b/test/463-checker-boolean-simplifier/src/Main.java
@@ -41,9 +41,9 @@
// 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-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
@@ -54,8 +54,8 @@
// 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-DAG: <<NotParam:z\d+>> BooleanNot [<<Param>>]
+ // CHECK-DAG: Return [<<NotParam>>]
// CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (after)
// CHECK-NOT: If
@@ -79,18 +79,18 @@
// 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-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-DAG: <<Cond:z\d+>> GreaterThan [<<ParamX>>,<<ParamY>>]
+ // CHECK-DAG: Return [<<Cond>>]
public static boolean GreaterThan(int x, int y) {
return (x <= y) ? false : true;
@@ -106,18 +106,18 @@
// 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-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-DAG: <<Cond:z\d+>> LessThan [<<ParamX>>,<<ParamY>>]
+ // CHECK-DAG: Return [<<Cond>>]
// CHECK-START: boolean Main.LessThan(int, int) boolean_simplifier (after)
// CHECK-NOT: GreaterThanOrEqual
@@ -137,25 +137,25 @@
// 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-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-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);
@@ -165,18 +165,18 @@
// 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-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-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.
diff --git a/test/464-checker-inline-sharpen-calls/src/Main.java b/test/464-checker-inline-sharpen-calls/src/Main.java
index 626823e..e451f70 100644
--- a/test/464-checker-inline-sharpen-calls/src/Main.java
+++ b/test/464-checker-inline-sharpen-calls/src/Main.java
@@ -32,14 +32,14 @@
// CHECK-START: int Main.inlineSharpenStringInvoke() inliner (before)
// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [ <<Invoke>> ]
+ // CHECK-DAG: Return [<<Invoke>>]
// 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-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 b712715..ac2863c 100644
--- a/test/465-checker-clinit-gvn/src/Main.java
+++ b/test/465-checker-clinit-gvn/src/Main.java
@@ -28,13 +28,13 @@
// CHECK-START: int Main.accessTwoStatics() GVN (before)
// CHECK-DAG: <<Class1:l\d+>> LoadClass
- // CHECK-DAG: ClinitCheck [ <<Class1>> ]
+ // CHECK-DAG: ClinitCheck [<<Class1>>]
// CHECK-DAG: <<Class2:l\d+>> LoadClass
- // CHECK-DAG: ClinitCheck [ <<Class2>> ]
+ // CHECK-DAG: ClinitCheck [<<Class2>>]
// CHECK-START: int Main.accessTwoStatics() GVN (after)
// CHECK-DAG: <<Class:l\d+>> LoadClass
- // CHECK-DAG: ClinitCheck [ <<Class>> ]
+ // CHECK-DAG: ClinitCheck [<<Class>>]
// CHECK-NOT: ClinitCheck
public static int accessTwoStatics() {
@@ -43,13 +43,13 @@
// CHECK-START: int Main.accessTwoStaticsCallInBetween() GVN (before)
// CHECK-DAG: <<Class1:l\d+>> LoadClass
- // CHECK-DAG: ClinitCheck [ <<Class1>> ]
+ // CHECK-DAG: ClinitCheck [<<Class1>>]
// CHECK-DAG: <<Class2:l\d+>> LoadClass
- // CHECK-DAG: ClinitCheck [ <<Class2>> ]
+ // CHECK-DAG: ClinitCheck [<<Class2>>]
// CHECK-START: int Main.accessTwoStaticsCallInBetween() GVN (after)
// CHECK-DAG: <<Class:l\d+>> LoadClass
- // CHECK-DAG: ClinitCheck [ <<Class>> ]
+ // CHECK-DAG: ClinitCheck [<<Class>>]
// CHECK-NOT: ClinitCheck
public static int accessTwoStaticsCallInBetween() {
diff --git a/test/468-checker-bool-simplifier-regression/smali/TestCase.smali b/test/468-checker-bool-simplifier-regression/smali/TestCase.smali
index 0cb5313..33e6dc3 100644
--- a/test/468-checker-bool-simplifier-regression/smali/TestCase.smali
+++ b/test/468-checker-bool-simplifier-regression/smali/TestCase.smali
@@ -22,14 +22,14 @@
# 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-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-DAG: <<Not:z\d+>> BooleanNot [<<Value>>]
+# CHECK-DAG: Return [<<Not>>]
.method public static testCase()Z
.registers 2
diff --git a/test/474-checker-boolean-input/src/Main.java b/test/474-checker-boolean-input/src/Main.java
index a395ff9..490f7f9 100644
--- a/test/474-checker-boolean-input/src/Main.java
+++ b/test/474-checker-boolean-input/src/Main.java
@@ -29,7 +29,7 @@
// CHECK-START: boolean Main.TestPhiAsBoolean(int) boolean_simplifier (after)
// CHECK-DAG: <<Phi:i\d+>> Phi
- // CHECK-DAG: BooleanNot [ <<Phi>> ]
+ // CHECK-DAG: BooleanNot [<<Phi>>]
public static boolean f1;
public static boolean f2;
@@ -49,7 +49,7 @@
// CHECK-START: boolean Main.TestAndAsBoolean(boolean, boolean) boolean_simplifier (after)
// CHECK-DAG: <<And:i\d+>> And
- // CHECK-DAG: BooleanNot [ <<And>> ]
+ // CHECK-DAG: BooleanNot [<<And>>]
public static boolean InlineAnd(boolean x, boolean y) {
return x & y;
@@ -66,7 +66,7 @@
// CHECK-START: boolean Main.TestOrAsBoolean(boolean, boolean) boolean_simplifier (after)
// CHECK-DAG: <<Or:i\d+>> Or
- // CHECK-DAG: BooleanNot [ <<Or>> ]
+ // CHECK-DAG: BooleanNot [<<Or>>]
public static boolean InlineOr(boolean x, boolean y) {
return x | y;
@@ -83,7 +83,7 @@
// CHECK-START: boolean Main.TestXorAsBoolean(boolean, boolean) boolean_simplifier (after)
// CHECK-DAG: <<Xor:i\d+>> Xor
- // CHECK-DAG: BooleanNot [ <<Xor>> ]
+ // CHECK-DAG: BooleanNot [<<Xor>>]
public static boolean InlineXor(boolean x, boolean y) {
return x ^ y;
diff --git a/test/478-checker-clinit-check-pruning/src/Main.java b/test/478-checker-clinit-check-pruning/src/Main.java
index b36b7d6..61199a7 100644
--- a/test/478-checker-clinit-check-pruning/src/Main.java
+++ b/test/478-checker-clinit-check-pruning/src/Main.java
@@ -25,12 +25,12 @@
// CHECK-START: void Main.invokeStaticInlined() builder (after)
// CHECK-DAG: <<LoadClass:l\d+>> LoadClass
- // CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [ <<LoadClass>> ]
- // CHECK-DAG: InvokeStaticOrDirect [ <<ClinitCheck>> ]
+ // CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
+ // CHECK-DAG: InvokeStaticOrDirect [<<ClinitCheck>>]
// CHECK-START: void Main.invokeStaticInlined() inliner (after)
// CHECK-DAG: <<LoadClass:l\d+>> LoadClass
- // CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [ <<LoadClass>> ]
+ // CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
// CHECK-START: void Main.invokeStaticInlined() inliner (after)
// CHECK-NOT: InvokeStaticOrDirect
@@ -68,13 +68,13 @@
// CHECK-START: void Main.invokeStaticNotInlined() builder (after)
// CHECK-DAG: <<LoadClass:l\d+>> LoadClass
- // CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [ <<LoadClass>> ]
- // CHECK-DAG: InvokeStaticOrDirect [ <<ClinitCheck>> ]
+ // CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
+ // CHECK-DAG: InvokeStaticOrDirect [<<ClinitCheck>>]
// CHECK-START: void Main.invokeStaticNotInlined() inliner (after)
// CHECK-DAG: <<LoadClass:l\d+>> LoadClass
- // CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [ <<LoadClass>> ]
- // CHECK-DAG: InvokeStaticOrDirect [ <<ClinitCheck>> ]
+ // 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
diff --git a/test/480-checker-dead-blocks/src/Main.java b/test/480-checker-dead-blocks/src/Main.java
index dda1a43..b76755e 100644
--- a/test/480-checker-dead-blocks/src/Main.java
+++ b/test/480-checker-dead-blocks/src/Main.java
@@ -34,16 +34,16 @@
// 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-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-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
@@ -64,16 +64,16 @@
// 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-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-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
@@ -126,7 +126,7 @@
// CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (after)
// CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: Return [ <<Arg>> ]
+ // CHECK-DAG: Return [<<Arg>>]
// CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (after)
// CHECK-NOT: If
@@ -146,7 +146,7 @@
// CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (after)
// CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: Return [ <<Arg>> ]
+ // CHECK-DAG: Return [<<Arg>>]
// CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (after)
// CHECK-NOT: If
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 334792e..9e1076a 100644
--- a/test/482-checker-loop-back-edge-use/src/Main.java
+++ b/test/482-checker-loop-back-edge-use/src/Main.java
@@ -18,14 +18,14 @@
public class Main {
// CHECK-START: void Main.loop1(boolean) liveness (after)
- // CHECK: ParameterValue liveness:2 ranges:[ 2-22 ] uses:[ 17 22 ]
+ // 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:2 ranges:[ 2-42 ] uses:[ 33 38 42 ]
+ // CHECK: ParameterValue liveness:2 ranges:[2-42] uses:[33,38,42]
// CHECK: Goto liveness:36
// CHECK: Goto liveness:40
public static void loop2(boolean incoming) {
@@ -36,7 +36,7 @@
}
// CHECK-START: void Main.loop3(boolean) liveness (after)
- // CHECK: ParameterValue liveness:2 ranges:[ 2-60 ] uses:[ 56 60 ]
+ // CHECK: ParameterValue liveness:2 ranges:[2-60] uses:[56,60]
// CHECK: Goto liveness:58
// CHECK-START: void Main.loop3(boolean) liveness (after)
@@ -50,7 +50,7 @@
}
// CHECK-START: void Main.loop4(boolean) liveness (after)
- // CHECK: ParameterValue liveness:2 ranges:[ 2-22 ] uses:[ 22 ]
+ // CHECK: ParameterValue liveness:2 ranges:[2-22] uses:[22]
// CHECK-START: void Main.loop4(boolean) liveness (after)
// CHECK-NOT: Goto liveness:20
@@ -63,7 +63,7 @@
}
// CHECK-START: void Main.loop5(boolean) liveness (after)
- // CHECK: ParameterValue liveness:2 ranges:[ 2-50 ] uses:[ 33 42 46 50 ]
+ // CHECK: ParameterValue liveness:2 ranges:[2-50] uses:[33,42,46,50]
// CHECK: Goto liveness:44
// CHECK: Goto liveness:48
public static void loop5(boolean incoming) {
@@ -76,7 +76,7 @@
}
// CHECK-START: void Main.loop6(boolean) liveness (after)
- // CHECK ParameterValue liveness:2 ranges:[ 2-46 ] uses:[ 24 46 ]
+ // CHECK ParameterValue liveness:2 ranges:[2-46] uses:[24,46]
// CHECK: Goto liveness:44
// CHECK-START: void Main.loop6(boolean) liveness (after)
@@ -90,7 +90,7 @@
}
// CHECK-START: void Main.loop7(boolean) liveness (after)
- // CHECK: ParameterValue liveness:2 ranges:[ 2-50 ] uses:[ 32 41 46 50 ]
+ // CHECK: ParameterValue liveness:2 ranges:[2-50] uses:[32,41,46,50]
// CHECK: Goto liveness:44
// CHECK: Goto liveness:48
public static void loop7(boolean incoming) {
@@ -102,7 +102,7 @@
}
// CHECK-START: void Main.loop8() liveness (after)
- // CHECK: StaticFieldGet liveness:12 ranges:[ 12-44 ] uses:[ 35 40 44 ]
+ // CHECK: StaticFieldGet liveness:12 ranges:[12-44] uses:[35,40,44]
// CHECK: Goto liveness:38
// CHECK: Goto liveness:42
public static void loop8() {
@@ -114,7 +114,7 @@
}
// CHECK-START: void Main.loop9() liveness (after)
- // CHECK: StaticFieldGet liveness:22 ranges:[ 22-36 ] uses:[ 31 36 ]
+ // CHECK: StaticFieldGet liveness:22 ranges:[22-36] uses:[31,36]
// CHECK: Goto liveness:38
public static void loop9() {
while (Runtime.getRuntime() != null) {
diff --git a/test/485-checker-dce-loop-update/smali/TestCase.smali b/test/485-checker-dce-loop-update/smali/TestCase.smali
index bdc4038..71da510 100644
--- a/test/485-checker-dce-loop-update/smali/TestCase.smali
+++ b/test/485-checker-dce-loop-update/smali/TestCase.smali
@@ -29,21 +29,21 @@
# 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-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-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
@@ -80,24 +80,24 @@
# 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-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-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
@@ -137,15 +137,15 @@
# 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-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
@@ -153,13 +153,13 @@
# 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-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
@@ -205,19 +205,19 @@
# 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>>
+# CHECK-DAG: <<PhiZ2:i\d+>> Phi [<<PhiZ1>>,<<XorZ>>] loop:<<HeaderZ:B\d+>>
+# CHECK-DAG: <<XorZ>> Xor [<<PhiZ2>>,<<Cst1>>] loop:<<HeaderZ>>
+# CHECK-DAG: <<CondZ:z\d+>> Equal [<<XorZ>>,<<Cst0>>] loop:<<HeaderZ>>
+# CHECK-DAG: If [<<CondZ>>] loop:<<HeaderZ>>
#
-# CHECK-DAG: <<Add5>> Add [ <<PhiX>> <<Cst5>> ] loop:<<HeaderY>>
-# CHECK-DAG: <<Add7>> Add [ <<PhiX>> <<Cst7>> ] loop:<<HeaderY>>
-# CHECK-DAG: Return [ <<PhiX>> ] loop:none
+# CHECK-DAG: <<Add5>> Add [<<PhiX>>,<<Cst5>>] loop:<<HeaderY>>
+# CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
+# CHECK-DAG: Return [<<PhiX>>] loop:none
# CHECK-START: int TestCase.testInnerLoop(int, boolean, boolean) dead_code_elimination_final (after)
# CHECK-DAG: <<ArgX:i\d+>> ParameterValue
@@ -227,18 +227,18 @@
# 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: <<PhiZ1:i\d+>> Phi [ <<ArgZ>> <<PhiZ1>> ] loop:<<HeaderY>>
-# 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: <<PhiZ1:i\d+>> Phi [<<ArgZ>>,<<PhiZ1>>] loop:<<HeaderY>>
+# CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
+# CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
#
# ### Inner loop ###
-# CHECK-DAG: <<PhiZ2:i\d+>> Phi [ <<PhiZ1>> <<XorZ:i\d+>> ] 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: <<PhiZ2:i\d+>> Phi [<<PhiZ1>>,<<XorZ:i\d+>>] 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: Return [ <<PhiX>> ] loop:none
+# CHECK-DAG: Return [<<PhiX>>] loop:none
.method public static testInnerLoop(IZZ)I
.registers 4