Implement running user defined list of passes
This change introduces new dex2oat switch --run-passes=. This switch
accepts path to a text file with names of passes to run.
Compiler will run optimization passes specified in the file rather
then the default ones.
There is no verification implemented on the compiler side. It is user's
responsibility to provide a list of passes that leads to successful
generation of correct code. Care should be taken to prepare a list
that satisfies all dependencies between optimizations.
We only take control of the optional optimizations. Codegen (builder),
and all passes required for register allocation will run unaffected
by this mechanism.
Change-Id: Ic3694e53515fefcc5ce6f28d9371776b5afcbb4f
diff --git a/test/442-checker-constant-folding/src/Main.java b/test/442-checker-constant-folding/src/Main.java
index b7712a7..33ef10b 100644
--- a/test/442-checker-constant-folding/src/Main.java
+++ b/test/442-checker-constant-folding/src/Main.java
@@ -213,17 +213,17 @@
* Exercise constant folding on addition.
*/
- /// CHECK-START: int Main.IntAddition1() constant_folding_after_inlining (before)
+ /// CHECK-START: int Main.IntAddition1() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: <<Add:i\d+>> Add [<<Const1>>,<<Const2>>]
/// CHECK-DAG: Return [<<Add>>]
- /// CHECK-START: int Main.IntAddition1() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.IntAddition1() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
/// CHECK-DAG: Return [<<Const3>>]
- /// CHECK-START: int Main.IntAddition1() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.IntAddition1() constant_folding$after_inlining (after)
/// CHECK-NOT: Add
public static int IntAddition1() {
@@ -234,7 +234,7 @@
return c;
}
- /// CHECK-START: int Main.IntAddition2() constant_folding_after_inlining (before)
+ /// CHECK-START: int Main.IntAddition2() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: <<Const5:i\d+>> IntConstant 5
@@ -244,11 +244,11 @@
/// CHECK-DAG: <<Add3:i\d+>> Add [<<Add1>>,<<Add2>>]
/// CHECK-DAG: Return [<<Add3>>]
- /// CHECK-START: int Main.IntAddition2() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.IntAddition2() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const14:i\d+>> IntConstant 14
/// CHECK-DAG: Return [<<Const14>>]
- /// CHECK-START: int Main.IntAddition2() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.IntAddition2() constant_folding$after_inlining (after)
/// CHECK-NOT: Add
public static int IntAddition2() {
@@ -263,17 +263,17 @@
return c;
}
- /// CHECK-START: long Main.LongAddition() constant_folding_after_inlining (before)
+ /// CHECK-START: long Main.LongAddition() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const1:j\d+>> LongConstant 1
/// CHECK-DAG: <<Const2:j\d+>> LongConstant 2
/// CHECK-DAG: <<Add:j\d+>> Add [<<Const1>>,<<Const2>>]
/// CHECK-DAG: Return [<<Add>>]
- /// CHECK-START: long Main.LongAddition() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.LongAddition() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const3:j\d+>> LongConstant 3
/// CHECK-DAG: Return [<<Const3>>]
- /// CHECK-START: long Main.LongAddition() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.LongAddition() constant_folding$after_inlining (after)
/// CHECK-NOT: Add
public static long LongAddition() {
@@ -284,17 +284,17 @@
return c;
}
- /// CHECK-START: float Main.FloatAddition() constant_folding_after_inlining (before)
+ /// CHECK-START: float Main.FloatAddition() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const1:f\d+>> FloatConstant 1
/// CHECK-DAG: <<Const2:f\d+>> FloatConstant 2
/// CHECK-DAG: <<Add:f\d+>> Add [<<Const1>>,<<Const2>>]
/// CHECK-DAG: Return [<<Add>>]
- /// CHECK-START: float Main.FloatAddition() constant_folding_after_inlining (after)
+ /// CHECK-START: float Main.FloatAddition() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const3:f\d+>> FloatConstant 3
/// CHECK-DAG: Return [<<Const3>>]
- /// CHECK-START: float Main.FloatAddition() constant_folding_after_inlining (after)
+ /// CHECK-START: float Main.FloatAddition() constant_folding$after_inlining (after)
/// CHECK-NOT: Add
public static float FloatAddition() {
@@ -305,17 +305,17 @@
return c;
}
- /// CHECK-START: double Main.DoubleAddition() constant_folding_after_inlining (before)
+ /// CHECK-START: double Main.DoubleAddition() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const1:d\d+>> DoubleConstant 1
/// CHECK-DAG: <<Const2:d\d+>> DoubleConstant 2
/// CHECK-DAG: <<Add:d\d+>> Add [<<Const1>>,<<Const2>>]
/// CHECK-DAG: Return [<<Add>>]
- /// CHECK-START: double Main.DoubleAddition() constant_folding_after_inlining (after)
+ /// CHECK-START: double Main.DoubleAddition() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const3:d\d+>> DoubleConstant 3
/// CHECK-DAG: Return [<<Const3>>]
- /// CHECK-START: double Main.DoubleAddition() constant_folding_after_inlining (after)
+ /// CHECK-START: double Main.DoubleAddition() constant_folding$after_inlining (after)
/// CHECK-NOT: Add
public static double DoubleAddition() {
@@ -331,17 +331,17 @@
* Exercise constant folding on subtraction.
*/
- /// CHECK-START: int Main.IntSubtraction() constant_folding_after_inlining (before)
+ /// CHECK-START: int Main.IntSubtraction() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const6:i\d+>> IntConstant 6
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const6>>,<<Const2>>]
/// CHECK-DAG: Return [<<Sub>>]
- /// CHECK-START: int Main.IntSubtraction() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.IntSubtraction() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const4:i\d+>> IntConstant 4
/// CHECK-DAG: Return [<<Const4>>]
- /// CHECK-START: int Main.IntSubtraction() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.IntSubtraction() constant_folding$after_inlining (after)
/// CHECK-NOT: Sub
public static int IntSubtraction() {
@@ -352,17 +352,17 @@
return c;
}
- /// CHECK-START: long Main.LongSubtraction() constant_folding_after_inlining (before)
+ /// CHECK-START: long Main.LongSubtraction() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const6:j\d+>> LongConstant 6
/// CHECK-DAG: <<Const2:j\d+>> LongConstant 2
/// CHECK-DAG: <<Sub:j\d+>> Sub [<<Const6>>,<<Const2>>]
/// CHECK-DAG: Return [<<Sub>>]
- /// CHECK-START: long Main.LongSubtraction() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.LongSubtraction() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const4:j\d+>> LongConstant 4
/// CHECK-DAG: Return [<<Const4>>]
- /// CHECK-START: long Main.LongSubtraction() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.LongSubtraction() constant_folding$after_inlining (after)
/// CHECK-NOT: Sub
public static long LongSubtraction() {
@@ -373,17 +373,17 @@
return c;
}
- /// CHECK-START: float Main.FloatSubtraction() constant_folding_after_inlining (before)
+ /// CHECK-START: float Main.FloatSubtraction() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const6:f\d+>> FloatConstant 6
/// CHECK-DAG: <<Const2:f\d+>> FloatConstant 2
/// CHECK-DAG: <<Sub:f\d+>> Sub [<<Const6>>,<<Const2>>]
/// CHECK-DAG: Return [<<Sub>>]
- /// CHECK-START: float Main.FloatSubtraction() constant_folding_after_inlining (after)
+ /// CHECK-START: float Main.FloatSubtraction() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const4:f\d+>> FloatConstant 4
/// CHECK-DAG: Return [<<Const4>>]
- /// CHECK-START: float Main.FloatSubtraction() constant_folding_after_inlining (after)
+ /// CHECK-START: float Main.FloatSubtraction() constant_folding$after_inlining (after)
/// CHECK-NOT: Sub
public static float FloatSubtraction() {
@@ -394,17 +394,17 @@
return c;
}
- /// CHECK-START: double Main.DoubleSubtraction() constant_folding_after_inlining (before)
+ /// CHECK-START: double Main.DoubleSubtraction() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const6:d\d+>> DoubleConstant 6
/// CHECK-DAG: <<Const2:d\d+>> DoubleConstant 2
/// CHECK-DAG: <<Sub:d\d+>> Sub [<<Const6>>,<<Const2>>]
/// CHECK-DAG: Return [<<Sub>>]
- /// CHECK-START: double Main.DoubleSubtraction() constant_folding_after_inlining (after)
+ /// CHECK-START: double Main.DoubleSubtraction() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const4:d\d+>> DoubleConstant 4
/// CHECK-DAG: Return [<<Const4>>]
- /// CHECK-START: double Main.DoubleSubtraction() constant_folding_after_inlining (after)
+ /// CHECK-START: double Main.DoubleSubtraction() constant_folding$after_inlining (after)
/// CHECK-NOT: Sub
public static double DoubleSubtraction() {
@@ -420,17 +420,17 @@
* Exercise constant folding on multiplication.
*/
- /// CHECK-START: int Main.IntMultiplication() constant_folding_after_inlining (before)
+ /// CHECK-START: int Main.IntMultiplication() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const7:i\d+>> IntConstant 7
/// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
/// CHECK-DAG: <<Mul:i\d+>> Mul [<<Const7>>,<<Const3>>]
/// CHECK-DAG: Return [<<Mul>>]
- /// CHECK-START: int Main.IntMultiplication() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.IntMultiplication() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const21:i\d+>> IntConstant 21
/// CHECK-DAG: Return [<<Const21>>]
- /// CHECK-START: int Main.IntMultiplication() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.IntMultiplication() constant_folding$after_inlining (after)
/// CHECK-NOT: Mul
public static int IntMultiplication() {
@@ -441,17 +441,17 @@
return c;
}
- /// CHECK-START: long Main.LongMultiplication() constant_folding_after_inlining (before)
+ /// CHECK-START: long Main.LongMultiplication() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const7:j\d+>> LongConstant 7
/// CHECK-DAG: <<Const3:j\d+>> LongConstant 3
/// CHECK-DAG: <<Mul:j\d+>> Mul [<<Const7>>,<<Const3>>]
/// CHECK-DAG: Return [<<Mul>>]
- /// CHECK-START: long Main.LongMultiplication() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.LongMultiplication() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const21:j\d+>> LongConstant 21
/// CHECK-DAG: Return [<<Const21>>]
- /// CHECK-START: long Main.LongMultiplication() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.LongMultiplication() constant_folding$after_inlining (after)
/// CHECK-NOT: Mul
public static long LongMultiplication() {
@@ -462,17 +462,17 @@
return c;
}
- /// CHECK-START: float Main.FloatMultiplication() constant_folding_after_inlining (before)
+ /// CHECK-START: float Main.FloatMultiplication() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const7:f\d+>> FloatConstant 7
/// CHECK-DAG: <<Const3:f\d+>> FloatConstant 3
/// CHECK-DAG: <<Mul:f\d+>> Mul [<<Const7>>,<<Const3>>]
/// CHECK-DAG: Return [<<Mul>>]
- /// CHECK-START: float Main.FloatMultiplication() constant_folding_after_inlining (after)
+ /// CHECK-START: float Main.FloatMultiplication() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const21:f\d+>> FloatConstant 21
/// CHECK-DAG: Return [<<Const21>>]
- /// CHECK-START: float Main.FloatMultiplication() constant_folding_after_inlining (after)
+ /// CHECK-START: float Main.FloatMultiplication() constant_folding$after_inlining (after)
/// CHECK-NOT: Mul
public static float FloatMultiplication() {
@@ -483,17 +483,17 @@
return c;
}
- /// CHECK-START: double Main.DoubleMultiplication() constant_folding_after_inlining (before)
+ /// CHECK-START: double Main.DoubleMultiplication() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const7:d\d+>> DoubleConstant 7
/// CHECK-DAG: <<Const3:d\d+>> DoubleConstant 3
/// CHECK-DAG: <<Mul:d\d+>> Mul [<<Const7>>,<<Const3>>]
/// CHECK-DAG: Return [<<Mul>>]
- /// CHECK-START: double Main.DoubleMultiplication() constant_folding_after_inlining (after)
+ /// CHECK-START: double Main.DoubleMultiplication() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const21:d\d+>> DoubleConstant 21
/// CHECK-DAG: Return [<<Const21>>]
- /// CHECK-START: double Main.DoubleMultiplication() constant_folding_after_inlining (after)
+ /// CHECK-START: double Main.DoubleMultiplication() constant_folding$after_inlining (after)
/// CHECK-NOT: Mul
public static double DoubleMultiplication() {
@@ -509,18 +509,18 @@
* Exercise constant folding on division.
*/
- /// CHECK-START: int Main.IntDivision() constant_folding_after_inlining (before)
+ /// CHECK-START: int Main.IntDivision() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const8:i\d+>> IntConstant 8
/// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
/// CHECK-DAG: <<Div0Chk:i\d+>> DivZeroCheck [<<Const3>>]
/// CHECK-DAG: <<Div:i\d+>> Div [<<Const8>>,<<Div0Chk>>]
/// CHECK-DAG: Return [<<Div>>]
- /// CHECK-START: int Main.IntDivision() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.IntDivision() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: Return [<<Const2>>]
- /// CHECK-START: int Main.IntDivision() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.IntDivision() constant_folding$after_inlining (after)
/// CHECK-NOT: DivZeroCheck
/// CHECK-NOT: Div
@@ -532,18 +532,18 @@
return c;
}
- /// CHECK-START: long Main.LongDivision() constant_folding_after_inlining (before)
+ /// CHECK-START: long Main.LongDivision() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const8:j\d+>> LongConstant 8
/// CHECK-DAG: <<Const3:j\d+>> LongConstant 3
/// CHECK-DAG: <<Div0Chk:j\d+>> DivZeroCheck [<<Const3>>]
/// CHECK-DAG: <<Div:j\d+>> Div [<<Const8>>,<<Div0Chk>>]
/// CHECK-DAG: Return [<<Div>>]
- /// CHECK-START: long Main.LongDivision() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.LongDivision() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const2:j\d+>> LongConstant 2
/// CHECK-DAG: Return [<<Const2>>]
- /// CHECK-START: long Main.LongDivision() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.LongDivision() constant_folding$after_inlining (after)
/// CHECK-NOT: DivZeroCheck
/// CHECK-NOT: Div
@@ -555,17 +555,17 @@
return c;
}
- /// CHECK-START: float Main.FloatDivision() constant_folding_after_inlining (before)
+ /// CHECK-START: float Main.FloatDivision() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const8:f\d+>> FloatConstant 8
/// CHECK-DAG: <<Const2P5:f\d+>> FloatConstant 2.5
/// CHECK-DAG: <<Div:f\d+>> Div [<<Const8>>,<<Const2P5>>]
/// CHECK-DAG: Return [<<Div>>]
- /// CHECK-START: float Main.FloatDivision() constant_folding_after_inlining (after)
+ /// CHECK-START: float Main.FloatDivision() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const3P2:f\d+>> FloatConstant 3.2
/// CHECK-DAG: Return [<<Const3P2>>]
- /// CHECK-START: float Main.FloatDivision() constant_folding_after_inlining (after)
+ /// CHECK-START: float Main.FloatDivision() constant_folding$after_inlining (after)
/// CHECK-NOT: Div
public static float FloatDivision() {
@@ -576,17 +576,17 @@
return c;
}
- /// CHECK-START: double Main.DoubleDivision() constant_folding_after_inlining (before)
+ /// CHECK-START: double Main.DoubleDivision() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const8:d\d+>> DoubleConstant 8
/// CHECK-DAG: <<Const2P5:d\d+>> DoubleConstant 2.5
/// CHECK-DAG: <<Div:d\d+>> Div [<<Const8>>,<<Const2P5>>]
/// CHECK-DAG: Return [<<Div>>]
- /// CHECK-START: double Main.DoubleDivision() constant_folding_after_inlining (after)
+ /// CHECK-START: double Main.DoubleDivision() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const3P2:d\d+>> DoubleConstant 3.2
/// CHECK-DAG: Return [<<Const3P2>>]
- /// CHECK-START: double Main.DoubleDivision() constant_folding_after_inlining (after)
+ /// CHECK-START: double Main.DoubleDivision() constant_folding$after_inlining (after)
/// CHECK-NOT: Div
public static double DoubleDivision() {
@@ -602,18 +602,18 @@
* Exercise constant folding on remainder.
*/
- /// CHECK-START: int Main.IntRemainder() constant_folding_after_inlining (before)
+ /// CHECK-START: int Main.IntRemainder() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const8:i\d+>> IntConstant 8
/// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
/// CHECK-DAG: <<Div0Chk:i\d+>> DivZeroCheck [<<Const3>>]
/// CHECK-DAG: <<Rem:i\d+>> Rem [<<Const8>>,<<Div0Chk>>]
/// CHECK-DAG: Return [<<Rem>>]
- /// CHECK-START: int Main.IntRemainder() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.IntRemainder() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: Return [<<Const2>>]
- /// CHECK-START: int Main.IntRemainder() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.IntRemainder() constant_folding$after_inlining (after)
/// CHECK-NOT: DivZeroCheck
/// CHECK-NOT: Rem
@@ -625,18 +625,18 @@
return c;
}
- /// CHECK-START: long Main.LongRemainder() constant_folding_after_inlining (before)
+ /// CHECK-START: long Main.LongRemainder() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const8:j\d+>> LongConstant 8
/// CHECK-DAG: <<Const3:j\d+>> LongConstant 3
/// CHECK-DAG: <<Div0Chk:j\d+>> DivZeroCheck [<<Const3>>]
/// CHECK-DAG: <<Rem:j\d+>> Rem [<<Const8>>,<<Div0Chk>>]
/// CHECK-DAG: Return [<<Rem>>]
- /// CHECK-START: long Main.LongRemainder() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.LongRemainder() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const2:j\d+>> LongConstant 2
/// CHECK-DAG: Return [<<Const2>>]
- /// CHECK-START: long Main.LongRemainder() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.LongRemainder() constant_folding$after_inlining (after)
/// CHECK-NOT: DivZeroCheck
/// CHECK-NOT: Rem
@@ -648,17 +648,17 @@
return c;
}
- /// CHECK-START: float Main.FloatRemainder() constant_folding_after_inlining (before)
+ /// CHECK-START: float Main.FloatRemainder() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const8:f\d+>> FloatConstant 8
/// CHECK-DAG: <<Const2P5:f\d+>> FloatConstant 2.5
/// CHECK-DAG: <<Rem:f\d+>> Rem [<<Const8>>,<<Const2P5>>]
/// CHECK-DAG: Return [<<Rem>>]
- /// CHECK-START: float Main.FloatRemainder() constant_folding_after_inlining (after)
+ /// CHECK-START: float Main.FloatRemainder() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const0P5:f\d+>> FloatConstant 0.5
/// CHECK-DAG: Return [<<Const0P5>>]
- /// CHECK-START: float Main.FloatRemainder() constant_folding_after_inlining (after)
+ /// CHECK-START: float Main.FloatRemainder() constant_folding$after_inlining (after)
/// CHECK-NOT: Rem
public static float FloatRemainder() {
@@ -669,17 +669,17 @@
return c;
}
- /// CHECK-START: double Main.DoubleRemainder() constant_folding_after_inlining (before)
+ /// CHECK-START: double Main.DoubleRemainder() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const8:d\d+>> DoubleConstant 8
/// CHECK-DAG: <<Const2P5:d\d+>> DoubleConstant 2.5
/// CHECK-DAG: <<Rem:d\d+>> Rem [<<Const8>>,<<Const2P5>>]
/// CHECK-DAG: Return [<<Rem>>]
- /// CHECK-START: double Main.DoubleRemainder() constant_folding_after_inlining (after)
+ /// CHECK-START: double Main.DoubleRemainder() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const0P5:d\d+>> DoubleConstant 0.5
/// CHECK-DAG: Return [<<Const0P5>>]
- /// CHECK-START: double Main.DoubleRemainder() constant_folding_after_inlining (after)
+ /// CHECK-START: double Main.DoubleRemainder() constant_folding$after_inlining (after)
/// CHECK-NOT: Rem
public static double DoubleRemainder() {
@@ -695,18 +695,18 @@
* Exercise constant folding on left shift.
*/
- /// CHECK-START: int Main.ShlIntLong() constant_folding_after_inlining (before)
+ /// CHECK-START: int Main.ShlIntLong() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
/// CHECK-DAG: <<Const2L:j\d+>> LongConstant 2
/// CHECK-DAG: <<TypeConv:i\d+>> TypeConversion [<<Const2L>>]
/// CHECK-DAG: <<Shl:i\d+>> Shl [<<Const1>>,<<TypeConv>>]
/// CHECK-DAG: Return [<<Shl>>]
- /// CHECK-START: int Main.ShlIntLong() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.ShlIntLong() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const4:i\d+>> IntConstant 4
/// CHECK-DAG: Return [<<Const4>>]
- /// CHECK-START: int Main.ShlIntLong() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.ShlIntLong() constant_folding$after_inlining (after)
/// CHECK-NOT: Shl
public static int ShlIntLong() {
@@ -715,17 +715,17 @@
return lhs << rhs;
}
- /// CHECK-START: long Main.ShlLongInt() constant_folding_after_inlining (before)
+ /// CHECK-START: long Main.ShlLongInt() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const3L:j\d+>> LongConstant 3
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: <<Shl:j\d+>> Shl [<<Const3L>>,<<Const2>>]
/// CHECK-DAG: Return [<<Shl>>]
- /// CHECK-START: long Main.ShlLongInt() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.ShlLongInt() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const12L:j\d+>> LongConstant 12
/// CHECK-DAG: Return [<<Const12L>>]
- /// CHECK-START: long Main.ShlLongInt() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.ShlLongInt() constant_folding$after_inlining (after)
/// CHECK-NOT: Shl
public static long ShlLongInt() {
@@ -739,18 +739,18 @@
* Exercise constant folding on right shift.
*/
- /// CHECK-START: int Main.ShrIntLong() constant_folding_after_inlining (before)
+ /// CHECK-START: int Main.ShrIntLong() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const7:i\d+>> IntConstant 7
/// CHECK-DAG: <<Const2L:j\d+>> LongConstant 2
/// CHECK-DAG: <<TypeConv:i\d+>> TypeConversion [<<Const2L>>]
/// CHECK-DAG: <<Shr:i\d+>> Shr [<<Const7>>,<<TypeConv>>]
/// CHECK-DAG: Return [<<Shr>>]
- /// CHECK-START: int Main.ShrIntLong() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.ShrIntLong() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
/// CHECK-DAG: Return [<<Const1>>]
- /// CHECK-START: int Main.ShrIntLong() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.ShrIntLong() constant_folding$after_inlining (after)
/// CHECK-NOT: Shr
public static int ShrIntLong() {
@@ -759,17 +759,17 @@
return lhs >> rhs;
}
- /// CHECK-START: long Main.ShrLongInt() constant_folding_after_inlining (before)
+ /// CHECK-START: long Main.ShrLongInt() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const9L:j\d+>> LongConstant 9
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: <<Shr:j\d+>> Shr [<<Const9L>>,<<Const2>>]
/// CHECK-DAG: Return [<<Shr>>]
- /// CHECK-START: long Main.ShrLongInt() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.ShrLongInt() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const2L:j\d+>> LongConstant 2
/// CHECK-DAG: Return [<<Const2L>>]
- /// CHECK-START: long Main.ShrLongInt() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.ShrLongInt() constant_folding$after_inlining (after)
/// CHECK-NOT: Shr
public static long ShrLongInt() {
@@ -783,18 +783,18 @@
* Exercise constant folding on unsigned right shift.
*/
- /// CHECK-START: int Main.UShrIntLong() constant_folding_after_inlining (before)
+ /// CHECK-START: int Main.UShrIntLong() constant_folding$after_inlining (before)
/// CHECK-DAG: <<ConstM7:i\d+>> IntConstant -7
/// CHECK-DAG: <<Const2L:j\d+>> LongConstant 2
/// CHECK-DAG: <<TypeConv:i\d+>> TypeConversion [<<Const2L>>]
/// CHECK-DAG: <<UShr:i\d+>> UShr [<<ConstM7>>,<<TypeConv>>]
/// CHECK-DAG: Return [<<UShr>>]
- /// CHECK-START: int Main.UShrIntLong() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.UShrIntLong() constant_folding$after_inlining (after)
/// CHECK-DAG: <<ConstRes:i\d+>> IntConstant 1073741822
/// CHECK-DAG: Return [<<ConstRes>>]
- /// CHECK-START: int Main.UShrIntLong() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.UShrIntLong() constant_folding$after_inlining (after)
/// CHECK-NOT: UShr
public static int UShrIntLong() {
@@ -803,17 +803,17 @@
return lhs >>> rhs;
}
- /// CHECK-START: long Main.UShrLongInt() constant_folding_after_inlining (before)
+ /// CHECK-START: long Main.UShrLongInt() constant_folding$after_inlining (before)
/// CHECK-DAG: <<ConstM9L:j\d+>> LongConstant -9
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: <<UShr:j\d+>> UShr [<<ConstM9L>>,<<Const2>>]
/// CHECK-DAG: Return [<<UShr>>]
- /// CHECK-START: long Main.UShrLongInt() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.UShrLongInt() constant_folding$after_inlining (after)
/// CHECK-DAG: <<ConstRes:j\d+>> LongConstant 4611686018427387901
/// CHECK-DAG: Return [<<ConstRes>>]
- /// CHECK-START: long Main.UShrLongInt() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.UShrLongInt() constant_folding$after_inlining (after)
/// CHECK-NOT: UShr
public static long UShrLongInt() {
@@ -827,18 +827,18 @@
* Exercise constant folding on logical and.
*/
- /// CHECK-START: long Main.AndIntLong() constant_folding_after_inlining (before)
+ /// CHECK-START: long Main.AndIntLong() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const10:i\d+>> IntConstant 10
/// CHECK-DAG: <<Const3L:j\d+>> LongConstant 3
/// CHECK-DAG: <<TypeConv:j\d+>> TypeConversion [<<Const10>>]
/// CHECK-DAG: <<And:j\d+>> And [<<TypeConv>>,<<Const3L>>]
/// CHECK-DAG: Return [<<And>>]
- /// CHECK-START: long Main.AndIntLong() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.AndIntLong() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const2:j\d+>> LongConstant 2
/// CHECK-DAG: Return [<<Const2>>]
- /// CHECK-START: long Main.AndIntLong() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.AndIntLong() constant_folding$after_inlining (after)
/// CHECK-NOT: And
public static long AndIntLong() {
@@ -847,18 +847,18 @@
return lhs & rhs;
}
- /// CHECK-START: long Main.AndLongInt() constant_folding_after_inlining (before)
+ /// CHECK-START: long Main.AndLongInt() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const10L:j\d+>> LongConstant 10
/// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
/// CHECK-DAG: <<TypeConv:j\d+>> TypeConversion [<<Const3>>]
/// CHECK-DAG: <<And:j\d+>> And [<<TypeConv>>,<<Const10L>>]
/// CHECK-DAG: Return [<<And>>]
- /// CHECK-START: long Main.AndLongInt() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.AndLongInt() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const2:j\d+>> LongConstant 2
/// CHECK-DAG: Return [<<Const2>>]
- /// CHECK-START: long Main.AndLongInt() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.AndLongInt() constant_folding$after_inlining (after)
/// CHECK-NOT: And
public static long AndLongInt() {
@@ -872,18 +872,18 @@
* Exercise constant folding on logical or.
*/
- /// CHECK-START: long Main.OrIntLong() constant_folding_after_inlining (before)
+ /// CHECK-START: long Main.OrIntLong() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const10:i\d+>> IntConstant 10
/// CHECK-DAG: <<Const3L:j\d+>> LongConstant 3
/// CHECK-DAG: <<TypeConv:j\d+>> TypeConversion [<<Const10>>]
/// CHECK-DAG: <<Or:j\d+>> Or [<<TypeConv>>,<<Const3L>>]
/// CHECK-DAG: Return [<<Or>>]
- /// CHECK-START: long Main.OrIntLong() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.OrIntLong() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const11:j\d+>> LongConstant 11
/// CHECK-DAG: Return [<<Const11>>]
- /// CHECK-START: long Main.OrIntLong() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.OrIntLong() constant_folding$after_inlining (after)
/// CHECK-NOT: Or
public static long OrIntLong() {
@@ -892,18 +892,18 @@
return lhs | rhs;
}
- /// CHECK-START: long Main.OrLongInt() constant_folding_after_inlining (before)
+ /// CHECK-START: long Main.OrLongInt() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const10L:j\d+>> LongConstant 10
/// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
/// CHECK-DAG: <<TypeConv:j\d+>> TypeConversion [<<Const3>>]
/// CHECK-DAG: <<Or:j\d+>> Or [<<TypeConv>>,<<Const10L>>]
/// CHECK-DAG: Return [<<Or>>]
- /// CHECK-START: long Main.OrLongInt() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.OrLongInt() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const11:j\d+>> LongConstant 11
/// CHECK-DAG: Return [<<Const11>>]
- /// CHECK-START: long Main.OrLongInt() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.OrLongInt() constant_folding$after_inlining (after)
/// CHECK-NOT: Or
public static long OrLongInt() {
@@ -917,18 +917,18 @@
* Exercise constant folding on logical exclusive or.
*/
- /// CHECK-START: long Main.XorIntLong() constant_folding_after_inlining (before)
+ /// CHECK-START: long Main.XorIntLong() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const10:i\d+>> IntConstant 10
/// CHECK-DAG: <<Const3L:j\d+>> LongConstant 3
/// CHECK-DAG: <<TypeConv:j\d+>> TypeConversion [<<Const10>>]
/// CHECK-DAG: <<Xor:j\d+>> Xor [<<TypeConv>>,<<Const3L>>]
/// CHECK-DAG: Return [<<Xor>>]
- /// CHECK-START: long Main.XorIntLong() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.XorIntLong() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const9:j\d+>> LongConstant 9
/// CHECK-DAG: Return [<<Const9>>]
- /// CHECK-START: long Main.XorIntLong() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.XorIntLong() constant_folding$after_inlining (after)
/// CHECK-NOT: Xor
public static long XorIntLong() {
@@ -937,18 +937,18 @@
return lhs ^ rhs;
}
- /// CHECK-START: long Main.XorLongInt() constant_folding_after_inlining (before)
+ /// CHECK-START: long Main.XorLongInt() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const10L:j\d+>> LongConstant 10
/// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
/// CHECK-DAG: <<TypeConv:j\d+>> TypeConversion [<<Const3>>]
/// CHECK-DAG: <<Xor:j\d+>> Xor [<<TypeConv>>,<<Const10L>>]
/// CHECK-DAG: Return [<<Xor>>]
- /// CHECK-START: long Main.XorLongInt() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.XorLongInt() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const9:j\d+>> LongConstant 9
/// CHECK-DAG: Return [<<Const9>>]
- /// CHECK-START: long Main.XorLongInt() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.XorLongInt() constant_folding$after_inlining (after)
/// CHECK-NOT: Xor
public static long XorLongInt() {
@@ -962,17 +962,17 @@
* Exercise constant folding on constant (static) condition.
*/
- /// CHECK-START: int Main.StaticCondition() constant_folding_after_inlining (before)
+ /// CHECK-START: int Main.StaticCondition() constant_folding$after_inlining (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: Select [{{i\d+}},{{i\d+}},<<Cond>>]
- /// CHECK-START: int Main.StaticCondition() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.StaticCondition() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
/// CHECK-DAG: Select [{{i\d+}},{{i\d+}},<<Const1>>]
- /// CHECK-START: int Main.StaticCondition() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.StaticCondition() constant_folding$after_inlining (after)
/// CHECK-NOT: GreaterThanOrEqual
public static int StaticCondition() {
@@ -991,16 +991,16 @@
* Exercise constant folding on constant (static) condition for null references.
*/
- /// CHECK-START: int Main.StaticConditionNulls() constant_folding_after_inlining (before)
+ /// CHECK-START: int Main.StaticConditionNulls() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Null:l\d+>> NullConstant
/// CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Null>>,<<Null>>]
/// CHECK-DAG: Select [{{i\d+}},{{i\d+}},<<Cond>>]
- /// CHECK-START: int Main.StaticConditionNulls() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.StaticConditionNulls() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
/// CHECK-DAG: Select [{{i\d+}},{{i\d+}},<<Const0>>]
- /// CHECK-START: int Main.StaticConditionNulls() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.StaticConditionNulls() constant_folding$after_inlining (after)
/// CHECK-NOT: NotEqual
private static Object getNull() {
@@ -1023,7 +1023,7 @@
* (forward) post-order traversal of the the dominator tree.
*/
- /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding_after_inlining (before)
+ /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding$after_inlining (before)
/// CHECK-DAG: <<Cond:z\d+>> ParameterValue
/// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
/// CHECK-DAG: <<Const5:i\d+>> IntConstant 5
@@ -1032,14 +1032,14 @@
/// CHECK-DAG: <<Phi:i\d+>> Select [<<Sub>>,<<Add>>,<<Cond>>]
/// CHECK-DAG: Return [<<Phi>>]
- /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding$after_inlining (after)
/// CHECK-DAG: <<Cond:z\d+>> ParameterValue
/// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
/// CHECK-DAG: <<Const7:i\d+>> IntConstant 7
/// CHECK-DAG: <<Phi:i\d+>> Select [<<Const3>>,<<Const7>>,<<Cond>>]
/// CHECK-DAG: Return [<<Phi>>]
- /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding$after_inlining (after)
/// CHECK-NOT: Add
/// CHECK-NOT: Sub
@@ -1325,16 +1325,16 @@
* Exercise constant folding on type conversions.
*/
- /// CHECK-START: int Main.ReturnInt33() constant_folding_after_inlining (before)
+ /// CHECK-START: int Main.ReturnInt33() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const33:j\d+>> LongConstant 33
/// CHECK-DAG: <<Convert:i\d+>> TypeConversion [<<Const33>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: int Main.ReturnInt33() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.ReturnInt33() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const33:i\d+>> IntConstant 33
/// CHECK-DAG: Return [<<Const33>>]
- /// CHECK-START: int Main.ReturnInt33() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.ReturnInt33() constant_folding$after_inlining (after)
/// CHECK-NOT: TypeConversion
public static int ReturnInt33() {
@@ -1342,16 +1342,16 @@
return (int) imm;
}
- /// CHECK-START: int Main.ReturnIntMax() constant_folding_after_inlining (before)
+ /// CHECK-START: int Main.ReturnIntMax() constant_folding$after_inlining (before)
/// CHECK-DAG: <<ConstMax:f\d+>> FloatConstant 1e+34
/// CHECK-DAG: <<Convert:i\d+>> TypeConversion [<<ConstMax>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: int Main.ReturnIntMax() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.ReturnIntMax() constant_folding$after_inlining (after)
/// CHECK-DAG: <<ConstMax:i\d+>> IntConstant 2147483647
/// CHECK-DAG: Return [<<ConstMax>>]
- /// CHECK-START: int Main.ReturnIntMax() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.ReturnIntMax() constant_folding$after_inlining (after)
/// CHECK-NOT: TypeConversion
public static int ReturnIntMax() {
@@ -1359,16 +1359,16 @@
return (int) imm;
}
- /// CHECK-START: int Main.ReturnInt0() constant_folding_after_inlining (before)
+ /// CHECK-START: int Main.ReturnInt0() constant_folding$after_inlining (before)
/// CHECK-DAG: <<ConstNaN:d\d+>> DoubleConstant nan
/// CHECK-DAG: <<Convert:i\d+>> TypeConversion [<<ConstNaN>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: int Main.ReturnInt0() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.ReturnInt0() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
/// CHECK-DAG: Return [<<Const0>>]
- /// CHECK-START: int Main.ReturnInt0() constant_folding_after_inlining (after)
+ /// CHECK-START: int Main.ReturnInt0() constant_folding$after_inlining (after)
/// CHECK-NOT: TypeConversion
public static int ReturnInt0() {
@@ -1376,16 +1376,16 @@
return (int) imm;
}
- /// CHECK-START: long Main.ReturnLong33() constant_folding_after_inlining (before)
+ /// CHECK-START: long Main.ReturnLong33() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const33:i\d+>> IntConstant 33
/// CHECK-DAG: <<Convert:j\d+>> TypeConversion [<<Const33>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: long Main.ReturnLong33() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.ReturnLong33() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const33:j\d+>> LongConstant 33
/// CHECK-DAG: Return [<<Const33>>]
- /// CHECK-START: long Main.ReturnLong33() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.ReturnLong33() constant_folding$after_inlining (after)
/// CHECK-NOT: TypeConversion
public static long ReturnLong33() {
@@ -1393,16 +1393,16 @@
return (long) imm;
}
- /// CHECK-START: long Main.ReturnLong34() constant_folding_after_inlining (before)
+ /// CHECK-START: long Main.ReturnLong34() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const34:f\d+>> FloatConstant 34
/// CHECK-DAG: <<Convert:j\d+>> TypeConversion [<<Const34>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: long Main.ReturnLong34() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.ReturnLong34() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const34:j\d+>> LongConstant 34
/// CHECK-DAG: Return [<<Const34>>]
- /// CHECK-START: long Main.ReturnLong34() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.ReturnLong34() constant_folding$after_inlining (after)
/// CHECK-NOT: TypeConversion
public static long ReturnLong34() {
@@ -1410,16 +1410,16 @@
return (long) imm;
}
- /// CHECK-START: long Main.ReturnLong0() constant_folding_after_inlining (before)
+ /// CHECK-START: long Main.ReturnLong0() constant_folding$after_inlining (before)
/// CHECK-DAG: <<ConstNaN:d\d+>> DoubleConstant nan
/// CHECK-DAG: <<Convert:j\d+>> TypeConversion [<<ConstNaN>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: long Main.ReturnLong0() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.ReturnLong0() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
/// CHECK-DAG: Return [<<Const0>>]
- /// CHECK-START: long Main.ReturnLong0() constant_folding_after_inlining (after)
+ /// CHECK-START: long Main.ReturnLong0() constant_folding$after_inlining (after)
/// CHECK-NOT: TypeConversion
public static long ReturnLong0() {
@@ -1427,16 +1427,16 @@
return (long) imm;
}
- /// CHECK-START: float Main.ReturnFloat33() constant_folding_after_inlining (before)
+ /// CHECK-START: float Main.ReturnFloat33() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const33:i\d+>> IntConstant 33
/// CHECK-DAG: <<Convert:f\d+>> TypeConversion [<<Const33>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: float Main.ReturnFloat33() constant_folding_after_inlining (after)
+ /// CHECK-START: float Main.ReturnFloat33() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const33:f\d+>> FloatConstant 33
/// CHECK-DAG: Return [<<Const33>>]
- /// CHECK-START: float Main.ReturnFloat33() constant_folding_after_inlining (after)
+ /// CHECK-START: float Main.ReturnFloat33() constant_folding$after_inlining (after)
/// CHECK-NOT: TypeConversion
public static float ReturnFloat33() {
@@ -1444,16 +1444,16 @@
return (float) imm;
}
- /// CHECK-START: float Main.ReturnFloat34() constant_folding_after_inlining (before)
+ /// CHECK-START: float Main.ReturnFloat34() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const34:j\d+>> LongConstant 34
/// CHECK-DAG: <<Convert:f\d+>> TypeConversion [<<Const34>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: float Main.ReturnFloat34() constant_folding_after_inlining (after)
+ /// CHECK-START: float Main.ReturnFloat34() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const34:f\d+>> FloatConstant 34
/// CHECK-DAG: Return [<<Const34>>]
- /// CHECK-START: float Main.ReturnFloat34() constant_folding_after_inlining (after)
+ /// CHECK-START: float Main.ReturnFloat34() constant_folding$after_inlining (after)
/// CHECK-NOT: TypeConversion
public static float ReturnFloat34() {
@@ -1461,16 +1461,16 @@
return (float) imm;
}
- /// CHECK-START: float Main.ReturnFloat99P25() constant_folding_after_inlining (before)
+ /// CHECK-START: float Main.ReturnFloat99P25() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const:d\d+>> DoubleConstant 99.25
/// CHECK-DAG: <<Convert:f\d+>> TypeConversion [<<Const>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: float Main.ReturnFloat99P25() constant_folding_after_inlining (after)
+ /// CHECK-START: float Main.ReturnFloat99P25() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const:f\d+>> FloatConstant 99.25
/// CHECK-DAG: Return [<<Const>>]
- /// CHECK-START: float Main.ReturnFloat99P25() constant_folding_after_inlining (after)
+ /// CHECK-START: float Main.ReturnFloat99P25() constant_folding$after_inlining (after)
/// CHECK-NOT: TypeConversion
public static float ReturnFloat99P25() {
@@ -1478,12 +1478,12 @@
return (float) imm;
}
- /// CHECK-START: double Main.ReturnDouble33() constant_folding_after_inlining (before)
+ /// CHECK-START: double Main.ReturnDouble33() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const33:i\d+>> IntConstant 33
/// CHECK-DAG: <<Convert:d\d+>> TypeConversion [<<Const33>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: double Main.ReturnDouble33() constant_folding_after_inlining (after)
+ /// CHECK-START: double Main.ReturnDouble33() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const33:d\d+>> DoubleConstant 33
/// CHECK-DAG: Return [<<Const33>>]
@@ -1492,16 +1492,16 @@
return (double) imm;
}
- /// CHECK-START: double Main.ReturnDouble34() constant_folding_after_inlining (before)
+ /// CHECK-START: double Main.ReturnDouble34() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const34:j\d+>> LongConstant 34
/// CHECK-DAG: <<Convert:d\d+>> TypeConversion [<<Const34>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: double Main.ReturnDouble34() constant_folding_after_inlining (after)
+ /// CHECK-START: double Main.ReturnDouble34() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const34:d\d+>> DoubleConstant 34
/// CHECK-DAG: Return [<<Const34>>]
- /// CHECK-START: double Main.ReturnDouble34() constant_folding_after_inlining (after)
+ /// CHECK-START: double Main.ReturnDouble34() constant_folding$after_inlining (after)
/// CHECK-NOT: TypeConversion
public static double ReturnDouble34() {
@@ -1509,16 +1509,16 @@
return (double) imm;
}
- /// CHECK-START: double Main.ReturnDouble99P25() constant_folding_after_inlining (before)
+ /// CHECK-START: double Main.ReturnDouble99P25() constant_folding$after_inlining (before)
/// CHECK-DAG: <<Const:f\d+>> FloatConstant 99.25
/// CHECK-DAG: <<Convert:d\d+>> TypeConversion [<<Const>>]
/// CHECK-DAG: Return [<<Convert>>]
- /// CHECK-START: double Main.ReturnDouble99P25() constant_folding_after_inlining (after)
+ /// CHECK-START: double Main.ReturnDouble99P25() constant_folding$after_inlining (after)
/// CHECK-DAG: <<Const:d\d+>> DoubleConstant 99.25
/// CHECK-DAG: Return [<<Const>>]
- /// CHECK-START: double Main.ReturnDouble99P25() constant_folding_after_inlining (after)
+ /// CHECK-START: double Main.ReturnDouble99P25() constant_folding$after_inlining (after)
/// CHECK-NOT: TypeConversion
public static double ReturnDouble99P25() {