summaryrefslogtreecommitdiff
path: root/test/411-optimizing-arith/src
diff options
context:
space:
mode:
Diffstat (limited to 'test/411-optimizing-arith/src')
-rw-r--r--test/411-optimizing-arith/src/DivTest.java250
-rw-r--r--test/411-optimizing-arith/src/Main.java26
-rw-r--r--test/411-optimizing-arith/src/MulTest.java180
-rw-r--r--test/411-optimizing-arith/src/NegTest.java197
-rw-r--r--test/411-optimizing-arith/src/RemTest.java157
-rw-r--r--test/411-optimizing-arith/src/ShiftsTest.java330
-rw-r--r--test/411-optimizing-arith/src/SubTest.java170
7 files changed, 1310 insertions, 0 deletions
diff --git a/test/411-optimizing-arith/src/DivTest.java b/test/411-optimizing-arith/src/DivTest.java
new file mode 100644
index 0000000000..7696d0a806
--- /dev/null
+++ b/test/411-optimizing-arith/src/DivTest.java
@@ -0,0 +1,250 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Note that $opt$ is a marker for the optimizing compiler to test
+// it does compile the method.
+public class DivTest {
+
+ public static void expectEquals(int expected, int result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void expectEquals(long expected, long result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void expectEquals(float expected, float result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void expectEquals(double expected, double result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void expectApproxEquals(float a, float b) {
+ float maxDelta = 0.00001F;
+ boolean aproxEquals = (a > b) ? ((a - b) < maxDelta) : ((b - a) < maxDelta);
+ if (!aproxEquals) {
+ throw new Error("Expected: " + a + ", found: " + b
+ + ", with delta: " + maxDelta + " " + (a - b));
+ }
+ }
+
+ public static void expectApproxEquals(double a, double b) {
+ double maxDelta = 0.00001D;
+ boolean aproxEquals = (a > b) ? ((a - b) < maxDelta) : ((b - a) < maxDelta);
+ if (!aproxEquals) {
+ throw new Error("Expected: " + a + ", found: "
+ + b + ", with delta: " + maxDelta + " " + (a - b));
+ }
+ }
+
+ public static void expectNaN(float a) {
+ if (a == a) {
+ throw new Error("Expected NaN: " + a);
+ }
+ }
+
+ public static void expectNaN(double a) {
+ if (a == a) {
+ throw new Error("Expected NaN: " + a);
+ }
+ }
+
+ public static void expectDivisionByZero(int value) {
+ try {
+ $opt$Div(value, 0);
+ throw new Error("Expected RuntimeException when dividing by 0");
+ } catch (java.lang.RuntimeException e) {
+ }
+ try {
+ $opt$DivZero(value);
+ throw new Error("Expected RuntimeException when dividing by 0");
+ } catch (java.lang.RuntimeException e) {
+ }
+ }
+
+ public static void expectDivisionByZero(long value) {
+ try {
+ $opt$Div(value, 0L);
+ throw new Error("Expected RuntimeException when dividing by 0");
+ } catch (java.lang.RuntimeException e) {
+ }
+ try {
+ $opt$DivZero(value);
+ throw new Error("Expected RuntimeException when dividing by 0");
+ } catch (java.lang.RuntimeException e) {
+ }
+ }
+
+ public static void main() {
+ divInt();
+ divLong();
+ divFloat();
+ divDouble();
+ }
+
+ private static void divInt() {
+ expectEquals(2, $opt$DivConst(6));
+ expectEquals(2, $opt$Div(6, 3));
+ expectEquals(6, $opt$Div(6, 1));
+ expectEquals(-2, $opt$Div(6, -3));
+ expectEquals(1, $opt$Div(4, 3));
+ expectEquals(-1, $opt$Div(4, -3));
+ expectEquals(5, $opt$Div(23, 4));
+ expectEquals(-5, $opt$Div(-23, 4));
+
+ expectEquals(-Integer.MAX_VALUE, $opt$Div(Integer.MAX_VALUE, -1));
+ expectEquals(Integer.MIN_VALUE, $opt$Div(Integer.MIN_VALUE, -1)); // overflow
+ expectEquals(-1073741824, $opt$Div(Integer.MIN_VALUE, 2));
+
+ expectEquals(0, $opt$Div(0, Integer.MAX_VALUE));
+ expectEquals(0, $opt$Div(0, Integer.MIN_VALUE));
+
+ expectDivisionByZero(0);
+ expectDivisionByZero(1);
+ expectDivisionByZero(Integer.MAX_VALUE);
+ expectDivisionByZero(Integer.MIN_VALUE);
+ }
+
+ private static void divLong() {
+ expectEquals(2L, $opt$DivConst(6L));
+ expectEquals(2L, $opt$Div(6L, 3L));
+ expectEquals(6L, $opt$Div(6L, 1L));
+ expectEquals(-2L, $opt$Div(6L, -3L));
+ expectEquals(1L, $opt$Div(4L, 3L));
+ expectEquals(-1L, $opt$Div(4L, -3L));
+ expectEquals(5L, $opt$Div(23L, 4L));
+ expectEquals(-5L, $opt$Div(-23L, 4L));
+
+ expectEquals(-Integer.MAX_VALUE, $opt$Div(Integer.MAX_VALUE, -1L));
+ expectEquals(2147483648L, $opt$Div(Integer.MIN_VALUE, -1L));
+ expectEquals(-1073741824L, $opt$Div(Integer.MIN_VALUE, 2L));
+
+ expectEquals(-Long.MAX_VALUE, $opt$Div(Long.MAX_VALUE, -1L));
+ expectEquals(Long.MIN_VALUE, $opt$Div(Long.MIN_VALUE, -1L)); // overflow
+
+ expectEquals(11111111111111L, $opt$Div(33333333333333L, 3L));
+ expectEquals(3L, $opt$Div(33333333333333L, 11111111111111L));
+
+ expectEquals(0L, $opt$Div(0L, Long.MAX_VALUE));
+ expectEquals(0L, $opt$Div(0L, Long.MIN_VALUE));
+
+ expectDivisionByZero(0L);
+ expectDivisionByZero(1L);
+ expectDivisionByZero(Long.MAX_VALUE);
+ expectDivisionByZero(Long.MIN_VALUE);
+ }
+
+ private static void divFloat() {
+ expectApproxEquals(1.6666666F, $opt$Div(5F, 3F));
+ expectApproxEquals(0F, $opt$Div(0F, 3F));
+ expectApproxEquals(-0.3333333F, $opt$Div(1F, -3F));
+ expectApproxEquals(4F, $opt$Div(-12F, -3F));
+ expectApproxEquals(0.5, $opt$Div(0.1F, 0.2F));
+ expectApproxEquals(-2.5F, $opt$Div(-0.5F, 0.2F));
+
+ expectEquals(0F, $opt$Div(0F, Float.POSITIVE_INFINITY));
+ expectEquals(0F, $opt$Div(11F, Float.POSITIVE_INFINITY));
+ expectEquals(0F, $opt$Div(0F, Float.NEGATIVE_INFINITY));
+ expectEquals(0F, $opt$Div(11F, Float.NEGATIVE_INFINITY));
+
+ expectNaN($opt$Div(0F, 0F));
+ expectNaN($opt$Div(Float.NaN, 11F));
+ expectNaN($opt$Div(-11F, Float.NaN));
+ expectNaN($opt$Div(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY));
+ expectNaN($opt$Div(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY));
+ expectNaN($opt$Div(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY));
+ expectNaN($opt$Div(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY));
+ expectNaN($opt$Div(Float.NaN, Float.NEGATIVE_INFINITY));
+ expectNaN($opt$Div(Float.POSITIVE_INFINITY, Float.NaN));
+
+ expectEquals(Float.POSITIVE_INFINITY, $opt$Div(3F, 0F));
+ expectEquals(Float.NEGATIVE_INFINITY, $opt$Div(-3F, 0F));
+ expectEquals(Float.POSITIVE_INFINITY, $opt$Div(Float.MAX_VALUE, Float.MIN_VALUE));
+ expectEquals(Float.NEGATIVE_INFINITY, $opt$Div(-Float.MAX_VALUE, Float.MIN_VALUE));
+ }
+
+ private static void divDouble() {
+ expectApproxEquals(1.6666666D, $opt$Div(5D, 3D));
+ expectApproxEquals(0D, $opt$Div(0D, 3D));
+ expectApproxEquals(-0.3333333D, $opt$Div(1D, -3D));
+ expectApproxEquals(4D, $opt$Div(-12D, -3D));
+ expectApproxEquals(0.5, $opt$Div(0.1D, 0.2D));
+ expectApproxEquals(-2.5D, $opt$Div(-0.5D, 0.2D));
+
+ expectEquals(0D, $opt$Div(0D, Float.POSITIVE_INFINITY));
+ expectEquals(0D, $opt$Div(11D, Float.POSITIVE_INFINITY));
+ expectEquals(0D, $opt$Div(0D, Float.NEGATIVE_INFINITY));
+ expectEquals(0D, $opt$Div(11D, Float.NEGATIVE_INFINITY));
+
+ expectNaN($opt$Div(0D, 0D));
+ expectNaN($opt$Div(Float.NaN, 11D));
+ expectNaN($opt$Div(-11D, Float.NaN));
+ expectNaN($opt$Div(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY));
+ expectNaN($opt$Div(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY));
+ expectNaN($opt$Div(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY));
+ expectNaN($opt$Div(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY));
+ expectNaN($opt$Div(Float.NaN, Float.NEGATIVE_INFINITY));
+ expectNaN($opt$Div(Float.POSITIVE_INFINITY, Float.NaN));
+
+ expectEquals(Float.POSITIVE_INFINITY, $opt$Div(3D, 0D));
+ expectEquals(Float.NEGATIVE_INFINITY, $opt$Div(-3D, 0D));
+ expectEquals(Float.POSITIVE_INFINITY, $opt$Div(Float.MAX_VALUE, Float.MIN_VALUE));
+ expectEquals(Float.NEGATIVE_INFINITY, $opt$Div(-Float.MAX_VALUE, Float.MIN_VALUE));
+ }
+
+ static int $opt$Div(int a, int b) {
+ return a / b;
+ }
+
+ static int $opt$DivZero(int a) {
+ return a / 0;
+ }
+
+ // Division by literals != 0 should not generate checks.
+ static int $opt$DivConst(int a) {
+ return a / 3;
+ }
+
+ static long $opt$DivConst(long a) {
+ return a / 3L;
+ }
+
+ static long $opt$Div(long a, long b) {
+ return a / b;
+ }
+
+ static long $opt$DivZero(long a) {
+ return a / 0L;
+ }
+
+ static float $opt$Div(float a, float b) {
+ return a / b;
+ }
+
+ static double $opt$Div(double a, double b) {
+ return a / b;
+ }
+}
diff --git a/test/411-optimizing-arith/src/Main.java b/test/411-optimizing-arith/src/Main.java
new file mode 100644
index 0000000000..e1a43d3b57
--- /dev/null
+++ b/test/411-optimizing-arith/src/Main.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+public class Main {
+ public static void main(String args[]) {
+ MulTest.main();
+ SubTest.main();
+ NegTest.main();
+ DivTest.main();
+ RemTest.main();
+ ShiftsTest.main();
+ }
+}
diff --git a/test/411-optimizing-arith/src/MulTest.java b/test/411-optimizing-arith/src/MulTest.java
new file mode 100644
index 0000000000..b9bffca0d1
--- /dev/null
+++ b/test/411-optimizing-arith/src/MulTest.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Note that $opt$ is a marker for the optimizing compiler to test
+// it does compile the method.
+public class MulTest {
+
+ public static void expectEquals(int expected, int result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void expectEquals(long expected, long result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void expectEquals(float expected, float result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void expectEquals(double expected, double result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void expectApproxEquals(float a, float b, float maxDelta) {
+ boolean aproxEquals = (a > b)
+ ? ((a - b) < maxDelta)
+ : ((b - a) < maxDelta);
+ if (!aproxEquals) {
+ throw new Error("Expected: " + a + ", found: " + b + ", with delta: " + maxDelta);
+ }
+ }
+
+ public static void expectApproxEquals(double a, double b, double maxDelta) {
+ boolean aproxEquals = (a > b)
+ ? ((a - b) < maxDelta)
+ : ((b - a) < maxDelta);
+ if (!aproxEquals) {
+ throw new Error("Expected: " + a + ", found: " + b + ", with delta: " + maxDelta);
+ }
+ }
+
+ public static void expectNaN(float a) {
+ if (a == a) {
+ throw new Error("Expected NaN: " + a);
+ }
+ }
+
+ public static void expectNaN(double a) {
+ if (a == a) {
+ throw new Error("Expected NaN: " + a);
+ }
+ }
+
+ public static void main() {
+ mulInt();
+ mulLong();
+ mulFloat();
+ mulDouble();
+ }
+
+ private static void mulInt() {
+ expectEquals(15, $opt$Mul(5, 3));
+ expectEquals(0, $opt$Mul(0, 0));
+ expectEquals(0, $opt$Mul(0, 3));
+ expectEquals(0, $opt$Mul(3, 0));
+ expectEquals(-3, $opt$Mul(1, -3));
+ expectEquals(36, $opt$Mul(-12, -3));
+ expectEquals(33, $opt$Mul(1, 3) * 11);
+ expectEquals(671088645, $opt$Mul(134217729, 5)); // (2^27 + 1) * 5
+ }
+
+ private static void mulLong() {
+ expectEquals(15L, $opt$Mul(5L, 3L));
+ expectEquals(0L, $opt$Mul(0L, 0L));
+ expectEquals(0L, $opt$Mul(0L, 3L));
+ expectEquals(0L, $opt$Mul(3L, 0L));
+ expectEquals(-3L, $opt$Mul(1L, -3L));
+ expectEquals(36L, $opt$Mul(-12L, -3L));
+ expectEquals(33L, $opt$Mul(1L, 3L) * 11L);
+ expectEquals(240518168583L, $opt$Mul(34359738369L, 7L)); // (2^35 + 1) * 7
+ }
+
+ private static void mulFloat() {
+ expectApproxEquals(15F, $opt$Mul(5F, 3F), 0.0001F);
+ expectApproxEquals(0F, $opt$Mul(0F, 0F), 0.0001F);
+ expectApproxEquals(0F, $opt$Mul(0F, 3F), 0.0001F);
+ expectApproxEquals(0F, $opt$Mul(3F, 0F), 0.0001F);
+ expectApproxEquals(-3F, $opt$Mul(1F, -3F), 0.0001F);
+ expectApproxEquals(36F, $opt$Mul(-12F, -3F), 0.0001F);
+ expectApproxEquals(33F, $opt$Mul(1F, 3F) * 11F, 0.0001F);
+ expectApproxEquals(0.02F, 0.1F * 0.2F, 0.0001F);
+ expectApproxEquals(-0.1F, -0.5F * 0.2F, 0.0001F);
+
+ expectNaN($opt$Mul(0F, Float.POSITIVE_INFINITY));
+ expectNaN($opt$Mul(0F, Float.NEGATIVE_INFINITY));
+ expectNaN($opt$Mul(Float.NaN, 11F));
+ expectNaN($opt$Mul(Float.NaN, -11F));
+ expectNaN($opt$Mul(Float.NaN, Float.NEGATIVE_INFINITY));
+ expectNaN($opt$Mul(Float.NaN, Float.POSITIVE_INFINITY));
+
+ expectEquals(Float.POSITIVE_INFINITY, $opt$Mul(2F, 3.40282346638528860e+38F));
+ expectEquals(Float.POSITIVE_INFINITY, $opt$Mul(2F, Float.POSITIVE_INFINITY));
+ expectEquals(Float.NEGATIVE_INFINITY, $opt$Mul(-2F, Float.POSITIVE_INFINITY));
+ expectEquals(Float.NEGATIVE_INFINITY, $opt$Mul(-2F, 3.40282346638528860e+38F));
+ expectEquals(Float.NEGATIVE_INFINITY, $opt$Mul(2F, Float.NEGATIVE_INFINITY));
+ expectEquals(Float.POSITIVE_INFINITY, $opt$Mul(-2F, Float.NEGATIVE_INFINITY));
+ expectEquals(Float.NEGATIVE_INFINITY,
+ $opt$Mul(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY));
+ expectEquals(Float.POSITIVE_INFINITY,
+ $opt$Mul(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY));
+ expectEquals(Float.POSITIVE_INFINITY,
+ $opt$Mul(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY));
+ }
+
+ private static void mulDouble() {
+ expectApproxEquals(15D, $opt$Mul(5D, 3D), 0.0001D);
+ expectApproxEquals(0D, $opt$Mul(0D, 0D), 0.0001D);
+ expectApproxEquals(0D, $opt$Mul(0D, 3D), 0.0001D);
+ expectApproxEquals(0D, $opt$Mul(3D, 0D), 0.0001D);
+ expectApproxEquals(-3D, $opt$Mul(1D, -3D), 0.0001D);
+ expectApproxEquals(36D, $opt$Mul(-12D, -3D), 0.0001D);
+ expectApproxEquals(33D, $opt$Mul(1D, 3D) * 11D, 0.0001D);
+ expectApproxEquals(0.02D, 0.1D * 0.2D, 0.0001D);
+ expectApproxEquals(-0.1D, -0.5D * 0.2D, 0.0001D);
+
+ expectNaN($opt$Mul(0D, Double.POSITIVE_INFINITY));
+ expectNaN($opt$Mul(0D, Double.NEGATIVE_INFINITY));
+ expectNaN($opt$Mul(Double.NaN, 11D));
+ expectNaN($opt$Mul(Double.NaN, -11D));
+ expectNaN($opt$Mul(Double.NaN, Double.NEGATIVE_INFINITY));
+ expectNaN($opt$Mul(Double.NaN, Double.POSITIVE_INFINITY));
+
+ expectEquals(Double.POSITIVE_INFINITY, $opt$Mul(2D, 1.79769313486231570e+308));
+ expectEquals(Double.POSITIVE_INFINITY, $opt$Mul(2D, Double.POSITIVE_INFINITY));
+ expectEquals(Double.NEGATIVE_INFINITY, $opt$Mul(-2D, Double.POSITIVE_INFINITY));
+ expectEquals(Double.NEGATIVE_INFINITY, $opt$Mul(-2D, 1.79769313486231570e+308));
+ expectEquals(Double.NEGATIVE_INFINITY, $opt$Mul(2D, Double.NEGATIVE_INFINITY));
+ expectEquals(Double.POSITIVE_INFINITY, $opt$Mul(-2D, Double.NEGATIVE_INFINITY));
+ expectEquals(Double.NEGATIVE_INFINITY, $opt$Mul(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY));
+ expectEquals(Double.POSITIVE_INFINITY, $opt$Mul(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY));
+ expectEquals(Double.POSITIVE_INFINITY, $opt$Mul(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY));
+ }
+
+ static int $opt$Mul(int a, int b) {
+ return a * b;
+ }
+
+ static long $opt$Mul(long a, long b) {
+ return a * b;
+ }
+
+ static float $opt$Mul(float a, float b) {
+ return a * b;
+ }
+
+ static double $opt$Mul(double a, double b) {
+ return a * b;
+ }
+}
diff --git a/test/411-optimizing-arith/src/NegTest.java b/test/411-optimizing-arith/src/NegTest.java
new file mode 100644
index 0000000000..83047269bb
--- /dev/null
+++ b/test/411-optimizing-arith/src/NegTest.java
@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Note that $opt$ is a marker for the optimizing compiler to test
+// it does compile the method, and that $noinline$ is a marker to
+// test that it does not inline it.
+public class NegTest {
+
+ public static void assertEquals(int expected, int result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void assertEquals(long expected, long result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void assertEquals(float expected, float result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void assertEquals(String expected, float result) {
+ if (!expected.equals(new Float(result).toString())) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void assertEquals(double expected, double result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void assertEquals(String expected, double result) {
+ if (!expected.equals(new Double(result).toString())) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void assertIsNaN(float result) {
+ if (!Float.isNaN(result)) {
+ throw new Error("Expected NaN: " + result);
+ }
+ }
+
+ public static void assertIsNaN(double result) {
+ if (!Double.isNaN(result)) {
+ throw new Error("Expected NaN: " + result);
+ }
+ }
+
+ public static void main() {
+ negInt();
+ $opt$noinline$InplaceNegOneInt(1);
+
+ negLong();
+ $opt$noinline$InplaceNegOneLong(1L);
+
+ negFloat();
+ negDouble();
+ }
+
+ private static void negInt() {
+ assertEquals(-1, $opt$noinline$NegInt(1));
+ assertEquals(1, $opt$noinline$NegInt(-1));
+ assertEquals(0, $opt$noinline$NegInt(0));
+ assertEquals(51, $opt$noinline$NegInt(-51));
+ assertEquals(-51, $opt$noinline$NegInt(51));
+ assertEquals(2147483647, $opt$noinline$NegInt(-2147483647)); // -(2^31 - 1)
+ assertEquals(-2147483647, $opt$noinline$NegInt(2147483647)); // 2^31 - 1
+ // From the Java 7 SE Edition specification:
+ // http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.15.4
+ //
+ // For integer values, negation is the same as subtraction from
+ // zero. The Java programming language uses two's-complement
+ // representation for integers, and the range of two's-complement
+ // values is not symmetric, so negation of the maximum negative
+ // int or long results in that same maximum negative number.
+ // Overflow occurs in this case, but no exception is thrown.
+ // For all integer values x, -x equals (~x)+1.''
+ assertEquals(-2147483648, $opt$noinline$NegInt(-2147483648)); // -(2^31)
+ }
+
+ private static void negLong() {
+ assertEquals(-1L, $opt$noinline$NegLong(1L));
+ assertEquals(1L, $opt$noinline$NegLong(-1L));
+ assertEquals(0L, $opt$noinline$NegLong(0L));
+ assertEquals(51L, $opt$noinline$NegLong(-51L));
+ assertEquals(-51L, $opt$noinline$NegLong(51L));
+
+ assertEquals(2147483647L, $opt$noinline$NegLong(-2147483647L)); // -(2^31 - 1)
+ assertEquals(-2147483647L, $opt$noinline$NegLong(2147483647L)); // (2^31 - 1)
+ assertEquals(2147483648L, $opt$noinline$NegLong(-2147483648L)); // -(2^31)
+ assertEquals(-2147483648L, $opt$noinline$NegLong(2147483648L)); // 2^31
+
+ assertEquals(9223372036854775807L, $opt$noinline$NegLong(-9223372036854775807L)); // -(2^63 - 1)
+ assertEquals(-9223372036854775807L, $opt$noinline$NegLong(9223372036854775807L)); // 2^63 - 1
+ // See remark regarding the negation of the maximum negative
+ // (long) value in negInt().
+ assertEquals(-9223372036854775808L, $opt$noinline$NegLong(-9223372036854775808L)); // -(2^63)
+ }
+
+ private static void negFloat() {
+ assertEquals("-0.0", $opt$noinline$NegFloat(0F));
+ assertEquals("0.0", $opt$noinline$NegFloat(-0F));
+ assertEquals(-1F, $opt$noinline$NegFloat(1F));
+ assertEquals(1F, $opt$noinline$NegFloat(-1F));
+ assertEquals(51F, $opt$noinline$NegFloat(-51F));
+ assertEquals(-51F, $opt$noinline$NegFloat(51F));
+
+ assertEquals(-0.1F, $opt$noinline$NegFloat(0.1F));
+ assertEquals(0.1F, $opt$noinline$NegFloat(-0.1F));
+ assertEquals(343597.38362F, $opt$noinline$NegFloat(-343597.38362F));
+ assertEquals(-343597.38362F, $opt$noinline$NegFloat(343597.38362F));
+
+ assertEquals(-Float.MIN_NORMAL, $opt$noinline$NegFloat(Float.MIN_NORMAL));
+ assertEquals(Float.MIN_NORMAL, $opt$noinline$NegFloat(-Float.MIN_NORMAL));
+ assertEquals(-Float.MIN_VALUE, $opt$noinline$NegFloat(Float.MIN_VALUE));
+ assertEquals(Float.MIN_VALUE, $opt$noinline$NegFloat(-Float.MIN_VALUE));
+ assertEquals(-Float.MAX_VALUE, $opt$noinline$NegFloat(Float.MAX_VALUE));
+ assertEquals(Float.MAX_VALUE, $opt$noinline$NegFloat(-Float.MAX_VALUE));
+
+ assertEquals(Float.NEGATIVE_INFINITY, $opt$noinline$NegFloat(Float.POSITIVE_INFINITY));
+ assertEquals(Float.POSITIVE_INFINITY, $opt$noinline$NegFloat(Float.NEGATIVE_INFINITY));
+ assertIsNaN($opt$noinline$NegFloat(Float.NaN));
+ }
+
+ private static void negDouble() {
+ assertEquals("-0.0", $opt$noinline$NegDouble(0D));
+ assertEquals("0.0", $opt$noinline$NegDouble(-0D));
+ assertEquals(-1D, $opt$noinline$NegDouble(1D));
+ assertEquals(1D, $opt$noinline$NegDouble(-1D));
+ assertEquals(51D, $opt$noinline$NegDouble(-51D));
+ assertEquals(-51D, $opt$noinline$NegDouble(51D));
+
+ assertEquals(-0.1D, $opt$noinline$NegDouble(0.1D));
+ assertEquals(0.1D, $opt$noinline$NegDouble(-0.1D));
+ assertEquals(343597.38362D, $opt$noinline$NegDouble(-343597.38362D));
+ assertEquals(-343597.38362D, $opt$noinline$NegDouble(343597.38362D));
+
+ assertEquals(-Double.MIN_NORMAL, $opt$noinline$NegDouble(Double.MIN_NORMAL));
+ assertEquals(Double.MIN_NORMAL, $opt$noinline$NegDouble(-Double.MIN_NORMAL));
+ assertEquals(-Double.MIN_VALUE, $opt$noinline$NegDouble(Double.MIN_VALUE));
+ assertEquals(Double.MIN_VALUE, $opt$noinline$NegDouble(-Double.MIN_VALUE));
+ assertEquals(-Double.MAX_VALUE, $opt$noinline$NegDouble(Double.MAX_VALUE));
+ assertEquals(Double.MAX_VALUE, $opt$noinline$NegDouble(-Double.MAX_VALUE));
+
+ assertEquals(Double.NEGATIVE_INFINITY, $opt$noinline$NegDouble(Double.POSITIVE_INFINITY));
+ assertEquals(Double.POSITIVE_INFINITY, $opt$noinline$NegDouble(Double.NEGATIVE_INFINITY));
+ assertIsNaN($opt$noinline$NegDouble(Double.NaN));
+ }
+
+
+ private static void $opt$noinline$InplaceNegOneInt(int a) {
+ a = -a;
+ assertEquals(-1, a);
+ }
+
+ private static void $opt$noinline$InplaceNegOneLong(long a) {
+ a = -a;
+ assertEquals(-1L, a);
+ }
+
+ private static int $opt$noinline$NegInt(int a){
+ return -a;
+ }
+
+ private static long $opt$noinline$NegLong(long a){
+ return -a;
+ }
+
+ private static float $opt$noinline$NegFloat(float a){
+ return -a;
+ }
+
+ private static double $opt$noinline$NegDouble(double a){
+ return -a;
+ }
+}
diff --git a/test/411-optimizing-arith/src/RemTest.java b/test/411-optimizing-arith/src/RemTest.java
new file mode 100644
index 0000000000..1b31f63569
--- /dev/null
+++ b/test/411-optimizing-arith/src/RemTest.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+public class RemTest {
+
+ public static void main() {
+ remInt();
+ remLong();
+ }
+
+ private static void remInt() {
+ expectEquals(2, $opt$RemConst(6));
+ expectEquals(2, $opt$Rem(6, 4));
+ expectEquals(2, $opt$Rem(6, -4));
+ expectEquals(0, $opt$Rem(6, 3));
+ expectEquals(0, $opt$Rem(6, -3));
+ expectEquals(0, $opt$Rem(6, 1));
+ expectEquals(0, $opt$Rem(6, -1));
+ expectEquals(-1, $opt$Rem(-7, 3));
+ expectEquals(-1, $opt$Rem(-7, -3));
+ expectEquals(0, $opt$Rem(6, 6));
+ expectEquals(0, $opt$Rem(-6, -6));
+ expectEquals(7, $opt$Rem(7, 9));
+ expectEquals(7, $opt$Rem(7, -9));
+ expectEquals(-7, $opt$Rem(-7, 9));
+ expectEquals(-7, $opt$Rem(-7, -9));
+
+ expectEquals(0, $opt$Rem(Integer.MAX_VALUE, 1));
+ expectEquals(0, $opt$Rem(Integer.MAX_VALUE, -1));
+ expectEquals(0, $opt$Rem(Integer.MIN_VALUE, 1));
+ expectEquals(0, $opt$Rem(Integer.MIN_VALUE, -1)); // no overflow
+ expectEquals(-1, $opt$Rem(Integer.MIN_VALUE, Integer.MAX_VALUE));
+ expectEquals(Integer.MAX_VALUE, $opt$Rem(Integer.MAX_VALUE, Integer.MIN_VALUE));
+
+ expectEquals(0, $opt$Rem(0, 7));
+ expectEquals(0, $opt$Rem(0, Integer.MAX_VALUE));
+ expectEquals(0, $opt$Rem(0, Integer.MIN_VALUE));
+
+ expectDivisionByZero(0);
+ expectDivisionByZero(1);
+ expectDivisionByZero(5);
+ expectDivisionByZero(Integer.MAX_VALUE);
+ expectDivisionByZero(Integer.MIN_VALUE);
+ }
+
+ private static void remLong() {
+ expectEquals(2L, $opt$RemConst(6L));
+ expectEquals(2L, $opt$Rem(6L, 4L));
+ expectEquals(2L, $opt$Rem(6L, -4L));
+ expectEquals(0L, $opt$Rem(6L, 3L));
+ expectEquals(0L, $opt$Rem(6L, -3L));
+ expectEquals(0L, $opt$Rem(6L, 1L));
+ expectEquals(0L, $opt$Rem(6L, -1L));
+ expectEquals(-1L, $opt$Rem(-7L, 3L));
+ expectEquals(-1L, $opt$Rem(-7L, -3L));
+ expectEquals(0L, $opt$Rem(6L, 6L));
+ expectEquals(0L, $opt$Rem(-6L, -6L));
+ expectEquals(7L, $opt$Rem(7L, 9L));
+ expectEquals(7L, $opt$Rem(7L, -9L));
+ expectEquals(-7L, $opt$Rem(-7L, 9L));
+ expectEquals(-7L, $opt$Rem(-7L, -9L));
+
+ expectEquals(0L, $opt$Rem(Long.MAX_VALUE, 1L));
+ expectEquals(0L, $opt$Rem(Long.MAX_VALUE, -1L));
+ expectEquals(0L, $opt$Rem(Long.MIN_VALUE, 1L));
+ expectEquals(0L, $opt$Rem(Long.MIN_VALUE, -1L)); // no overflow
+ expectEquals(-1L, $opt$Rem(Long.MIN_VALUE, Long.MAX_VALUE));
+ expectEquals(Long.MAX_VALUE, $opt$Rem(Long.MAX_VALUE, Long.MIN_VALUE));
+
+ expectEquals(0L, $opt$Rem(0L, 7L));
+ expectEquals(0L, $opt$Rem(0L, Long.MAX_VALUE));
+ expectEquals(0L, $opt$Rem(0L, Long.MIN_VALUE));
+
+ expectDivisionByZero(0L);
+ expectDivisionByZero(1L);
+ expectDivisionByZero(5L);
+ expectDivisionByZero(Long.MAX_VALUE);
+ expectDivisionByZero(Long.MIN_VALUE);
+ }
+
+ static int $opt$Rem(int a, int b) {
+ return a % b;
+ }
+
+ static int $opt$RemZero(int a) {
+ return a % 0;
+ }
+
+ // Modulo by literals != 0 should not generate checks.
+ static int $opt$RemConst(int a) {
+ return a % 4;
+ }
+
+ static long $opt$RemConst(long a) {
+ return a % 4L;
+ }
+
+ static long $opt$Rem(long a, long b) {
+ return a % b;
+ }
+
+ static long $opt$RemZero(long a) {
+ return a % 0L;
+ }
+
+ public static void expectEquals(int expected, int result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void expectEquals(long expected, long result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void expectDivisionByZero(int value) {
+ try {
+ $opt$Rem(value, 0);
+ throw new Error("Expected RuntimeException when modulo by 0");
+ } catch (java.lang.RuntimeException e) {
+ }
+ try {
+ $opt$RemZero(value);
+ throw new Error("Expected RuntimeException when modulo by 0");
+ } catch (java.lang.RuntimeException e) {
+ }
+ }
+
+ public static void expectDivisionByZero(long value) {
+ try {
+ $opt$Rem(value, 0L);
+ throw new Error("Expected RuntimeException when modulo by 0");
+ } catch (java.lang.RuntimeException e) {
+ }
+ try {
+ $opt$RemZero(value);
+ throw new Error("Expected RuntimeException when modulo by 0");
+ } catch (java.lang.RuntimeException e) {
+ }
+ }
+
+}
diff --git a/test/411-optimizing-arith/src/ShiftsTest.java b/test/411-optimizing-arith/src/ShiftsTest.java
new file mode 100644
index 0000000000..139ff70bf0
--- /dev/null
+++ b/test/411-optimizing-arith/src/ShiftsTest.java
@@ -0,0 +1,330 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+public class ShiftsTest {
+
+ public static void expectEquals(int expected, int result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void expectEquals(long expected, long result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void main() {
+ testShlInt();
+ testShlLong();
+ testShrInt();
+ testShrLong();
+ testUShrInt();
+ testUShrLong();
+ }
+
+ private static void testShlInt() {
+ expectEquals(48, $opt$ShlIntConst2(12));
+ expectEquals(12, $opt$ShlIntConst0(12));
+ expectEquals(-48, $opt$ShlInt(-12, 2));
+ expectEquals(1024, $opt$ShlInt(32, 5));
+
+ expectEquals(7, $opt$ShlInt(7, 0));
+ expectEquals(14, $opt$ShlInt(7, 1));
+ expectEquals(0, $opt$ShlInt(0, 30));
+
+ expectEquals(1073741824L, $opt$ShlInt(1, 30));
+ expectEquals(Integer.MIN_VALUE, $opt$ShlInt(1, 31)); // overflow
+ expectEquals(Integer.MIN_VALUE, $opt$ShlInt(1073741824, 1)); // overflow
+ expectEquals(1073741824, $opt$ShlInt(268435456, 2));
+
+ // Only the 5 lower bits should be used for shifting (& 0x1f).
+ expectEquals(7, $opt$ShlInt(7, 32)); // 32 & 0x1f = 0
+ expectEquals(14, $opt$ShlInt(7, 33)); // 33 & 0x1f = 1
+ expectEquals(32, $opt$ShlInt(1, 101)); // 101 & 0x1f = 5
+
+ expectEquals(Integer.MIN_VALUE, $opt$ShlInt(1, -1)); // -1 & 0x1f = 31
+ expectEquals(14, $opt$ShlInt(7, -31)); // -31 & 0x1f = 1
+ expectEquals(7, $opt$ShlInt(7, -32)); // -32 & 0x1f = 0
+ expectEquals(-536870912, $opt$ShlInt(7, -3)); // -3 & 0x1f = 29
+
+ expectEquals(Integer.MIN_VALUE, $opt$ShlInt(7, Integer.MAX_VALUE));
+ expectEquals(7, $opt$ShlInt(7, Integer.MIN_VALUE));
+ }
+
+ private static void testShlLong() {
+ expectEquals(48L, $opt$ShlLongConst2(12L));
+ expectEquals(12L, $opt$ShlLongConst0(12L));
+ expectEquals(-48L, $opt$ShlLong(-12L, 2));
+ expectEquals(1024L, $opt$ShlLong(32L, 5));
+
+ expectEquals(7L, $opt$ShlLong(7L, 0));
+ expectEquals(14L, $opt$ShlLong(7L, 1));
+ expectEquals(0L, $opt$ShlLong(0L, 30));
+
+ expectEquals(1073741824L, $opt$ShlLong(1L, 30));
+ expectEquals(2147483648L, $opt$ShlLong(1L, 31));
+ expectEquals(2147483648L, $opt$ShlLong(1073741824L, 1));
+
+ // Long shifts can use up to 6 lower bits.
+ expectEquals(4294967296L, $opt$ShlLong(1L, 32));
+ expectEquals(60129542144L, $opt$ShlLong(7L, 33));
+ expectEquals(Long.MIN_VALUE, $opt$ShlLong(1L, 63)); // overflow
+
+ // Only the 6 lower bits should be used for shifting (& 0x3f).
+ expectEquals(7L, $opt$ShlLong(7L, 64)); // 64 & 0x3f = 0
+ expectEquals(14L, $opt$ShlLong(7L, 65)); // 65 & 0x3f = 1
+ expectEquals(137438953472L, $opt$ShlLong(1L, 101)); // 101 & 0x3f = 37
+
+ expectEquals(Long.MIN_VALUE, $opt$ShlLong(1L, -1)); // -1 & 0x3f = 63
+ expectEquals(14L, $opt$ShlLong(7L, -63)); // -63 & 0x3f = 1
+ expectEquals(7L, $opt$ShlLong(7L, -64)); // -64 & 0x3f = 0
+ expectEquals(2305843009213693952L, $opt$ShlLong(1L, -3)); // -3 & 0x3f = 61
+
+ expectEquals(Long.MIN_VALUE, $opt$ShlLong(7L, Integer.MAX_VALUE));
+ expectEquals(7L, $opt$ShlLong(7L, Integer.MIN_VALUE));
+
+ // Exercise some special cases handled by backends/simplifier.
+ expectEquals(24L, $opt$ShlLongConst1(12L));
+ expectEquals(0x2345678900000000L, $opt$ShlLongConst32(0x123456789L));
+ expectEquals(0x2490249000000000L, $opt$ShlLongConst33(0x12481248L));
+ expectEquals(0x4920492000000000L, $opt$ShlLongConst34(0x12481248L));
+ expectEquals(0x9240924000000000L, $opt$ShlLongConst35(0x12481248L));
+ }
+
+ private static void testShrInt() {
+ expectEquals(3, $opt$ShrIntConst2(12));
+ expectEquals(12, $opt$ShrIntConst0(12));
+ expectEquals(-3, $opt$ShrInt(-12, 2));
+ expectEquals(1, $opt$ShrInt(32, 5));
+
+ expectEquals(7, $opt$ShrInt(7, 0));
+ expectEquals(3, $opt$ShrInt(7, 1));
+ expectEquals(0, $opt$ShrInt(0, 30));
+ expectEquals(0, $opt$ShrInt(1, 30));
+ expectEquals(-1, $opt$ShrInt(-1, 30));
+
+ expectEquals(0, $opt$ShrInt(Integer.MAX_VALUE, 31));
+ expectEquals(-1, $opt$ShrInt(Integer.MIN_VALUE, 31));
+
+ // Only the 5 lower bits should be used for shifting (& 0x1f).
+ expectEquals(7, $opt$ShrInt(7, 32)); // 32 & 0x1f = 0
+ expectEquals(3, $opt$ShrInt(7, 33)); // 33 & 0x1f = 1
+
+ expectEquals(0, $opt$ShrInt(1, -1)); // -1 & 0x1f = 31
+ expectEquals(3, $opt$ShrInt(7, -31)); // -31 & 0x1f = 1
+ expectEquals(7, $opt$ShrInt(7, -32)); // -32 & 0x1f = 0
+ expectEquals(-4, $opt$ShrInt(Integer.MIN_VALUE, -3)); // -3 & 0x1f = 29
+
+ expectEquals(0, $opt$ShrInt(7, Integer.MAX_VALUE));
+ expectEquals(7, $opt$ShrInt(7, Integer.MIN_VALUE));
+ }
+
+ private static void testShrLong() {
+ expectEquals(3L, $opt$ShrLongConst2(12L));
+ expectEquals(12L, $opt$ShrLongConst0(12L));
+ expectEquals(-3L, $opt$ShrLong(-12L, 2));
+ expectEquals(1, $opt$ShrLong(32, 5));
+
+ expectEquals(7L, $opt$ShrLong(7L, 0));
+ expectEquals(3L, $opt$ShrLong(7L, 1));
+ expectEquals(0L, $opt$ShrLong(0L, 30));
+ expectEquals(0L, $opt$ShrLong(1L, 30));
+ expectEquals(-1L, $opt$ShrLong(-1L, 30));
+
+ expectEquals(1L, $opt$ShrLong(1073741824L, 30));
+ expectEquals(1L, $opt$ShrLong(2147483648L, 31));
+ expectEquals(1073741824L, $opt$ShrLong(2147483648L, 1));
+
+ // Long shifts can use up to 6 lower bits.
+ expectEquals(1L, $opt$ShrLong(4294967296L, 32));
+ expectEquals(7L, $opt$ShrLong(60129542144L, 33));
+ expectEquals(0L, $opt$ShrLong(Long.MAX_VALUE, 63));
+ expectEquals(-1L, $opt$ShrLong(Long.MIN_VALUE, 63));
+
+ // Only the 6 lower bits should be used for shifting (& 0x3f).
+ expectEquals(7L, $opt$ShrLong(7L, 64)); // 64 & 0x3f = 0
+ expectEquals(3L, $opt$ShrLong(7L, 65)); // 65 & 0x3f = 1
+
+ expectEquals(-1L, $opt$ShrLong(Long.MIN_VALUE, -1)); // -1 & 0x3f = 63
+ expectEquals(3L, $opt$ShrLong(7L, -63)); // -63 & 0x3f = 1
+ expectEquals(7L, $opt$ShrLong(7L, -64)); // -64 & 0x3f = 0
+ expectEquals(1L, $opt$ShrLong(2305843009213693952L, -3)); // -3 & 0x3f = 61
+ expectEquals(-1L, $opt$ShrLong(Integer.MIN_VALUE, -3)); // -3 & 0x1f = 29
+
+ expectEquals(0L, $opt$ShrLong(7L, Integer.MAX_VALUE));
+ expectEquals(7L, $opt$ShrLong(7L, Integer.MIN_VALUE));
+ }
+
+ private static void testUShrInt() {
+ expectEquals(3, $opt$UShrIntConst2(12));
+ expectEquals(12, $opt$UShrIntConst0(12));
+ expectEquals(1073741821, $opt$UShrInt(-12, 2));
+ expectEquals(1, $opt$UShrInt(32, 5));
+
+ expectEquals(7, $opt$UShrInt(7, 0));
+ expectEquals(3, $opt$UShrInt(7, 1));
+ expectEquals(0, $opt$UShrInt(0, 30));
+ expectEquals(0, $opt$UShrInt(1, 30));
+ expectEquals(3, $opt$UShrInt(-1, 30));
+
+ expectEquals(0, $opt$UShrInt(Integer.MAX_VALUE, 31));
+ expectEquals(1, $opt$UShrInt(Integer.MIN_VALUE, 31));
+
+ // Only the 5 lower bits should be used for shifting (& 0x1f).
+ expectEquals(7, $opt$UShrInt(7, 32)); // 32 & 0x1f = 0
+ expectEquals(3, $opt$UShrInt(7, 33)); // 33 & 0x1f = 1
+
+ expectEquals(0, $opt$UShrInt(1, -1)); // -1 & 0x1f = 31
+ expectEquals(3, $opt$UShrInt(7, -31)); // -31 & 0x1f = 1
+ expectEquals(7, $opt$UShrInt(7, -32)); // -32 & 0x1f = 0
+ expectEquals(4, $opt$UShrInt(Integer.MIN_VALUE, -3)); // -3 & 0x1f = 29
+
+ expectEquals(0, $opt$UShrInt(7, Integer.MAX_VALUE));
+ expectEquals(7, $opt$UShrInt(7, Integer.MIN_VALUE));
+ }
+
+ private static void testUShrLong() {
+ expectEquals(3L, $opt$UShrLongConst2(12L));
+ expectEquals(12L, $opt$UShrLongConst0(12L));
+ expectEquals(4611686018427387901L, $opt$UShrLong(-12L, 2));
+ expectEquals(1, $opt$UShrLong(32, 5));
+
+ expectEquals(7L, $opt$UShrLong(7L, 0));
+ expectEquals(3L, $opt$UShrLong(7L, 1));
+ expectEquals(0L, $opt$UShrLong(0L, 30));
+ expectEquals(0L, $opt$UShrLong(1L, 30));
+ expectEquals(17179869183L, $opt$UShrLong(-1L, 30));
+
+ expectEquals(1L, $opt$UShrLong(1073741824L, 30));
+ expectEquals(1L, $opt$UShrLong(2147483648L, 31));
+ expectEquals(1073741824L, $opt$UShrLong(2147483648L, 1));
+
+ // Long shifts can use use up to 6 lower bits.
+ expectEquals(1L, $opt$UShrLong(4294967296L, 32));
+ expectEquals(7L, $opt$UShrLong(60129542144L, 33));
+ expectEquals(0L, $opt$UShrLong(Long.MAX_VALUE, 63));
+ expectEquals(1L, $opt$UShrLong(Long.MIN_VALUE, 63));
+
+ // Only the 6 lower bits should be used for shifting (& 0x3f).
+ expectEquals(7L, $opt$UShrLong(7L, 64)); // 64 & 0x3f = 0
+ expectEquals(3L, $opt$UShrLong(7L, 65)); // 65 & 0x3f = 1
+
+ expectEquals(1L, $opt$UShrLong(Long.MIN_VALUE, -1)); // -1 & 0x3f = 63
+ expectEquals(3L, $opt$UShrLong(7L, -63)); // -63 & 0x3f = 1
+ expectEquals(7L, $opt$UShrLong(7L, -64)); // -64 & 0x3f = 0
+ expectEquals(1L, $opt$UShrLong(2305843009213693952L, -3)); // -3 & 0x3f = 61
+ expectEquals(4L, $opt$UShrLong(Long.MIN_VALUE, -3)); // -3 & 0x3f = 61
+
+ expectEquals(0L, $opt$UShrLong(7L, Integer.MAX_VALUE));
+ expectEquals(7L, $opt$UShrLong(7L, Integer.MIN_VALUE));
+ }
+
+
+ static int $opt$ShlInt(int value, int distance) {
+ return value << distance;
+ }
+
+ static long $opt$ShlLong(long value, int distance) {
+ return value << distance;
+ }
+
+ static int $opt$ShrInt(int value, int distance) {
+ return value >> distance;
+ }
+
+ static long $opt$ShrLong(long value, int distance) {
+ return value >> distance;
+ }
+
+ static int $opt$UShrInt(int value, int distance) {
+ return value >>> distance;
+ }
+
+ static long $opt$UShrLong(long value, int distance) {
+ return value >>> distance;
+ }
+
+ static int $opt$ShlIntConst2(int value) {
+ return value << 2;
+ }
+
+ static long $opt$ShlLongConst2(long value) {
+ return value << 2;
+ }
+
+ static int $opt$ShrIntConst2(int value) {
+ return value >> 2;
+ }
+
+ static long $opt$ShrLongConst2(long value) {
+ return value >> 2;
+ }
+
+ static int $opt$UShrIntConst2(int value) {
+ return value >>> 2;
+ }
+
+ static long $opt$UShrLongConst2(long value) {
+ return value >>> 2;
+ }
+
+ static int $opt$ShlIntConst0(int value) {
+ return value << 0;
+ }
+
+ static long $opt$ShlLongConst0(long value) {
+ return value << 0;
+ }
+
+ static int $opt$ShrIntConst0(int value) {
+ return value >> 0;
+ }
+
+ static long $opt$ShrLongConst0(long value) {
+ return value >> 0;
+ }
+
+ static int $opt$UShrIntConst0(int value) {
+ return value >>> 0;
+ }
+
+ static long $opt$UShrLongConst0(long value) {
+ return value >>> 0;
+ }
+
+ static long $opt$ShlLongConst1(long value) {
+ return value << 1;
+ }
+
+ static long $opt$ShlLongConst32(long value) {
+ return value << 32;
+ }
+
+ static long $opt$ShlLongConst33(long value) {
+ return value << 33;
+ }
+
+ static long $opt$ShlLongConst34(long value) {
+ return value << 34;
+ }
+
+ static long $opt$ShlLongConst35(long value) {
+ return value << 35;
+ }
+
+}
diff --git a/test/411-optimizing-arith/src/SubTest.java b/test/411-optimizing-arith/src/SubTest.java
new file mode 100644
index 0000000000..9c9ea92f20
--- /dev/null
+++ b/test/411-optimizing-arith/src/SubTest.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Note that $opt$ is a marker for the optimizing compiler to test
+// it does compile the method.
+public class SubTest {
+
+ public static void expectEquals(int expected, int result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void expectEquals(long expected, long result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void expectEquals(float expected, float result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void expectEquals(double expected, double result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+
+ public static void expectApproxEquals(float a, float b) {
+ float maxDelta = 0.0001F;
+ boolean aproxEquals = (a > b) ? ((a - b) < maxDelta) : ((b - a) < maxDelta);
+ if (!aproxEquals) {
+ throw new Error("Expected: " + a + ", found: " + b + ", with delta: " + maxDelta + " " + (a - b));
+ }
+ }
+
+ public static void expectApproxEquals(double a, double b) {
+ double maxDelta = 0.00001D;
+ boolean aproxEquals = (a > b) ? ((a - b) < maxDelta) : ((b - a) < maxDelta);
+ if (!aproxEquals) {
+ throw new Error("Expected: " + a + ", found: " + b + ", with delta: " + maxDelta + " " + (a - b));
+ }
+ }
+
+ public static void expectNaN(float a) {
+ if (a == a) {
+ throw new Error("Expected NaN: " + a);
+ }
+ }
+
+ public static void expectNaN(double a) {
+ if (a == a) {
+ throw new Error("Expected NaN: " + a);
+ }
+ }
+
+ public static void main() {
+ subInt();
+ subLong();
+ subFloat();
+ subDouble();
+ }
+
+ private static void subInt() {
+ expectEquals(2, $opt$Sub(5, 3));
+ expectEquals(0, $opt$Sub(0, 0));
+ expectEquals(-3, $opt$Sub(0, 3));
+ expectEquals(3, $opt$Sub(3, 0));
+ expectEquals(4, $opt$Sub(1, -3));
+ expectEquals(-9, $opt$Sub(-12, -3));
+ expectEquals(134217724, $opt$Sub(134217729, 5)); // (2^27 + 1) - 5
+ }
+
+ private static void subLong() {
+ expectEquals(2L, $opt$Sub(5L, 3L));
+ expectEquals(0L, $opt$Sub(0L, 0L));
+ expectEquals(-3L, $opt$Sub(0L, 3L));
+ expectEquals(3L, $opt$Sub(3L, 0L));
+ expectEquals(4L, $opt$Sub(1L, -3L));
+ expectEquals(-9L, $opt$Sub(-12L, -3L));
+ expectEquals(134217724L, $opt$Sub(134217729L, 5L)); // (2^27 + 1) - 5
+ expectEquals(34359738362L, $opt$Sub(34359738369L, 7L)); // (2^35 + 1) - 7
+ }
+
+ private static void subFloat() {
+ expectApproxEquals(2F, $opt$Sub(5F, 3F));
+ expectApproxEquals(0F, $opt$Sub(0F, 0F));
+ expectApproxEquals(-3F, $opt$Sub(0F, 3F));
+ expectApproxEquals(3F, $opt$Sub(3F, 0F));
+ expectApproxEquals(4F, $opt$Sub(1F, -3F));
+ expectApproxEquals(-9F, $opt$Sub(-12F, -3F));
+ expectApproxEquals(34359738362F, $opt$Sub(34359738369F, 7F)); // (2^35 + 1) - 7
+ expectApproxEquals(-0.1F, $opt$Sub(0.1F, 0.2F));
+ expectApproxEquals(0.2F, $opt$Sub(-0.5F, -0.7F));
+
+ expectNaN($opt$Sub(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY));
+ expectNaN($opt$Sub(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY));
+ expectNaN($opt$Sub(Float.NaN, 11F));
+ expectNaN($opt$Sub(Float.NaN, -11F));
+ expectNaN($opt$Sub(Float.NaN, Float.NEGATIVE_INFINITY));
+ expectNaN($opt$Sub(Float.NaN, Float.POSITIVE_INFINITY));
+
+ expectEquals(Float.NEGATIVE_INFINITY, $opt$Sub(-Float.MAX_VALUE, Float.MAX_VALUE));
+ expectEquals(Float.NEGATIVE_INFINITY, $opt$Sub(2F, Float.POSITIVE_INFINITY));
+ expectEquals(Float.POSITIVE_INFINITY, $opt$Sub(Float.MAX_VALUE, -Float.MAX_VALUE));
+ expectEquals(Float.POSITIVE_INFINITY, $opt$Sub(2F, Float.NEGATIVE_INFINITY));
+ expectEquals(Float.POSITIVE_INFINITY, $opt$Sub(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY));
+ expectEquals(Float.NEGATIVE_INFINITY, $opt$Sub(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY));
+ }
+
+ private static void subDouble() {
+ expectApproxEquals(2D, $opt$Sub(5D, 3D));
+ expectApproxEquals(0D, $opt$Sub(0D, 0D));
+ expectApproxEquals(-3D, $opt$Sub(0D, 3D));
+ expectApproxEquals(3D, $opt$Sub(3D, 0D));
+ expectApproxEquals(4D, $opt$Sub(1D, -3D));
+ expectApproxEquals(-9D, $opt$Sub(-12D, -3D));
+ expectApproxEquals(134217724D, $opt$Sub(134217729D, 5D)); // (2^27 + 1) - 5
+ expectApproxEquals(34359738362D, $opt$Sub(34359738369D, 7D)); // (2^35 + 1) - 7
+ expectApproxEquals(-0.1D, $opt$Sub(0.1D, 0.2D));
+ expectApproxEquals(0.2D, $opt$Sub(-0.5D, -0.7D));
+
+ expectNaN($opt$Sub(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY));
+ expectNaN($opt$Sub(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY));
+ expectNaN($opt$Sub(Double.NaN, 11D));
+ expectNaN($opt$Sub(Double.NaN, -11D));
+ expectNaN($opt$Sub(Double.NaN, Double.NEGATIVE_INFINITY));
+ expectNaN($opt$Sub(Double.NaN, Double.POSITIVE_INFINITY));
+
+ expectEquals(Double.NEGATIVE_INFINITY, $opt$Sub(-Double.MAX_VALUE, Double.MAX_VALUE));
+ expectEquals(Double.NEGATIVE_INFINITY, $opt$Sub(2D, Double.POSITIVE_INFINITY));
+ expectEquals(Double.POSITIVE_INFINITY, $opt$Sub(Double.MAX_VALUE, -Double.MAX_VALUE));
+ expectEquals(Double.POSITIVE_INFINITY, $opt$Sub(2D, Double.NEGATIVE_INFINITY));
+ expectEquals(Double.POSITIVE_INFINITY, $opt$Sub(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY));
+ expectEquals(Double.NEGATIVE_INFINITY, $opt$Sub(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
+ }
+
+ static int $opt$Sub(int a, int b) {
+ return a - b;
+ }
+
+ static long $opt$Sub(long a, long b) {
+ return a - b;
+ }
+
+ static float $opt$Sub(float a, float b) {
+ return a - b;
+ }
+
+ static double $opt$Sub(double a, double b) {
+ return a - b;
+ }
+
+}