ART: Distinguish Checker lines from comments
In order to prevent tests passing due to lines with hard-to-spot
formatting errors begin ignored, e.g. by forgetting the colon after
"//CHECK", Checker will now require its assertions to start with "///"
or "##", respectivelly for Java and Smali. Such lines will never be
ignored and will fail the test unless successfully parsed.
Change-Id: I0da9a8f13eb96d950af8c85df17d1899a853a299
diff --git a/test/458-checker-instruction-simplification/src/Main.java b/test/458-checker-instruction-simplification/src/Main.java
index 742210c..ad5fc8e 100644
--- a/test/458-checker-instruction-simplification/src/Main.java
+++ b/test/458-checker-instruction-simplification/src/Main.java
@@ -50,296 +50,296 @@
* Tiny programs exercising optimizations of arithmetic identities.
*/
- // CHECK-START: long Main.Add0(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-DAG: <<Add:j\d+>> Add [<<Const0>>,<<Arg>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: long Main.Add0(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-DAG: <<Add:j\d+>> Add [<<Const0>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: long Main.Add0(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.Add0(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.Add0(long) instruction_simplifier (after)
- // CHECK-NOT: Add
+ /// CHECK-START: long Main.Add0(long) instruction_simplifier (after)
+ /// CHECK-NOT: Add
public static long Add0(long arg) {
return 0 + arg;
}
- // CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
- // CHECK-DAG: <<And:i\d+>> And [<<Arg>>,<<ConstF>>]
- // CHECK-DAG: Return [<<And>>]
+ /// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
+ /// CHECK-DAG: <<And:i\d+>> And [<<Arg>>,<<ConstF>>]
+ /// CHECK-DAG: Return [<<And>>]
- // CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after)
- // CHECK-NOT: And
+ /// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after)
+ /// CHECK-NOT: And
public static int AndAllOnes(int arg) {
return arg & -1;
}
- // CHECK-START: long Main.Div1(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const1:j\d+>> LongConstant 1
- // CHECK-DAG: <<Div:j\d+>> Div [<<Arg>>,<<Const1>>]
- // CHECK-DAG: Return [<<Div>>]
+ /// CHECK-START: long Main.Div1(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:j\d+>> LongConstant 1
+ /// CHECK-DAG: <<Div:j\d+>> Div [<<Arg>>,<<Const1>>]
+ /// CHECK-DAG: Return [<<Div>>]
- // CHECK-START: long Main.Div1(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.Div1(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.Div1(long) instruction_simplifier (after)
- // CHECK-NOT: Div
+ /// CHECK-START: long Main.Div1(long) instruction_simplifier (after)
+ /// CHECK-NOT: Div
public static long Div1(long arg) {
return arg / 1;
}
- // CHECK-START: int Main.DivN1(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<ConstN1:i\d+>> IntConstant -1
- // CHECK-DAG: <<Div:i\d+>> Div [<<Arg>>,<<ConstN1>>]
- // CHECK-DAG: Return [<<Div>>]
+ /// CHECK-START: int Main.DivN1(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstN1:i\d+>> IntConstant -1
+ /// CHECK-DAG: <<Div:i\d+>> Div [<<Arg>>,<<ConstN1>>]
+ /// CHECK-DAG: Return [<<Div>>]
- // CHECK-START: int Main.DivN1(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.DivN1(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
+ /// CHECK-DAG: Return [<<Neg>>]
- // CHECK-START: int Main.DivN1(int) instruction_simplifier (after)
- // CHECK-NOT: Div
+ /// CHECK-START: int Main.DivN1(int) instruction_simplifier (after)
+ /// CHECK-NOT: Div
public static int DivN1(int arg) {
return arg / -1;
}
- // CHECK-START: long Main.Mul1(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const1:j\d+>> LongConstant 1
- // CHECK-DAG: <<Mul:j\d+>> Mul [<<Arg>>,<<Const1>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: long Main.Mul1(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:j\d+>> LongConstant 1
+ /// CHECK-DAG: <<Mul:j\d+>> Mul [<<Arg>>,<<Const1>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: long Main.Mul1(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.Mul1(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.Mul1(long) instruction_simplifier (after)
- // CHECK-NOT: Mul
+ /// CHECK-START: long Main.Mul1(long) instruction_simplifier (after)
+ /// CHECK-NOT: Mul
public static long Mul1(long arg) {
return arg * 1;
}
- // CHECK-START: int Main.MulN1(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<ConstN1:i\d+>> IntConstant -1
- // CHECK-DAG: <<Mul:i\d+>> Mul [<<Arg>>,<<ConstN1>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: int Main.MulN1(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstN1:i\d+>> IntConstant -1
+ /// CHECK-DAG: <<Mul:i\d+>> Mul [<<Arg>>,<<ConstN1>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: int Main.MulN1(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.MulN1(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
+ /// CHECK-DAG: Return [<<Neg>>]
- // CHECK-START: int Main.MulN1(int) instruction_simplifier (after)
- // CHECK-NOT: Mul
+ /// CHECK-START: int Main.MulN1(int) instruction_simplifier (after)
+ /// CHECK-NOT: Mul
public static int MulN1(int arg) {
return arg * -1;
}
- // CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const128:j\d+>> LongConstant 128
- // CHECK-DAG: <<Mul:j\d+>> Mul [<<Arg>>,<<Const128>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const128:j\d+>> LongConstant 128
+ /// CHECK-DAG: <<Mul:j\d+>> Mul [<<Arg>>,<<Const128>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const7:i\d+>> IntConstant 7
- // CHECK-DAG: <<Shl:j\d+>> Shl [<<Arg>>,<<Const7>>]
- // CHECK-DAG: Return [<<Shl>>]
+ /// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const7:i\d+>> IntConstant 7
+ /// CHECK-DAG: <<Shl:j\d+>> Shl [<<Arg>>,<<Const7>>]
+ /// CHECK-DAG: Return [<<Shl>>]
- // CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after)
- // CHECK-NOT: Mul
+ /// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after)
+ /// CHECK-NOT: Mul
public static long MulPowerOfTwo128(long arg) {
return arg * 128;
}
- // CHECK-START: int Main.Or0(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Or:i\d+>> Or [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.Or0(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.Or0(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: int Main.Or0(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: int Main.Or0(int) instruction_simplifier (after)
- // CHECK-NOT: Or
+ /// CHECK-START: int Main.Or0(int) instruction_simplifier (after)
+ /// CHECK-NOT: Or
public static int Or0(int arg) {
return arg | 0;
}
- // CHECK-START: long Main.OrSame(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Or:j\d+>> Or [<<Arg>>,<<Arg>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: long Main.OrSame(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Or:j\d+>> Or [<<Arg>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: long Main.OrSame(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.OrSame(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.OrSame(long) instruction_simplifier (after)
- // CHECK-NOT: Or
+ /// CHECK-START: long Main.OrSame(long) instruction_simplifier (after)
+ /// CHECK-NOT: Or
public static long OrSame(long arg) {
return arg | arg;
}
- // CHECK-START: int Main.Shl0(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Shl:i\d+>> Shl [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<Shl>>]
+ /// CHECK-START: int Main.Shl0(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Shl:i\d+>> Shl [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Shl>>]
- // CHECK-START: int Main.Shl0(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: int Main.Shl0(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: int Main.Shl0(int) instruction_simplifier (after)
- // CHECK-NOT: Shl
+ /// CHECK-START: int Main.Shl0(int) instruction_simplifier (after)
+ /// CHECK-NOT: Shl
public static int Shl0(int arg) {
return arg << 0;
}
- // CHECK-START: int Main.Shl1(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Shl:i\d+>> Shl [<<Arg>>,<<Const1>>]
- // CHECK-DAG: Return [<<Shl>>]
+ /// CHECK-START: int Main.Shl1(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Shl:i\d+>> Shl [<<Arg>>,<<Const1>>]
+ /// CHECK-DAG: Return [<<Shl>>]
- // CHECK-START: int Main.Shl1(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Add:i\d+>> Add [<<Arg>>,<<Arg>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.Shl1(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Arg>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: int Main.Shl1(int) instruction_simplifier (after)
- // CHECK-NOT: Shl
+ /// CHECK-START: int Main.Shl1(int) instruction_simplifier (after)
+ /// CHECK-NOT: Shl
public static int Shl1(int arg) {
return arg << 1;
}
- // CHECK-START: long Main.Shr0(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Shr:j\d+>> Shr [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<Shr>>]
+ /// CHECK-START: long Main.Shr0(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Shr:j\d+>> Shr [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Shr>>]
- // CHECK-START: long Main.Shr0(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.Shr0(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.Shr0(long) instruction_simplifier (after)
- // CHECK-NOT: Shr
+ /// CHECK-START: long Main.Shr0(long) instruction_simplifier (after)
+ /// CHECK-NOT: Shr
public static long Shr0(long arg) {
return arg >> 0;
}
- // CHECK-START: long Main.Sub0(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: long Main.Sub0(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: long Main.Sub0(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.Sub0(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.Sub0(long) instruction_simplifier (after)
- // CHECK-NOT: Sub
+ /// CHECK-START: long Main.Sub0(long) instruction_simplifier (after)
+ /// CHECK-NOT: Sub
public static long Sub0(long arg) {
return arg - 0;
}
- // CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Const0>>,<<Arg>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const0>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
+ /// CHECK-DAG: Return [<<Neg>>]
- // CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after)
- // CHECK-NOT: Sub
+ /// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after)
+ /// CHECK-NOT: Sub
public static int SubAliasNeg(int arg) {
return 0 - arg;
}
- // CHECK-START: long Main.UShr0(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<UShr:j\d+>> UShr [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<UShr>>]
+ /// CHECK-START: long Main.UShr0(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<UShr:j\d+>> UShr [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<UShr>>]
- // CHECK-START: long Main.UShr0(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.UShr0(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.UShr0(long) instruction_simplifier (after)
- // CHECK-NOT: UShr
+ /// CHECK-START: long Main.UShr0(long) instruction_simplifier (after)
+ /// CHECK-NOT: UShr
public static long UShr0(long arg) {
return arg >>> 0;
}
- // CHECK-START: int Main.Xor0(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<Xor>>]
+ /// CHECK-START: int Main.Xor0(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Xor>>]
- // CHECK-START: int Main.Xor0(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: int Main.Xor0(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: int Main.Xor0(int) instruction_simplifier (after)
- // CHECK-NOT: Xor
+ /// CHECK-START: int Main.Xor0(int) instruction_simplifier (after)
+ /// CHECK-NOT: Xor
public static int Xor0(int arg) {
return arg ^ 0;
}
- // CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
- // CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<ConstF>>]
- // CHECK-DAG: Return [<<Xor>>]
+ /// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
+ /// CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<ConstF>>]
+ /// CHECK-DAG: Return [<<Xor>>]
- // CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Not:i\d+>> Not [<<Arg>>]
- // CHECK-DAG: Return [<<Not>>]
+ /// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Not:i\d+>> Not [<<Arg>>]
+ /// CHECK-DAG: Return [<<Not>>]
- // CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after)
- // CHECK-NOT: Xor
+ /// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after)
+ /// CHECK-NOT: Xor
public static int XorAllOnes(int arg) {
return arg ^ -1;
@@ -352,21 +352,21 @@
* `InstructionSimplifierVisitor::TryMoveNegOnInputsAfterBinop`.
*/
- // CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
- // CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-NOT: Neg
- // CHECK-DAG: <<Add:i\d+>> Add [<<Arg1>>,<<Arg2>>]
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Add>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-NOT: Neg
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Arg1>>,<<Arg2>>]
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Add>>]
+ /// CHECK-DAG: Return [<<Neg>>]
public static int AddNegs1(int arg1, int arg2) {
return -arg1 + -arg2;
@@ -383,35 +383,35 @@
* increasing the register pressure by creating or extending live ranges.
*/
- // CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
- // CHECK-DAG: <<Add1:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: <<Add2:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: <<Or:i\d+>> Or [<<Add1>>,<<Add2>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
+ /// CHECK-DAG: <<Add1:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: <<Add2:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Add1>>,<<Add2>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
- // CHECK-DAG: <<Add1:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: <<Add2:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-NOT: Neg
- // CHECK-DAG: <<Or:i\d+>> Or [<<Add1>>,<<Add2>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
+ /// CHECK-DAG: <<Add1:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: <<Add2:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-NOT: Neg
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Add1>>,<<Add2>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.AddNegs2(int, int) GVN (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
- // CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: <<Or:i\d+>> Or [<<Add>>,<<Add>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.AddNegs2(int, int) GVN (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Add>>,<<Add>>]
+ /// CHECK-DAG: Return [<<Or>>]
public static int AddNegs2(int arg1, int arg2) {
int temp1 = -arg1;
@@ -427,30 +427,30 @@
* the loop.
*/
- // CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (before)
- // -------------- Arguments and initial negation operations.
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Neg2:j\d+>> Neg [<<Arg2>>]
- // CHECK: Goto
- // -------------- Loop
- // CHECK: SuspendCheck
- // CHECK: <<Add:j\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK: Goto
+ /// CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (before)
+ // -------------- Arguments and initial negation operations.
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Neg2:j\d+>> Neg [<<Arg2>>]
+ /// CHECK: Goto
+ // -------------- Loop
+ /// CHECK: SuspendCheck
+ /// CHECK: <<Add:j\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK: Goto
- // CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (after)
- // -------------- Arguments and initial negation operations.
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Neg2:j\d+>> Neg [<<Arg2>>]
- // CHECK: Goto
- // -------------- Loop
- // CHECK: SuspendCheck
- // CHECK: <<Add:j\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-NOT: Neg
- // CHECK: Goto
+ /// CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (after)
+ // -------------- Arguments and initial negation operations.
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Neg2:j\d+>> Neg [<<Arg2>>]
+ /// CHECK: Goto
+ // -------------- Loop
+ /// CHECK: SuspendCheck
+ /// CHECK: <<Add:j\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-NOT: Neg
+ /// CHECK: Goto
public static long AddNegs3(long arg1, long arg2) {
long res = 0;
@@ -468,22 +468,22 @@
* The transformation tested is implemented in `InstructionSimplifierVisitor::VisitAdd`.
*/
- // CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Add:j\d+>> Add [<<Neg>>,<<Arg2>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Add:j\d+>> Add [<<Neg>>,<<Arg2>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg2>>,<<Arg1>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg2>>,<<Arg1>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after)
- // CHECK-NOT: Neg
- // CHECK-NOT: Add
+ /// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after)
+ /// CHECK-NOT: Neg
+ /// CHECK-NOT: Add
public static long AddNeg1(long arg1, long arg2) {
return -arg1 + arg2;
@@ -498,26 +498,26 @@
* increasing the register pressure by creating or extending live ranges.
*/
- // CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg2>>]
- // CHECK-DAG: <<Add1:j\d+>> Add [<<Arg1>>,<<Neg>>]
- // CHECK-DAG: <<Add2:j\d+>> Add [<<Arg1>>,<<Neg>>]
- // CHECK-DAG: <<Res:j\d+>> Or [<<Add1>>,<<Add2>>]
- // CHECK-DAG: Return [<<Res>>]
+ /// CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg2>>]
+ /// CHECK-DAG: <<Add1:j\d+>> Add [<<Arg1>>,<<Neg>>]
+ /// CHECK-DAG: <<Add2:j\d+>> Add [<<Arg1>>,<<Neg>>]
+ /// CHECK-DAG: <<Res:j\d+>> Or [<<Add1>>,<<Add2>>]
+ /// CHECK-DAG: Return [<<Res>>]
- // CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg2>>]
- // CHECK-DAG: <<Add1:j\d+>> Add [<<Arg1>>,<<Neg>>]
- // CHECK-DAG: <<Add2:j\d+>> Add [<<Arg1>>,<<Neg>>]
- // CHECK-DAG: <<Res:j\d+>> Or [<<Add1>>,<<Add2>>]
- // CHECK-DAG: Return [<<Res>>]
+ /// CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg2>>]
+ /// CHECK-DAG: <<Add1:j\d+>> Add [<<Arg1>>,<<Neg>>]
+ /// CHECK-DAG: <<Add2:j\d+>> Add [<<Arg1>>,<<Neg>>]
+ /// CHECK-DAG: <<Res:j\d+>> Or [<<Add1>>,<<Add2>>]
+ /// CHECK-DAG: Return [<<Res>>]
- // CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after)
- // CHECK-NOT: Sub
+ /// CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after)
+ /// CHECK-NOT: Sub
public static long AddNeg2(long arg1, long arg2) {
long temp = -arg2;
@@ -529,18 +529,18 @@
* The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNeg`.
*/
- // CHECK-START: long Main.NegNeg1(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg>>]
- // CHECK-DAG: <<Neg2:j\d+>> Neg [<<Neg1>>]
- // CHECK-DAG: Return [<<Neg2>>]
+ /// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg>>]
+ /// CHECK-DAG: <<Neg2:j\d+>> Neg [<<Neg1>>]
+ /// CHECK-DAG: Return [<<Neg2>>]
- // CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after)
- // CHECK-NOT: Neg
+ /// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after)
+ /// CHECK-NOT: Neg
public static long NegNeg1(long arg) {
return -(-arg);
@@ -553,27 +553,27 @@
* and in `InstructionSimplifierVisitor::VisitAdd`.
*/
- // CHECK-START: int Main.NegNeg2(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Neg1>>]
- // CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Neg1>>]
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg>>,<<Arg>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after)
- // CHECK-NOT: Neg
- // CHECK-NOT: Add
+ /// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after)
+ /// CHECK-NOT: Neg
+ /// CHECK-NOT: Add
- // CHECK-START: int Main.NegNeg2(int) constant_folding_after_inlining (after)
- // CHECK: <<Const0:i\d+>> IntConstant 0
- // CHECK-NOT: Neg
- // CHECK-NOT: Add
- // CHECK: Return [<<Const0>>]
+ /// CHECK-START: int Main.NegNeg2(int) constant_folding_after_inlining (after)
+ /// CHECK: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-NOT: Neg
+ /// CHECK-NOT: Add
+ /// CHECK: Return [<<Const0>>]
public static int NegNeg2(int arg) {
int temp = -arg;
@@ -587,20 +587,20 @@
* and in `InstructionSimplifierVisitor::VisitSub`.
*/
- // CHECK-START: long Main.NegNeg3(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg>>]
- // CHECK-DAG: <<Sub:j\d+>> Sub [<<Const0>>,<<Neg>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg>>]
+ /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Const0>>,<<Neg>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after)
- // CHECK-NOT: Neg
- // CHECK-NOT: Sub
+ /// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after)
+ /// CHECK-NOT: Neg
+ /// CHECK-NOT: Sub
public static long NegNeg3(long arg) {
return 0 - -arg;
@@ -612,21 +612,21 @@
* The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNeg`.
*/
- // CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>]
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Sub>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>]
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Sub>>]
+ /// CHECK-DAG: Return [<<Neg>>]
- // CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg2>>,<<Arg1>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg2>>,<<Arg1>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after)
- // CHECK-NOT: Neg
+ /// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after)
+ /// CHECK-NOT: Neg
public static int NegSub1(int arg1, int arg2) {
return -(arg1 - arg2);
@@ -642,23 +642,23 @@
* increasing the register pressure by creating or extending live ranges.
*/
- // CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>]
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Sub>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Sub>>]
- // CHECK-DAG: <<Or:i\d+>> Or [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>]
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Sub>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Sub>>]
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>]
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Sub>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Sub>>]
- // CHECK-DAG: <<Or:i\d+>> Or [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>]
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Sub>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Sub>>]
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: Return [<<Or>>]
public static int NegSub2(int arg1, int arg2) {
int temp = arg1 - arg2;
@@ -670,40 +670,40 @@
* The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNot`.
*/
- // CHECK-START: long Main.NotNot1(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<ConstF1:j\d+>> LongConstant -1
- // CHECK-DAG: <<Xor1:j\d+>> Xor [<<Arg>>,<<ConstF1>>]
- // CHECK-DAG: <<Xor2:j\d+>> Xor [<<Xor1>>,<<ConstF1>>]
- // CHECK-DAG: Return [<<Xor2>>]
+ /// CHECK-START: long Main.NotNot1(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstF1:j\d+>> LongConstant -1
+ /// CHECK-DAG: <<Xor1:j\d+>> Xor [<<Arg>>,<<ConstF1>>]
+ /// CHECK-DAG: <<Xor2:j\d+>> Xor [<<Xor1>>,<<ConstF1>>]
+ /// CHECK-DAG: Return [<<Xor2>>]
- // CHECK-START: long Main.NotNot1(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.NotNot1(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.NotNot1(long) instruction_simplifier (after)
- // CHECK-NOT: Xor
+ /// CHECK-START: long Main.NotNot1(long) instruction_simplifier (after)
+ /// CHECK-NOT: Xor
public static long NotNot1(long arg) {
return ~~arg;
}
- // CHECK-START: int Main.NotNot2(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<ConstF1:i\d+>> IntConstant -1
- // CHECK-DAG: <<Xor1:i\d+>> Xor [<<Arg>>,<<ConstF1>>]
- // CHECK-DAG: <<Xor2:i\d+>> Xor [<<Xor1>>,<<ConstF1>>]
- // CHECK-DAG: <<Add:i\d+>> Add [<<Xor1>>,<<Xor2>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.NotNot2(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstF1:i\d+>> IntConstant -1
+ /// CHECK-DAG: <<Xor1:i\d+>> Xor [<<Arg>>,<<ConstF1>>]
+ /// CHECK-DAG: <<Xor2:i\d+>> Xor [<<Xor1>>,<<ConstF1>>]
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Xor1>>,<<Xor2>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: int Main.NotNot2(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Not:i\d+>> Not [<<Arg>>]
- // CHECK-DAG: <<Add:i\d+>> Add [<<Not>>,<<Arg>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.NotNot2(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Not:i\d+>> Not [<<Arg>>]
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Not>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: int Main.NotNot2(int) instruction_simplifier (after)
- // CHECK-NOT: Xor
+ /// CHECK-START: int Main.NotNot2(int) instruction_simplifier (after)
+ /// CHECK-NOT: Xor
public static int NotNot2(int arg) {
int temp = ~arg;
@@ -715,22 +715,22 @@
* The transformation tested is implemented in `InstructionSimplifierVisitor::VisitSub`.
*/
- // CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Add:i\d+>> Add [<<Arg1>>,<<Arg2>>]
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Add>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Arg1>>,<<Arg2>>]
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Add>>]
+ /// CHECK-DAG: Return [<<Neg>>]
- // CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after)
- // CHECK-NOT: Sub
+ /// CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after)
+ /// CHECK-NOT: Sub
public static int SubNeg1(int arg1, int arg2) {
return -arg1 - arg2;
@@ -746,26 +746,26 @@
* increasing the register pressure by creating or extending live ranges.
*/
- // CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Sub1:i\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK-DAG: <<Sub2:i\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK-DAG: <<Or:i\d+>> Or [<<Sub1>>,<<Sub2>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Sub1:i\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK-DAG: <<Sub2:i\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Sub1>>,<<Sub2>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Sub1:i\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK-DAG: <<Sub2:i\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK-DAG: <<Or:i\d+>> Or [<<Sub1>>,<<Sub2>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Sub1:i\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK-DAG: <<Sub2:i\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Sub1>>,<<Sub2>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after)
- // CHECK-NOT: Add
+ /// CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after)
+ /// CHECK-NOT: Add
public static int SubNeg2(int arg1, int arg2) {
int temp = -arg1;
@@ -779,28 +779,28 @@
* the loop.
*/
- // CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (before)
- // -------------- Arguments and initial negation operation.
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>]
- // CHECK: Goto
- // -------------- Loop
- // CHECK: SuspendCheck
- // CHECK: <<Sub:j\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK: Goto
+ /// CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (before)
+ // -------------- Arguments and initial negation operation.
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>]
+ /// CHECK: Goto
+ // -------------- Loop
+ /// CHECK: SuspendCheck
+ /// CHECK: <<Sub:j\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK: Goto
- // CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (after)
- // -------------- Arguments and initial negation operation.
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: Goto
- // -------------- Loop
- // CHECK: SuspendCheck
- // CHECK: <<Sub:j\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK-NOT: Neg
- // CHECK: Goto
+ /// CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (after)
+ // -------------- Arguments and initial negation operation.
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: Goto
+ // -------------- Loop
+ /// CHECK: SuspendCheck
+ /// CHECK: <<Sub:j\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK-NOT: Neg
+ /// CHECK: Goto
public static long SubNeg3(long arg1, long arg2) {
long res = 0;
@@ -811,117 +811,117 @@
return res;
}
- // CHECK-START: int Main.EqualTrueRhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> Equal [<<Arg>>,<<Const1>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.EqualTrueRhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> Equal [<<Arg>>,<<Const1>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.EqualTrueRhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: If [<<Arg>>]
+ /// CHECK-START: int Main.EqualTrueRhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: If [<<Arg>>]
public static int EqualTrueRhs(boolean arg) {
return (arg != true) ? 3 : 5;
}
- // CHECK-START: int Main.EqualTrueLhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> Equal [<<Const1>>,<<Arg>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.EqualTrueLhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> Equal [<<Const1>>,<<Arg>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.EqualTrueLhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: If [<<Arg>>]
+ /// CHECK-START: int Main.EqualTrueLhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: If [<<Arg>>]
public static int EqualTrueLhs(boolean arg) {
return (true != arg) ? 3 : 5;
}
- // CHECK-START: int Main.EqualFalseRhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Cond:z\d+>> Equal [<<Arg>>,<<Const0>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.EqualFalseRhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Cond:z\d+>> Equal [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.EqualFalseRhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
- // CHECK-DAG: If [<<NotArg>>]
+ /// CHECK-START: int Main.EqualFalseRhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ /// CHECK-DAG: If [<<NotArg>>]
public static int EqualFalseRhs(boolean arg) {
return (arg != false) ? 3 : 5;
}
- // CHECK-START: int Main.EqualFalseLhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Cond:z\d+>> Equal [<<Const0>>,<<Arg>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.EqualFalseLhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Cond:z\d+>> Equal [<<Const0>>,<<Arg>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.EqualFalseLhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
- // CHECK-DAG: If [<<NotArg>>]
+ /// CHECK-START: int Main.EqualFalseLhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ /// CHECK-DAG: If [<<NotArg>>]
public static int EqualFalseLhs(boolean arg) {
return (false != arg) ? 3 : 5;
}
- // CHECK-START: int Main.NotEqualTrueRhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Arg>>,<<Const1>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.NotEqualTrueRhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Arg>>,<<Const1>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.NotEqualTrueRhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
- // CHECK-DAG: If [<<NotArg>>]
+ /// CHECK-START: int Main.NotEqualTrueRhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ /// CHECK-DAG: If [<<NotArg>>]
public static int NotEqualTrueRhs(boolean arg) {
return (arg == true) ? 3 : 5;
}
- // CHECK-START: int Main.NotEqualTrueLhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Const1>>,<<Arg>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.NotEqualTrueLhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Const1>>,<<Arg>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.NotEqualTrueLhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
- // CHECK-DAG: If [<<NotArg>>]
+ /// CHECK-START: int Main.NotEqualTrueLhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ /// CHECK-DAG: If [<<NotArg>>]
public static int NotEqualTrueLhs(boolean arg) {
return (true == arg) ? 3 : 5;
}
- // CHECK-START: int Main.NotEqualFalseRhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Arg>>,<<Const0>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.NotEqualFalseRhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.NotEqualFalseRhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: If [<<Arg>>]
+ /// CHECK-START: int Main.NotEqualFalseRhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: If [<<Arg>>]
public static int NotEqualFalseRhs(boolean arg) {
return (arg == false) ? 3 : 5;
}
- // CHECK-START: int Main.NotEqualFalseLhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Const0>>,<<Arg>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.NotEqualFalseLhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Const0>>,<<Arg>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.NotEqualFalseLhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: If [<<Arg>>]
+ /// CHECK-START: int Main.NotEqualFalseLhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: If [<<Arg>>]
public static int NotEqualFalseLhs(boolean arg) {
return (false == arg) ? 3 : 5;
@@ -933,20 +933,20 @@
* remove the second.
*/
- // CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
- // CHECK-DAG: <<NotNotArg:z\d+>> BooleanNot [<<NotArg>>]
- // CHECK-DAG: Return [<<NotNotArg>>]
+ /// CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ /// CHECK-DAG: <<NotNotArg:z\d+>> BooleanNot [<<NotArg>>]
+ /// CHECK-DAG: Return [<<NotNotArg>>]
- // CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: BooleanNot [<<Arg>>]
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: BooleanNot [<<Arg>>]
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (after)
- // CHECK: BooleanNot
- // CHECK-NOT: BooleanNot
+ /// CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (after)
+ /// CHECK: BooleanNot
+ /// CHECK-NOT: BooleanNot
public static boolean NegateValue(boolean arg) {
return !arg;
@@ -956,76 +956,76 @@
return !(NegateValue(arg));
}
- // CHECK-START: float Main.Div2(float) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:f\d+>> ParameterValue
- // CHECK-DAG: <<Const2:f\d+>> FloatConstant 2
- // CHECK-DAG: <<Div:f\d+>> Div [<<Arg>>,<<Const2>>]
- // CHECK-DAG: Return [<<Div>>]
+ /// CHECK-START: float Main.Div2(float) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:f\d+>> ParameterValue
+ /// CHECK-DAG: <<Const2:f\d+>> FloatConstant 2
+ /// CHECK-DAG: <<Div:f\d+>> Div [<<Arg>>,<<Const2>>]
+ /// CHECK-DAG: Return [<<Div>>]
- // CHECK-START: float Main.Div2(float) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:f\d+>> ParameterValue
- // CHECK-DAG: <<ConstP5:f\d+>> FloatConstant 0.5
- // CHECK-DAG: <<Mul:f\d+>> Mul [<<Arg>>,<<ConstP5>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: float Main.Div2(float) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:f\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstP5:f\d+>> FloatConstant 0.5
+ /// CHECK-DAG: <<Mul:f\d+>> Mul [<<Arg>>,<<ConstP5>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: float Main.Div2(float) instruction_simplifier (after)
- // CHECK-NOT: Div
+ /// CHECK-START: float Main.Div2(float) instruction_simplifier (after)
+ /// CHECK-NOT: Div
public static float Div2(float arg) {
return arg / 2.0f;
}
- // CHECK-START: double Main.Div2(double) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:d\d+>> ParameterValue
- // CHECK-DAG: <<Const2:d\d+>> DoubleConstant 2
- // CHECK-DAG: <<Div:d\d+>> Div [<<Arg>>,<<Const2>>]
- // CHECK-DAG: Return [<<Div>>]
+ /// CHECK-START: double Main.Div2(double) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:d\d+>> ParameterValue
+ /// CHECK-DAG: <<Const2:d\d+>> DoubleConstant 2
+ /// CHECK-DAG: <<Div:d\d+>> Div [<<Arg>>,<<Const2>>]
+ /// CHECK-DAG: Return [<<Div>>]
- // CHECK-START: double Main.Div2(double) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:d\d+>> ParameterValue
- // CHECK-DAG: <<ConstP5:d\d+>> DoubleConstant 0.5
- // CHECK-DAG: <<Mul:d\d+>> Mul [<<Arg>>,<<ConstP5>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: double Main.Div2(double) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:d\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstP5:d\d+>> DoubleConstant 0.5
+ /// CHECK-DAG: <<Mul:d\d+>> Mul [<<Arg>>,<<ConstP5>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: double Main.Div2(double) instruction_simplifier (after)
- // CHECK-NOT: Div
+ /// CHECK-START: double Main.Div2(double) instruction_simplifier (after)
+ /// CHECK-NOT: Div
public static double Div2(double arg) {
return arg / 2.0;
}
- // CHECK-START: float Main.DivMP25(float) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:f\d+>> ParameterValue
- // CHECK-DAG: <<ConstMP25:f\d+>> FloatConstant -0.25
- // CHECK-DAG: <<Div:f\d+>> Div [<<Arg>>,<<ConstMP25>>]
- // CHECK-DAG: Return [<<Div>>]
+ /// CHECK-START: float Main.DivMP25(float) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:f\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstMP25:f\d+>> FloatConstant -0.25
+ /// CHECK-DAG: <<Div:f\d+>> Div [<<Arg>>,<<ConstMP25>>]
+ /// CHECK-DAG: Return [<<Div>>]
- // CHECK-START: float Main.DivMP25(float) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:f\d+>> ParameterValue
- // CHECK-DAG: <<ConstM4:f\d+>> FloatConstant -4
- // CHECK-DAG: <<Mul:f\d+>> Mul [<<Arg>>,<<ConstM4>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: float Main.DivMP25(float) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:f\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstM4:f\d+>> FloatConstant -4
+ /// CHECK-DAG: <<Mul:f\d+>> Mul [<<Arg>>,<<ConstM4>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: float Main.DivMP25(float) instruction_simplifier (after)
- // CHECK-NOT: Div
+ /// CHECK-START: float Main.DivMP25(float) instruction_simplifier (after)
+ /// CHECK-NOT: Div
public static float DivMP25(float arg) {
return arg / -0.25f;
}
- // CHECK-START: double Main.DivMP25(double) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:d\d+>> ParameterValue
- // CHECK-DAG: <<ConstMP25:d\d+>> DoubleConstant -0.25
- // CHECK-DAG: <<Div:d\d+>> Div [<<Arg>>,<<ConstMP25>>]
- // CHECK-DAG: Return [<<Div>>]
+ /// CHECK-START: double Main.DivMP25(double) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:d\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstMP25:d\d+>> DoubleConstant -0.25
+ /// CHECK-DAG: <<Div:d\d+>> Div [<<Arg>>,<<ConstMP25>>]
+ /// CHECK-DAG: Return [<<Div>>]
- // CHECK-START: double Main.DivMP25(double) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:d\d+>> ParameterValue
- // CHECK-DAG: <<ConstM4:d\d+>> DoubleConstant -4
- // CHECK-DAG: <<Mul:d\d+>> Mul [<<Arg>>,<<ConstM4>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: double Main.DivMP25(double) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:d\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstM4:d\d+>> DoubleConstant -4
+ /// CHECK-DAG: <<Mul:d\d+>> Mul [<<Arg>>,<<ConstM4>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: double Main.DivMP25(double) instruction_simplifier (after)
- // CHECK-NOT: Div
+ /// CHECK-START: double Main.DivMP25(double) instruction_simplifier (after)
+ /// CHECK-NOT: Div
public static double DivMP25(double arg) {
return arg / -0.25f;
}