Remove obsolete `doThrow` pattern from some tests.
And mark methods with $noinline$ instead if they were not
marked yet. Also exercise some test methods that were
previously unused, only CHECK-ed.
Test: testrunner.py --host --optimizing -t 536 -t 567 -t 570
Change-Id: I8d8e8c07f2e0002dccd665878b47c547c6a375a3
diff --git a/test/536-checker-intrinsic-optimization/smali/SmaliTests.smali b/test/536-checker-intrinsic-optimization/smali/SmaliTests.smali
index ffb1853..87aca6f 100644
--- a/test/536-checker-intrinsic-optimization/smali/SmaliTests.smali
+++ b/test/536-checker-intrinsic-optimization/smali/SmaliTests.smali
@@ -15,11 +15,11 @@
.class public LSmaliTests;
.super Ljava/lang/Object;
-## CHECK-START: char SmaliTests.stringCharAtCatch(java.lang.String, int) instruction_simplifier (before)
+## CHECK-START: char SmaliTests.$noinline$stringCharAtCatch(java.lang.String, int) instruction_simplifier (before)
## CHECK-DAG: <<Char:c\d+>> InvokeVirtual intrinsic:StringCharAt
## CHECK-DAG: Return [<<Char>>]
-## CHECK-START: char SmaliTests.stringCharAtCatch(java.lang.String, int) instruction_simplifier (after)
+## CHECK-START: char SmaliTests.$noinline$stringCharAtCatch(java.lang.String, int) instruction_simplifier (after)
## CHECK-DAG: <<String:l\d+>> ParameterValue
## CHECK-DAG: <<Pos:i\d+>> ParameterValue
## CHECK-DAG: <<NullCk:l\d+>> NullCheck [<<String>>]
@@ -28,23 +28,15 @@
## CHECK-DAG: <<Char:c\d+>> ArrayGet [<<NullCk>>,<<Bounds>>] is_string_char_at:true
## CHECK-DAG: Return [<<Char>>]
-## CHECK-START: char SmaliTests.stringCharAtCatch(java.lang.String, int) instruction_simplifier (after)
+## CHECK-START: char SmaliTests.$noinline$stringCharAtCatch(java.lang.String, int) instruction_simplifier (after)
## CHECK-NOT: InvokeVirtual intrinsic:StringCharAt
-.method public static stringCharAtCatch(Ljava/lang/String;I)C
+.method public static $noinline$stringCharAtCatch(Ljava/lang/String;I)C
.registers 4
.param p0, "s" # Ljava/lang/String;
.param p1, "pos" # I
.prologue
- # if (doThrow) { throw new Error(); }
- sget-boolean v1, LMain;->doThrow:Z
- if-eqz v1, :doThrow_false
- new-instance v1, Ljava/lang/Error;
- invoke-direct {v1}, Ljava/lang/Error;-><init>()V
- throw v1
-
- :doThrow_false
:try_start
# tmp = s.charAt(pos)
invoke-virtual {p0, p1}, Ljava/lang/String;->charAt(I)C
diff --git a/test/536-checker-intrinsic-optimization/src/Main.java b/test/536-checker-intrinsic-optimization/src/Main.java
index 83a89a6..a2bd42f 100644
--- a/test/536-checker-intrinsic-optimization/src/Main.java
+++ b/test/536-checker-intrinsic-optimization/src/Main.java
@@ -17,8 +17,6 @@
import java.lang.reflect.Method;
public class Main {
- public static boolean doThrow = false;
-
public static void assertIntEquals(int expected, int result) {
if (expected != result) {
throw new Error("Expected: " + expected + ", found: " + result);
@@ -84,9 +82,9 @@
}
assertCharEquals('7', $opt$noinline$stringCharAtCatch("0123456789", 7));
- assertCharEquals('7', $noinline$runSmaliTest("stringCharAtCatch", "0123456789", 7));
+ assertCharEquals('7', $noinline$runSmaliTest("$noinline$stringCharAtCatch", "0123456789", 7));
assertCharEquals('\0', $opt$noinline$stringCharAtCatch("0123456789", 10));
- assertCharEquals('\0', $noinline$runSmaliTest("stringCharAtCatch","0123456789", 10));
+ assertCharEquals('\0', $noinline$runSmaliTest("$noinline$stringCharAtCatch","0123456789", 10));
assertIntEquals('a' + 'b' + 'c', $opt$noinline$stringSumChars("abc"));
assertIntEquals('a' + 'b' + 'c', $opt$noinline$stringSumLeadingChars("abcdef", 3));
@@ -123,7 +121,6 @@
/// CHECK-NOT: InvokeVirtual intrinsic:StringLength
static public int $opt$noinline$getStringLength(String s) {
- if (doThrow) { throw new Error(); }
return s.length();
}
@@ -143,7 +140,6 @@
/// CHECK-NOT: InvokeVirtual intrinsic:StringIsEmpty
static public boolean $opt$noinline$isStringEmpty(String s) {
- if (doThrow) { throw new Error(); }
return s.isEmpty();
}
@@ -164,7 +160,6 @@
/// CHECK-NOT: InvokeVirtual intrinsic:StringCharAt
static public char $opt$noinline$stringCharAt(String s, int pos) {
- if (doThrow) { throw new Error(); }
return s.charAt(pos);
}
@@ -191,7 +186,6 @@
/// CHECK-NOT: InvokeVirtual intrinsic:StringCharAt
static public char $opt$noinline$stringCharAtCatch(String s, int pos) {
- if (doThrow) { throw new Error(); }
try {
return s.charAt(pos);
} catch (StringIndexOutOfBoundsException ignored) {
@@ -221,7 +215,6 @@
/// CHECK-NOT: BoundsCheck
static public int $opt$noinline$stringSumChars(String s) {
- if (doThrow) { throw new Error(); }
int sum = 0;
int len = s.length();
for (int i = 0; i < len; ++i) {
@@ -248,7 +241,6 @@
/// CHECK-NOT: BoundsCheck is_string_char_at:true
static public int $opt$noinline$stringSumLeadingChars(String s, int n) {
- if (doThrow) { throw new Error(); }
int sum = 0;
for (int i = 0; i < n; ++i) {
sum += s.charAt(i);
@@ -286,7 +278,6 @@
/// CHECK-NOT: BoundsCheck is_string_char_at:true
static public int $opt$noinline$stringSum4LeadingChars(String s) {
- if (doThrow) { throw new Error(); }
int sum = s.charAt(0) + s.charAt(1) + s.charAt(2) + s.charAt(3);
return sum;
}
diff --git a/test/567-checker-compare/src/Main.java b/test/567-checker-compare/src/Main.java
index a3ff005..25d88aa 100644
--- a/test/567-checker-compare/src/Main.java
+++ b/test/567-checker-compare/src/Main.java
@@ -18,8 +18,6 @@
public class Main {
- public static boolean doThrow = false;
-
/// CHECK-START: void Main.$opt$noinline$testReplaceInputWithItself(int) builder (after)
/// CHECK-DAG: <<ArgX:i\d+>> ParameterValue
/// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
@@ -32,8 +30,6 @@
/// CHECK-DAG: GreaterThanOrEqual [<<ArgX>>,<<Zero>>]
public static void $opt$noinline$testReplaceInputWithItself(int x) {
- if (doThrow) { throw new Error(); }
-
// The instruction simplifier first replaces Integer.compare(x, 0) with Compare HIR
// and then merges the Compare into the GreaterThanOrEqual. This is a regression
// test that to check that it is allowed to replace the second input of the
diff --git a/test/570-checker-select/src/Main.java b/test/570-checker-select/src/Main.java
index 2dad14c..0e23b3d 100644
--- a/test/570-checker-select/src/Main.java
+++ b/test/570-checker-select/src/Main.java
@@ -16,322 +16,272 @@
public class Main {
- static boolean doThrow = false;
-
- /// CHECK-START: int Main.BoolCond_IntVarVar(boolean, int, int) register (after)
+ /// CHECK-START: int Main.$noinline$BoolCond_IntVarVar(boolean, int, int) register (after)
/// CHECK: Select [{{i\d+}},{{i\d+}},{{z\d+}}]
- /// CHECK-START-ARM64: int Main.BoolCond_IntVarVar(boolean, int, int) disassembly (after)
+ /// CHECK-START-ARM64: int Main.$noinline$BoolCond_IntVarVar(boolean, int, int) disassembly (after)
/// CHECK: Select
/// CHECK-NEXT: cmp
/// CHECK-NEXT: csel ne
- /// CHECK-START-X86_64: int Main.BoolCond_IntVarVar(boolean, int, int) disassembly (after)
+ /// CHECK-START-X86_64: int Main.$noinline$BoolCond_IntVarVar(boolean, int, int) disassembly (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
/// CHECK: cmovnz/ne
- /// CHECK-START-X86: int Main.BoolCond_IntVarVar(boolean, int, int) disassembly (after)
+ /// CHECK-START-X86: int Main.$noinline$BoolCond_IntVarVar(boolean, int, int) disassembly (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
/// CHECK: cmovnz/ne
- public static int BoolCond_IntVarVar(boolean cond, int x, int y) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static int $noinline$BoolCond_IntVarVar(boolean cond, int x, int y) {
return cond ? x : y;
}
- /// CHECK-START: int Main.BoolCond_IntVarCst(boolean, int) register (after)
+ /// CHECK-START: int Main.$noinline$BoolCond_IntVarCst(boolean, int) register (after)
/// CHECK: Select [{{i\d+}},{{i\d+}},{{z\d+}}]
- /// CHECK-START-ARM64: int Main.BoolCond_IntVarCst(boolean, int) disassembly (after)
+ /// CHECK-START-ARM64: int Main.$noinline$BoolCond_IntVarCst(boolean, int) disassembly (after)
/// CHECK: Select
/// CHECK-NEXT: cmp
/// CHECK-NEXT: csinc ne
- /// CHECK-START-X86_64: int Main.BoolCond_IntVarCst(boolean, int) disassembly (after)
+ /// CHECK-START-X86_64: int Main.$noinline$BoolCond_IntVarCst(boolean, int) disassembly (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
/// CHECK: cmovnz/ne
- /// CHECK-START-X86: int Main.BoolCond_IntVarCst(boolean, int) disassembly (after)
+ /// CHECK-START-X86: int Main.$noinline$BoolCond_IntVarCst(boolean, int) disassembly (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
/// CHECK: cmovnz/ne
- public static int BoolCond_IntVarCst(boolean cond, int x) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static int $noinline$BoolCond_IntVarCst(boolean cond, int x) {
return cond ? x : 1;
}
- /// CHECK-START: int Main.BoolCond_IntCstVar(boolean, int) register (after)
+ /// CHECK-START: int Main.$noinline$BoolCond_IntCstVar(boolean, int) register (after)
/// CHECK: Select [{{i\d+}},{{i\d+}},{{z\d+}}]
- /// CHECK-START-ARM64: int Main.BoolCond_IntCstVar(boolean, int) disassembly (after)
+ /// CHECK-START-ARM64: int Main.$noinline$BoolCond_IntCstVar(boolean, int) disassembly (after)
/// CHECK: Select
/// CHECK-NEXT: cmp
/// CHECK-NEXT: csinc eq
- /// CHECK-START-X86_64: int Main.BoolCond_IntCstVar(boolean, int) disassembly (after)
+ /// CHECK-START-X86_64: int Main.$noinline$BoolCond_IntCstVar(boolean, int) disassembly (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
/// CHECK: cmovnz/ne
- /// CHECK-START-X86: int Main.BoolCond_IntCstVar(boolean, int) disassembly (after)
+ /// CHECK-START-X86: int Main.$noinline$BoolCond_IntCstVar(boolean, int) disassembly (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
/// CHECK: cmovnz/ne
- public static int BoolCond_IntCstVar(boolean cond, int y) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static int $noinline$BoolCond_IntCstVar(boolean cond, int y) {
return cond ? 1 : y;
}
- /// CHECK-START: long Main.BoolCond_LongVarVar(boolean, long, long) register (after)
+ /// CHECK-START: long Main.$noinline$BoolCond_LongVarVar(boolean, long, long) register (after)
/// CHECK: Select [{{j\d+}},{{j\d+}},{{z\d+}}]
- /// CHECK-START-ARM64: long Main.BoolCond_LongVarVar(boolean, long, long) disassembly (after)
+ /// CHECK-START-ARM64: long Main.$noinline$BoolCond_LongVarVar(boolean, long, long) disassembly (after)
/// CHECK: Select
/// CHECK-NEXT: cmp
/// CHECK-NEXT: csel ne
- /// CHECK-START-X86_64: long Main.BoolCond_LongVarVar(boolean, long, long) disassembly (after)
+ /// CHECK-START-X86_64: long Main.$noinline$BoolCond_LongVarVar(boolean, long, long) disassembly (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
/// CHECK: cmovnz/neq
- /// CHECK-START-X86: long Main.BoolCond_LongVarVar(boolean, long, long) disassembly (after)
+ /// CHECK-START-X86: long Main.$noinline$BoolCond_LongVarVar(boolean, long, long) disassembly (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
/// CHECK: cmovnz/ne
/// CHECK-NEXT: cmovnz/ne
- public static long BoolCond_LongVarVar(boolean cond, long x, long y) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static long $noinline$BoolCond_LongVarVar(boolean cond, long x, long y) {
return cond ? x : y;
}
- /// CHECK-START: long Main.BoolCond_LongVarCst(boolean, long) register (after)
+ /// CHECK-START: long Main.$noinline$BoolCond_LongVarCst(boolean, long) register (after)
/// CHECK: Select [{{j\d+}},{{j\d+}},{{z\d+}}]
- /// CHECK-START-ARM64: long Main.BoolCond_LongVarCst(boolean, long) disassembly (after)
+ /// CHECK-START-ARM64: long Main.$noinline$BoolCond_LongVarCst(boolean, long) disassembly (after)
/// CHECK: Select
/// CHECK-NEXT: cmp
/// CHECK-NEXT: csinc ne
- /// CHECK-START-X86_64: long Main.BoolCond_LongVarCst(boolean, long) disassembly (after)
+ /// CHECK-START-X86_64: long Main.$noinline$BoolCond_LongVarCst(boolean, long) disassembly (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
/// CHECK: cmovnz/neq
- /// CHECK-START-X86: long Main.BoolCond_LongVarCst(boolean, long) disassembly (after)
+ /// CHECK-START-X86: long Main.$noinline$BoolCond_LongVarCst(boolean, long) disassembly (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
/// CHECK: cmovnz/ne
/// CHECK-NEXT: cmovnz/ne
- public static long BoolCond_LongVarCst(boolean cond, long x) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static long $noinline$BoolCond_LongVarCst(boolean cond, long x) {
return cond ? x : 1L;
}
- /// CHECK-START: long Main.BoolCond_LongCstVar(boolean, long) register (after)
+ /// CHECK-START: long Main.$noinline$BoolCond_LongCstVar(boolean, long) register (after)
/// CHECK: Select [{{j\d+}},{{j\d+}},{{z\d+}}]
- /// CHECK-START-ARM64: long Main.BoolCond_LongCstVar(boolean, long) disassembly (after)
+ /// CHECK-START-ARM64: long Main.$noinline$BoolCond_LongCstVar(boolean, long) disassembly (after)
/// CHECK: Select
/// CHECK-NEXT: cmp
/// CHECK-NEXT: csinc eq
- /// CHECK-START-X86_64: long Main.BoolCond_LongCstVar(boolean, long) disassembly (after)
+ /// CHECK-START-X86_64: long Main.$noinline$BoolCond_LongCstVar(boolean, long) disassembly (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
/// CHECK: cmovnz/neq
- /// CHECK-START-X86: long Main.BoolCond_LongCstVar(boolean, long) disassembly (after)
+ /// CHECK-START-X86: long Main.$noinline$BoolCond_LongCstVar(boolean, long) disassembly (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
/// CHECK: cmovnz/ne
/// CHECK-NEXT: cmovnz/ne
- public static long BoolCond_LongCstVar(boolean cond, long y) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static long $noinline$BoolCond_LongCstVar(boolean cond, long y) {
return cond ? 1L : y;
}
- /// CHECK-START: float Main.BoolCond_FloatVarVar(boolean, float, float) register (after)
+ /// CHECK-START: float Main.$noinline$BoolCond_FloatVarVar(boolean, float, float) register (after)
/// CHECK: Select [{{f\d+}},{{f\d+}},{{z\d+}}]
- /// CHECK-START-ARM64: float Main.BoolCond_FloatVarVar(boolean, float, float) disassembly (after)
+ /// CHECK-START-ARM64: float Main.$noinline$BoolCond_FloatVarVar(boolean, float, float) disassembly (after)
/// CHECK: Select
/// CHECK-NEXT: cmp
/// CHECK-NEXT: fcsel ne
- public static float BoolCond_FloatVarVar(boolean cond, float x, float y) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static float $noinline$BoolCond_FloatVarVar(boolean cond, float x, float y) {
return cond ? x : y;
}
- /// CHECK-START: float Main.BoolCond_FloatVarCst(boolean, float) register (after)
+ /// CHECK-START: float Main.$noinline$BoolCond_FloatVarCst(boolean, float) register (after)
/// CHECK: Select [{{f\d+}},{{f\d+}},{{z\d+}}]
- /// CHECK-START-ARM64: float Main.BoolCond_FloatVarCst(boolean, float) disassembly (after)
+ /// CHECK-START-ARM64: float Main.$noinline$BoolCond_FloatVarCst(boolean, float) disassembly (after)
/// CHECK: Select
/// CHECK-NEXT: cmp
/// CHECK-NEXT: fcsel ne
- public static float BoolCond_FloatVarCst(boolean cond, float x) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static float $noinline$BoolCond_FloatVarCst(boolean cond, float x) {
return cond ? x : 1.0f;
}
- /// CHECK-START: float Main.BoolCond_FloatCstVar(boolean, float) register (after)
+ /// CHECK-START: float Main.$noinline$BoolCond_FloatCstVar(boolean, float) register (after)
/// CHECK: Select [{{f\d+}},{{f\d+}},{{z\d+}}]
- /// CHECK-START-ARM64: float Main.BoolCond_FloatCstVar(boolean, float) disassembly (after)
+ /// CHECK-START-ARM64: float Main.$noinline$BoolCond_FloatCstVar(boolean, float) disassembly (after)
/// CHECK: Select
/// CHECK-NEXT: cmp
/// CHECK-NEXT: fcsel ne
- public static float BoolCond_FloatCstVar(boolean cond, float y) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static float $noinline$BoolCond_FloatCstVar(boolean cond, float y) {
return cond ? 1.0f : y;
}
- /// CHECK-START: int Main.IntNonmatCond_IntVarVar(int, int, int, int) register (after)
+ /// CHECK-START: int Main.$noinline$IntNonmatCond_IntVarVar(int, int, int, int) register (after)
/// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
/// CHECK-NEXT: Select [{{i\d+}},{{i\d+}},<<Cond>>]
- /// CHECK-START-ARM64: int Main.IntNonmatCond_IntVarVar(int, int, int, int) disassembly (after)
+ /// CHECK-START-ARM64: int Main.$noinline$IntNonmatCond_IntVarVar(int, int, int, int) disassembly (after)
/// CHECK: Select
/// CHECK-NEXT: cmp
/// CHECK-NEXT: csel le
- /// CHECK-START-X86_64: int Main.IntNonmatCond_IntVarVar(int, int, int, int) disassembly (after)
+ /// CHECK-START-X86_64: int Main.$noinline$IntNonmatCond_IntVarVar(int, int, int, int) disassembly (after)
/// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
/// CHECK-NEXT: Select [{{i\d+}},{{i\d+}},<<Cond>>]
/// CHECK: cmovle/ng
- /// CHECK-START-X86: int Main.IntNonmatCond_IntVarVar(int, int, int, int) disassembly (after)
+ /// CHECK-START-X86: int Main.$noinline$IntNonmatCond_IntVarVar(int, int, int, int) disassembly (after)
/// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
/// CHECK-NEXT: Select [{{i\d+}},{{i\d+}},<<Cond>>]
/// CHECK: cmovle/ng
- public static int IntNonmatCond_IntVarVar(int a, int b, int x, int y) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static int $noinline$IntNonmatCond_IntVarVar(int a, int b, int x, int y) {
return a > b ? x : y;
}
- /// CHECK-START: int Main.IntMatCond_IntVarVar(int, int, int, int) register (after)
+ /// CHECK-START: int Main.$noinline$IntMatCond_IntVarVar(int, int, int, int) register (after)
/// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
/// CHECK-NEXT: <<Sel:i\d+>> Select [{{i\d+}},{{i\d+}},{{z\d+}}]
/// CHECK-NEXT: Add [<<Cond>>,<<Sel>>]
- /// CHECK-START-ARM64: int Main.IntMatCond_IntVarVar(int, int, int, int) disassembly (after)
+ /// CHECK-START-ARM64: int Main.$noinline$IntMatCond_IntVarVar(int, int, int, int) disassembly (after)
/// CHECK: LessThanOrEqual
/// CHECK-NEXT: cmp
/// CHECK-NEXT: cset le
/// CHECK: Select
/// CHECK-NEXT: csel le
- /// CHECK-START-X86_64: int Main.IntMatCond_IntVarVar(int, int, int, int) disassembly (after)
+ /// CHECK-START-X86_64: int Main.$noinline$IntMatCond_IntVarVar(int, int, int, int) disassembly (after)
/// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
/// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
/// CHECK: cmovle/ng
- /// CHECK-START-X86: int Main.IntMatCond_IntVarVar(int, int, int, int) disassembly (after)
+ /// CHECK-START-X86: int Main.$noinline$IntMatCond_IntVarVar(int, int, int, int) disassembly (after)
/// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
/// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
/// CHECK: cmovle/ng
- public static int IntMatCond_IntVarVar(int a, int b, int x, int y) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static int $noinline$IntMatCond_IntVarVar(int a, int b, int x, int y) {
int result = (a > b ? x : y);
return result + (a > b ? 0 : 1);
}
- /// CHECK-START: long Main.IntNonmatCond_LongVarVar(int, int, long, long) register (after)
+ /// CHECK-START: long Main.$noinline$IntNonmatCond_LongVarVar(int, int, long, long) register (after)
/// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
/// CHECK-NEXT: Select [{{j\d+}},{{j\d+}},<<Cond>>]
- /// CHECK-START-ARM64: long Main.IntNonmatCond_LongVarVar(int, int, long, long) disassembly (after)
+ /// CHECK-START-ARM64: long Main.$noinline$IntNonmatCond_LongVarVar(int, int, long, long) disassembly (after)
/// CHECK: Select
/// CHECK-NEXT: cmp
/// CHECK-NEXT: csel le
- /// CHECK-START-X86_64: long Main.IntNonmatCond_LongVarVar(int, int, long, long) disassembly (after)
+ /// CHECK-START-X86_64: long Main.$noinline$IntNonmatCond_LongVarVar(int, int, long, long) disassembly (after)
/// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
/// CHECK-NEXT: Select [{{j\d+}},{{j\d+}},<<Cond>>]
/// CHECK: cmovle/ngq
- /// CHECK-START-X86: long Main.IntNonmatCond_LongVarVar(int, int, long, long) disassembly (after)
+ /// CHECK-START-X86: long Main.$noinline$IntNonmatCond_LongVarVar(int, int, long, long) disassembly (after)
/// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
/// CHECK-NEXT: Select [{{j\d+}},{{j\d+}},<<Cond>>]
/// CHECK: cmovle/ng
/// CHECK-NEXT: cmovle/ng
- public static long IntNonmatCond_LongVarVar(int a, int b, long x, long y) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static long $noinline$IntNonmatCond_LongVarVar(int a, int b, long x, long y) {
return a > b ? x : y;
}
- /// CHECK-START: long Main.IntMatCond_LongVarVar(int, int, long, long) register (after)
+ /// CHECK-START: long Main.$noinline$IntMatCond_LongVarVar(int, int, long, long) register (after)
/// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
/// CHECK: <<Sel1:j\d+>> Select [{{j\d+}},{{j\d+}},<<Cond>>]
/// CHECK: <<Sel2:j\d+>> Select [{{j\d+}},{{j\d+}},<<Cond>>]
/// CHECK: Add [<<Sel2>>,<<Sel1>>]
- /// CHECK-START-ARM64: long Main.IntMatCond_LongVarVar(int, int, long, long) disassembly (after)
+ /// CHECK-START-ARM64: long Main.$noinline$IntMatCond_LongVarVar(int, int, long, long) disassembly (after)
/// CHECK: LessThanOrEqual
/// CHECK-NEXT: cmp
/// CHECK-NEXT: cset le
/// CHECK: Select
/// CHECK-NEXT: csel le
- /// CHECK-START-X86_64: long Main.IntMatCond_LongVarVar(int, int, long, long) disassembly (after)
+ /// CHECK-START-X86_64: long Main.$noinline$IntMatCond_LongVarVar(int, int, long, long) disassembly (after)
/// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
/// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
/// CHECK: cmovle/ngq
/// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
/// CHECK: cmovnz/neq
- /// CHECK-START-X86: long Main.IntMatCond_LongVarVar(int, int, long, long) disassembly (after)
+ /// CHECK-START-X86: long Main.$noinline$IntMatCond_LongVarVar(int, int, long, long) disassembly (after)
/// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
/// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
/// CHECK-NEXT: cmovle/ng
@@ -340,34 +290,26 @@
/// CHECK: cmovnz/ne
/// CHECK-NEXT: cmovnz/ne
- public static long IntMatCond_LongVarVar(int a, int b, long x, long y) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static long $noinline$IntMatCond_LongVarVar(int a, int b, long x, long y) {
long result = (a > b ? x : y);
return result + (a > b ? 0L : 1L);
}
- /// CHECK-START: long Main.LongNonmatCond_LongVarVar(long, long, long, long) register (after)
+ /// CHECK-START: long Main.$noinline$LongNonmatCond_LongVarVar(long, long, long, long) register (after)
/// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{j\d+}},{{j\d+}}]
/// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
- /// CHECK-START-ARM64: long Main.LongNonmatCond_LongVarVar(long, long, long, long) disassembly (after)
+ /// CHECK-START-ARM64: long Main.$noinline$LongNonmatCond_LongVarVar(long, long, long, long) disassembly (after)
/// CHECK: Select
/// CHECK-NEXT: cmp
/// CHECK-NEXT: csel le
- /// CHECK-START-X86_64: long Main.LongNonmatCond_LongVarVar(long, long, long, long) disassembly (after)
+ /// CHECK-START-X86_64: long Main.$noinline$LongNonmatCond_LongVarVar(long, long, long, long) disassembly (after)
/// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{j\d+}},{{j\d+}}]
/// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
/// CHECK: cmovle/ngq
- public static long LongNonmatCond_LongVarVar(long a, long b, long x, long y) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static long $noinline$LongNonmatCond_LongVarVar(long a, long b, long x, long y) {
return a > b ? x : y;
}
@@ -454,205 +396,169 @@
return a < 0 ? x : y;
}
- /// CHECK-START: long Main.LongMatCond_LongVarVar(long, long, long, long) register (after)
+ /// CHECK-START: long Main.$noinline$LongMatCond_LongVarVar(long, long, long, long) register (after)
/// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{j\d+}},{{j\d+}}]
/// CHECK: <<Sel1:j\d+>> Select [{{j\d+}},{{j\d+}},<<Cond>>]
/// CHECK: <<Sel2:j\d+>> Select [{{j\d+}},{{j\d+}},<<Cond>>]
/// CHECK: Add [<<Sel2>>,<<Sel1>>]
- /// CHECK-START-ARM64: long Main.LongMatCond_LongVarVar(long, long, long, long) disassembly (after)
+ /// CHECK-START-ARM64: long Main.$noinline$LongMatCond_LongVarVar(long, long, long, long) disassembly (after)
/// CHECK: LessThanOrEqual
/// CHECK-NEXT: cmp
/// CHECK-NEXT: cset le
/// CHECK: Select
/// CHECK-NEXT: csel le
- /// CHECK-START-X86_64: long Main.LongMatCond_LongVarVar(long, long, long, long) disassembly (after)
+ /// CHECK-START-X86_64: long Main.$noinline$LongMatCond_LongVarVar(long, long, long, long) disassembly (after)
/// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{j\d+}},{{j\d+}}]
/// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
/// CHECK: cmovle/ngq
/// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
/// CHECK: cmovnz/neq
- public static long LongMatCond_LongVarVar(long a, long b, long x, long y) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static long $noinline$LongMatCond_LongVarVar(long a, long b, long x, long y) {
long result = (a > b ? x : y);
return result + (a > b ? 0L : 1L);
}
- /// CHECK-START: int Main.FloatLtNonmatCond_IntVarVar(float, float, int, int) register (after)
+ /// CHECK-START: int Main.$noinline$FloatLtNonmatCond_IntVarVar(float, float, int, int) register (after)
/// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{f\d+}},{{f\d+}}]
/// CHECK-NEXT: Select [{{i\d+}},{{i\d+}},<<Cond>>]
- /// CHECK-START-ARM64: int Main.FloatLtNonmatCond_IntVarVar(float, float, int, int) disassembly (after)
+ /// CHECK-START-ARM64: int Main.$noinline$FloatLtNonmatCond_IntVarVar(float, float, int, int) disassembly (after)
/// CHECK: LessThanOrEqual
/// CHECK: Select
/// CHECK-NEXT: fcmp
/// CHECK-NEXT: csel le
- public static int FloatLtNonmatCond_IntVarVar(float a, float b, int x, int y) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static int $noinline$FloatLtNonmatCond_IntVarVar(float a, float b, int x, int y) {
return a > b ? x : y;
}
- /// CHECK-START: int Main.FloatGtNonmatCond_IntVarVar(float, float, int, int) register (after)
+ /// CHECK-START: int Main.$noinline$FloatGtNonmatCond_IntVarVar(float, float, int, int) register (after)
/// CHECK: <<Cond:z\d+>> GreaterThanOrEqual [{{f\d+}},{{f\d+}}]
/// CHECK-NEXT: Select [{{i\d+}},{{i\d+}},<<Cond>>]
- /// CHECK-START-ARM64: int Main.FloatGtNonmatCond_IntVarVar(float, float, int, int) disassembly (after)
+ /// CHECK-START-ARM64: int Main.$noinline$FloatGtNonmatCond_IntVarVar(float, float, int, int) disassembly (after)
/// CHECK: GreaterThanOrEqual
/// CHECK: Select
/// CHECK-NEXT: fcmp
/// CHECK-NEXT: csel hs
- public static int FloatGtNonmatCond_IntVarVar(float a, float b, int x, int y) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static int $noinline$FloatGtNonmatCond_IntVarVar(float a, float b, int x, int y) {
return a < b ? x : y;
}
- /// CHECK-START: float Main.FloatGtNonmatCond_FloatVarVar(float, float, float, float) register (after)
+ /// CHECK-START: float Main.$noinline$FloatGtNonmatCond_FloatVarVar(float, float, float, float) register (after)
/// CHECK: <<Cond:z\d+>> GreaterThanOrEqual [{{f\d+}},{{f\d+}}]
/// CHECK-NEXT: Select [{{f\d+}},{{f\d+}},<<Cond>>]
- /// CHECK-START-ARM64: float Main.FloatGtNonmatCond_FloatVarVar(float, float, float, float) disassembly (after)
+ /// CHECK-START-ARM64: float Main.$noinline$FloatGtNonmatCond_FloatVarVar(float, float, float, float) disassembly (after)
/// CHECK: GreaterThanOrEqual
/// CHECK: Select
/// CHECK-NEXT: fcmp
/// CHECK-NEXT: fcsel hs
- public static float FloatGtNonmatCond_FloatVarVar(float a, float b, float x, float y) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static float $noinline$FloatGtNonmatCond_FloatVarVar(float a, float b, float x, float y) {
return a < b ? x : y;
}
- /// CHECK-START: int Main.FloatLtMatCond_IntVarVar(float, float, int, int) register (after)
+ /// CHECK-START: int Main.$noinline$FloatLtMatCond_IntVarVar(float, float, int, int) register (after)
/// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{f\d+}},{{f\d+}}]
/// CHECK-NEXT: <<Sel:i\d+>> Select [{{i\d+}},{{i\d+}},<<Cond>>]
/// CHECK-NEXT: Add [<<Cond>>,<<Sel>>]
- /// CHECK-START-ARM64: int Main.FloatLtMatCond_IntVarVar(float, float, int, int) disassembly (after)
+ /// CHECK-START-ARM64: int Main.$noinline$FloatLtMatCond_IntVarVar(float, float, int, int) disassembly (after)
/// CHECK: LessThanOrEqual
/// CHECK-NEXT: fcmp
/// CHECK-NEXT: cset le
/// CHECK: Select
/// CHECK-NEXT: csel le
- public static int FloatLtMatCond_IntVarVar(float a, float b, int x, int y) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static int $noinline$FloatLtMatCond_IntVarVar(float a, float b, int x, int y) {
int result = (a > b ? x : y);
return result + (a > b ? 0 : 1);
}
- /// CHECK-START: int Main.FloatGtMatCond_IntVarVar(float, float, int, int) register (after)
+ /// CHECK-START: int Main.$noinline$FloatGtMatCond_IntVarVar(float, float, int, int) register (after)
/// CHECK: <<Cond:z\d+>> GreaterThanOrEqual [{{f\d+}},{{f\d+}}]
/// CHECK-NEXT: <<Sel:i\d+>> Select [{{i\d+}},{{i\d+}},<<Cond>>]
/// CHECK-NEXT: Add [<<Cond>>,<<Sel>>]
- /// CHECK-START-ARM64: int Main.FloatGtMatCond_IntVarVar(float, float, int, int) disassembly (after)
+ /// CHECK-START-ARM64: int Main.$noinline$FloatGtMatCond_IntVarVar(float, float, int, int) disassembly (after)
/// CHECK: GreaterThanOrEqual
/// CHECK-NEXT: fcmp
/// CHECK-NEXT: cset hs
/// CHECK: Select
/// CHECK-NEXT: csel hs
- public static int FloatGtMatCond_IntVarVar(float a, float b, int x, int y) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static int $noinline$FloatGtMatCond_IntVarVar(float a, float b, int x, int y) {
int result = (a < b ? x : y);
return result + (a < b ? 0 : 1);
}
- /// CHECK-START: float Main.FloatGtMatCond_FloatVarVar(float, float, float, float) register (after)
+ /// CHECK-START: float Main.$noinline$FloatGtMatCond_FloatVarVar(float, float, float, float) register (after)
/// CHECK: <<Cond:z\d+>> GreaterThanOrEqual
/// CHECK-NEXT: <<Sel:f\d+>> Select [{{f\d+}},{{f\d+}},<<Cond>>]
/// CHECK-NEXT: TypeConversion [<<Cond>>]
- /// CHECK-START-ARM64: float Main.FloatGtMatCond_FloatVarVar(float, float, float, float) disassembly (after)
+ /// CHECK-START-ARM64: float Main.$noinline$FloatGtMatCond_FloatVarVar(float, float, float, float) disassembly (after)
/// CHECK: GreaterThanOrEqual
/// CHECK-NEXT: fcmp
/// CHECK-NEXT: cset hs
/// CHECK: Select
/// CHECK-NEXT: fcsel hs
- public static float FloatGtMatCond_FloatVarVar(float a, float b, float x, float y) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static float $noinline$FloatGtMatCond_FloatVarVar(float a, float b, float x, float y) {
float result = (a < b ? x : y);
return result + (a < b ? 0 : 1);
}
- /// CHECK-START: int Main.BoolCond_0_m1(boolean) register (after)
+ /// CHECK-START: int Main.$noinline$BoolCond_0_m1(boolean) register (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
- /// CHECK-START-ARM64: int Main.BoolCond_0_m1(boolean) disassembly (after)
+ /// CHECK-START-ARM64: int Main.$noinline$BoolCond_0_m1(boolean) disassembly (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
/// CHECK-NEXT: cmp {{w\d+}}, #0x0 (0)
/// CHECK-NEXT: csetm {{w\d+}}, eq
- /// CHECK-START-X86_64: int Main.BoolCond_0_m1(boolean) disassembly (after)
+ /// CHECK-START-X86_64: int Main.$noinline$BoolCond_0_m1(boolean) disassembly (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
/// CHECK: cmovnz/ne
- /// CHECK-START-X86: int Main.BoolCond_0_m1(boolean) disassembly (after)
+ /// CHECK-START-X86: int Main.$noinline$BoolCond_0_m1(boolean) disassembly (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
/// CHECK: cmovnz/ne
- public static int BoolCond_0_m1(boolean cond) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static int $noinline$BoolCond_0_m1(boolean cond) {
return cond ? 0 : -1;
}
- /// CHECK-START: int Main.BoolCond_m1_0(boolean) register (after)
+ /// CHECK-START: int Main.$noinline$BoolCond_m1_0(boolean) register (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
- /// CHECK-START-ARM64: int Main.BoolCond_m1_0(boolean) disassembly (after)
+ /// CHECK-START-ARM64: int Main.$noinline$BoolCond_m1_0(boolean) disassembly (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
/// CHECK-NEXT: cmp {{w\d+}}, #0x0 (0)
/// CHECK-NEXT: csetm {{w\d+}}, ne
- /// CHECK-START-X86_64: int Main.BoolCond_m1_0(boolean) disassembly (after)
+ /// CHECK-START-X86_64: int Main.$noinline$BoolCond_m1_0(boolean) disassembly (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
/// CHECK: cmovnz/ne
- /// CHECK-START-X86: int Main.BoolCond_m1_0(boolean) disassembly (after)
+ /// CHECK-START-X86: int Main.$noinline$BoolCond_m1_0(boolean) disassembly (after)
/// CHECK: <<Cond:z\d+>> ParameterValue
/// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
/// CHECK: cmovnz/ne
- public static int BoolCond_m1_0(boolean cond) {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ public static int $noinline$BoolCond_m1_0(boolean cond) {
return cond ? -1 : 0;
}
@@ -669,46 +575,58 @@
}
public static void main(String[] args) {
- assertEqual(5, BoolCond_IntVarVar(true, 5, 7));
- assertEqual(7, BoolCond_IntVarVar(false, 5, 7));
- assertEqual(5, BoolCond_IntVarCst(true, 5));
- assertEqual(1, BoolCond_IntVarCst(false, 5));
- assertEqual(1, BoolCond_IntCstVar(true, 7));
- assertEqual(7, BoolCond_IntCstVar(false, 7));
+ assertEqual(5, $noinline$BoolCond_IntVarVar(true, 5, 7));
+ assertEqual(7, $noinline$BoolCond_IntVarVar(false, 5, 7));
+ assertEqual(5, $noinline$BoolCond_IntVarCst(true, 5));
+ assertEqual(1, $noinline$BoolCond_IntVarCst(false, 5));
+ assertEqual(1, $noinline$BoolCond_IntCstVar(true, 7));
+ assertEqual(7, $noinline$BoolCond_IntCstVar(false, 7));
- assertEqual(5L, BoolCond_LongVarVar(true, 5L, 7L));
- assertEqual(7L, BoolCond_LongVarVar(false, 5L, 7L));
- assertEqual(5L, BoolCond_LongVarCst(true, 5L));
- assertEqual(1L, BoolCond_LongVarCst(false, 5L));
- assertEqual(1L, BoolCond_LongCstVar(true, 7L));
- assertEqual(7L, BoolCond_LongCstVar(false, 7L));
+ assertEqual(5L, $noinline$BoolCond_LongVarVar(true, 5L, 7L));
+ assertEqual(7L, $noinline$BoolCond_LongVarVar(false, 5L, 7L));
+ assertEqual(5L, $noinline$BoolCond_LongVarCst(true, 5L));
+ assertEqual(1L, $noinline$BoolCond_LongVarCst(false, 5L));
+ assertEqual(1L, $noinline$BoolCond_LongCstVar(true, 7L));
+ assertEqual(7L, $noinline$BoolCond_LongCstVar(false, 7L));
- assertEqual(5, BoolCond_FloatVarVar(true, 5, 7));
- assertEqual(7, BoolCond_FloatVarVar(false, 5, 7));
- assertEqual(5, BoolCond_FloatVarCst(true, 5));
- assertEqual(1, BoolCond_FloatVarCst(false, 5));
- assertEqual(1, BoolCond_FloatCstVar(true, 7));
- assertEqual(7, BoolCond_FloatCstVar(false, 7));
+ assertEqual(5, $noinline$BoolCond_FloatVarVar(true, 5, 7));
+ assertEqual(7, $noinline$BoolCond_FloatVarVar(false, 5, 7));
+ assertEqual(5, $noinline$BoolCond_FloatVarCst(true, 5));
+ assertEqual(1, $noinline$BoolCond_FloatVarCst(false, 5));
+ assertEqual(1, $noinline$BoolCond_FloatCstVar(true, 7));
+ assertEqual(7, $noinline$BoolCond_FloatCstVar(false, 7));
- assertEqual(5, IntNonmatCond_IntVarVar(3, 2, 5, 7));
- assertEqual(7, IntNonmatCond_IntVarVar(2, 3, 5, 7));
- assertEqual(5, IntMatCond_IntVarVar(3, 2, 5, 7));
- assertEqual(8, IntMatCond_IntVarVar(2, 3, 5, 7));
+ assertEqual(5, $noinline$IntNonmatCond_IntVarVar(3, 2, 5, 7));
+ assertEqual(7, $noinline$IntNonmatCond_IntVarVar(2, 3, 5, 7));
+ assertEqual(5, $noinline$IntMatCond_IntVarVar(3, 2, 5, 7));
+ assertEqual(8, $noinline$IntMatCond_IntVarVar(2, 3, 5, 7));
+ assertEqual(5, $noinline$IntNonmatCond_LongVarVar(3, 2, 5L, 7L));
+ assertEqual(7, $noinline$IntNonmatCond_LongVarVar(2, 3, 5L, 7L));
+ assertEqual(5, $noinline$IntMatCond_LongVarVar(3, 2, 5L, 7L));
+ assertEqual(8, $noinline$IntMatCond_LongVarVar(2, 3, 5L, 7L));
+ assertEqual(5, $noinline$LongMatCond_LongVarVar(3L, 2L, 5L, 7L));
+ assertEqual(8, $noinline$LongMatCond_LongVarVar(2L, 3L, 5L, 7L));
- assertEqual(0xAAAAAAAA55555555L,
- LongNonmatCond_LongVarVar(3L, 2L, 0xAAAAAAAA55555555L, 0x8888888877777777L));
- assertEqual(0x8888888877777777L,
- LongNonmatCond_LongVarVar(2L, 2L, 0xAAAAAAAA55555555L, 0x8888888877777777L));
- assertEqual(0x8888888877777777L,
- LongNonmatCond_LongVarVar(2L, 3L, 0xAAAAAAAA55555555L, 0x8888888877777777L));
- assertEqual(0xAAAAAAAA55555555L, LongNonmatCond_LongVarVar(0x0000000100000000L,
- 0x00000000FFFFFFFFL,
- 0xAAAAAAAA55555555L,
- 0x8888888877777777L));
- assertEqual(0x8888888877777777L, LongNonmatCond_LongVarVar(0x00000000FFFFFFFFL,
- 0x0000000100000000L,
- 0xAAAAAAAA55555555L,
- 0x8888888877777777L));
+ assertEqual(0xAAAAAAAA55555555L, $noinline$LongNonmatCond_LongVarVar(3L,
+ 2L,
+ 0xAAAAAAAA55555555L,
+ 0x8888888877777777L));
+ assertEqual(0x8888888877777777L, $noinline$LongNonmatCond_LongVarVar(2L,
+ 2L,
+ 0xAAAAAAAA55555555L,
+ 0x8888888877777777L));
+ assertEqual(0x8888888877777777L, $noinline$LongNonmatCond_LongVarVar(2L,
+ 3L,
+ 0xAAAAAAAA55555555L,
+ 0x8888888877777777L));
+ assertEqual(0xAAAAAAAA55555555L, $noinline$LongNonmatCond_LongVarVar(0x0000000100000000L,
+ 0x00000000FFFFFFFFL,
+ 0xAAAAAAAA55555555L,
+ 0x8888888877777777L));
+ assertEqual(0x8888888877777777L, $noinline$LongNonmatCond_LongVarVar(0x00000000FFFFFFFFL,
+ 0x0000000100000000L,
+ 0xAAAAAAAA55555555L,
+ 0x8888888877777777L));
assertEqual(0x8888888877777777L, $noinline$LongEqNonmatCond_LongVarVar(2L,
3L,
@@ -759,39 +677,39 @@
assertEqual(7L, $noinline$LongNonmatCondCst_LongVarVar7(2L, 5L, 7L));
assertEqual(5L, $noinline$LongNonmatCondCst_LongVarVar7(-9000L, 5L, 7L));
- assertEqual(5, FloatLtNonmatCond_IntVarVar(3, 2, 5, 7));
- assertEqual(7, FloatLtNonmatCond_IntVarVar(2, 3, 5, 7));
- assertEqual(7, FloatLtNonmatCond_IntVarVar(Float.NaN, 2, 5, 7));
- assertEqual(7, FloatLtNonmatCond_IntVarVar(2, Float.NaN, 5, 7));
+ assertEqual(5, $noinline$FloatLtNonmatCond_IntVarVar(3, 2, 5, 7));
+ assertEqual(7, $noinline$FloatLtNonmatCond_IntVarVar(2, 3, 5, 7));
+ assertEqual(7, $noinline$FloatLtNonmatCond_IntVarVar(Float.NaN, 2, 5, 7));
+ assertEqual(7, $noinline$FloatLtNonmatCond_IntVarVar(2, Float.NaN, 5, 7));
- assertEqual(5, FloatGtNonmatCond_IntVarVar(2, 3, 5, 7));
- assertEqual(7, FloatGtNonmatCond_IntVarVar(3, 2, 5, 7));
- assertEqual(7, FloatGtNonmatCond_IntVarVar(Float.NaN, 2, 5, 7));
- assertEqual(7, FloatGtNonmatCond_IntVarVar(2, Float.NaN, 5, 7));
+ assertEqual(5, $noinline$FloatGtNonmatCond_IntVarVar(2, 3, 5, 7));
+ assertEqual(7, $noinline$FloatGtNonmatCond_IntVarVar(3, 2, 5, 7));
+ assertEqual(7, $noinline$FloatGtNonmatCond_IntVarVar(Float.NaN, 2, 5, 7));
+ assertEqual(7, $noinline$FloatGtNonmatCond_IntVarVar(2, Float.NaN, 5, 7));
- assertEqual(5, FloatGtNonmatCond_FloatVarVar(2, 3, 5, 7));
- assertEqual(7, FloatGtNonmatCond_FloatVarVar(3, 2, 5, 7));
- assertEqual(7, FloatGtNonmatCond_FloatVarVar(Float.NaN, 2, 5, 7));
- assertEqual(7, FloatGtNonmatCond_FloatVarVar(2, Float.NaN, 5, 7));
+ assertEqual(5, $noinline$FloatGtNonmatCond_FloatVarVar(2, 3, 5, 7));
+ assertEqual(7, $noinline$FloatGtNonmatCond_FloatVarVar(3, 2, 5, 7));
+ assertEqual(7, $noinline$FloatGtNonmatCond_FloatVarVar(Float.NaN, 2, 5, 7));
+ assertEqual(7, $noinline$FloatGtNonmatCond_FloatVarVar(2, Float.NaN, 5, 7));
- assertEqual(5, FloatLtMatCond_IntVarVar(3, 2, 5, 7));
- assertEqual(8, FloatLtMatCond_IntVarVar(2, 3, 5, 7));
- assertEqual(8, FloatLtMatCond_IntVarVar(Float.NaN, 2, 5, 7));
- assertEqual(8, FloatLtMatCond_IntVarVar(2, Float.NaN, 5, 7));
+ assertEqual(5, $noinline$FloatLtMatCond_IntVarVar(3, 2, 5, 7));
+ assertEqual(8, $noinline$FloatLtMatCond_IntVarVar(2, 3, 5, 7));
+ assertEqual(8, $noinline$FloatLtMatCond_IntVarVar(Float.NaN, 2, 5, 7));
+ assertEqual(8, $noinline$FloatLtMatCond_IntVarVar(2, Float.NaN, 5, 7));
- assertEqual(5, FloatGtMatCond_IntVarVar(2, 3, 5, 7));
- assertEqual(8, FloatGtMatCond_IntVarVar(3, 2, 5, 7));
- assertEqual(8, FloatGtMatCond_IntVarVar(Float.NaN, 2, 5, 7));
- assertEqual(8, FloatGtMatCond_IntVarVar(2, Float.NaN, 5, 7));
+ assertEqual(5, $noinline$FloatGtMatCond_IntVarVar(2, 3, 5, 7));
+ assertEqual(8, $noinline$FloatGtMatCond_IntVarVar(3, 2, 5, 7));
+ assertEqual(8, $noinline$FloatGtMatCond_IntVarVar(Float.NaN, 2, 5, 7));
+ assertEqual(8, $noinline$FloatGtMatCond_IntVarVar(2, Float.NaN, 5, 7));
- assertEqual(5, FloatGtMatCond_FloatVarVar(2, 3, 5, 7));
- assertEqual(8, FloatGtMatCond_FloatVarVar(3, 2, 5, 7));
- assertEqual(8, FloatGtMatCond_FloatVarVar(Float.NaN, 2, 5, 7));
- assertEqual(8, FloatGtMatCond_FloatVarVar(2, Float.NaN, 5, 7));
+ assertEqual(5, $noinline$FloatGtMatCond_FloatVarVar(2, 3, 5, 7));
+ assertEqual(8, $noinline$FloatGtMatCond_FloatVarVar(3, 2, 5, 7));
+ assertEqual(8, $noinline$FloatGtMatCond_FloatVarVar(Float.NaN, 2, 5, 7));
+ assertEqual(8, $noinline$FloatGtMatCond_FloatVarVar(2, Float.NaN, 5, 7));
- assertEqual(0, BoolCond_0_m1(true));
- assertEqual(-1, BoolCond_0_m1(false));
- assertEqual(-1, BoolCond_m1_0(true));
- assertEqual(0, BoolCond_m1_0(false));
+ assertEqual(0, $noinline$BoolCond_0_m1(true));
+ assertEqual(-1, $noinline$BoolCond_0_m1(false));
+ assertEqual(-1, $noinline$BoolCond_m1_0(true));
+ assertEqual(0, $noinline$BoolCond_m1_0(false));
}
}
