[optimizing compiler] Add REM_FLOAT and REM_DOUBLE
- for arm, x86, x86_64 backends
- reinstated fmod quick entry points for x86. This is a partial revert
of bd3682eada753de52975ae2b4a712bd87dc139a6 which added inline assembly
for floting point rem on x86. Note that Quick still uses the inline
version.
- fix rem tests for longs
Change-Id: I73be19a9f2f2bcf3f718d9ca636e67bdd72b5440
diff --git a/test/428-optimizing-arith-rem/src/Main.java b/test/428-optimizing-arith-rem/src/Main.java
index 46bd3c6..3f77318 100644
--- a/test/428-optimizing-arith-rem/src/Main.java
+++ b/test/428-optimizing-arith-rem/src/Main.java
@@ -16,49 +16,7 @@
public class Main {
- 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) {
- }
- }
-
public static void main(String[] args) {
- rem();
- }
-
- public static void rem() {
remInt();
remLong();
}
@@ -115,22 +73,22 @@
expectEquals(-7L, $opt$Rem(-7L, 9L));
expectEquals(-7L, $opt$Rem(-7L, -9L));
- expectEquals(0L, $opt$Rem(Integer.MAX_VALUE, 1L));
- expectEquals(0L, $opt$Rem(Integer.MAX_VALUE, -1L));
- expectEquals(0L, $opt$Rem(Integer.MIN_VALUE, 1L));
- expectEquals(0L, $opt$Rem(Integer.MIN_VALUE, -1L)); // no overflow
- expectEquals(-1L, $opt$Rem(Integer.MIN_VALUE, Integer.MAX_VALUE));
- expectEquals(Integer.MAX_VALUE, $opt$Rem(Integer.MAX_VALUE, Integer.MIN_VALUE));
+ 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, Integer.MAX_VALUE));
- expectEquals(0L, $opt$Rem(0L, Integer.MIN_VALUE));
+ expectEquals(0L, $opt$Rem(0L, Long.MAX_VALUE));
+ expectEquals(0L, $opt$Rem(0L, Long.MIN_VALUE));
expectDivisionByZero(0L);
expectDivisionByZero(1L);
expectDivisionByZero(5L);
- expectDivisionByZero(Integer.MAX_VALUE);
- expectDivisionByZero(Integer.MIN_VALUE);
+ expectDivisionByZero(Long.MAX_VALUE);
+ expectDivisionByZero(Long.MIN_VALUE);
}
static int $opt$Rem(int a, int b) {
@@ -157,4 +115,43 @@
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/436-rem-float/expected.txt b/test/436-rem-float/expected.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/436-rem-float/expected.txt
diff --git a/test/436-rem-float/info.txt b/test/436-rem-float/info.txt
new file mode 100644
index 0000000..b023f59
--- /dev/null
+++ b/test/436-rem-float/info.txt
@@ -0,0 +1 @@
+Tests for floating point modulo (rem) operation.
diff --git a/test/436-rem-float/src/Main.java b/test/436-rem-float/src/Main.java
new file mode 100644
index 0000000..e20c21f
--- /dev/null
+++ b/test/436-rem-float/src/Main.java
@@ -0,0 +1,154 @@
+/*
+ * 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 Main {
+
+ public static void main(String[] args) {
+ remFloat();
+ remDouble();
+ }
+
+ private static void remFloat() {
+ expectApproxEquals(2F, $opt$RemConst(6F));
+
+ expectApproxEquals(2F, $opt$Rem(5.1F, 3.1F));
+ expectApproxEquals(2.1F, $opt$Rem(5.1F, 3F));
+ expectApproxEquals(-2F, $opt$Rem(-5.1F, 3.1F));
+ expectApproxEquals(-2.1F, $opt$Rem(-5.1F, -3F));
+
+ expectApproxEquals(2F, $opt$Rem(6F, 4F));
+ expectApproxEquals(2F, $opt$Rem(6F, -4F));
+ expectApproxEquals(0F, $opt$Rem(6F, 3F));
+ expectApproxEquals(0F, $opt$Rem(6F, -3F));
+ expectApproxEquals(0F, $opt$Rem(6F, 1F));
+ expectApproxEquals(0F, $opt$Rem(6F, -1F));
+ expectApproxEquals(-1F, $opt$Rem(-7F, 3F));
+ expectApproxEquals(-1F, $opt$Rem(-7F, -3F));
+ expectApproxEquals(0F, $opt$Rem(6F, 6F));
+ expectApproxEquals(0F, $opt$Rem(-6F, -6F));
+ expectApproxEquals(7F, $opt$Rem(7F, 9F));
+ expectApproxEquals(7F, $opt$Rem(7F, -9F));
+ expectApproxEquals(-7F, $opt$Rem(-7F, 9F));
+ expectApproxEquals(-7F, $opt$Rem(-7F, -9F));
+
+ expectApproxEquals(0F, $opt$Rem(Float.MAX_VALUE, 1F));
+ expectApproxEquals(0F, $opt$Rem(Float.MAX_VALUE, -1F));
+ expectApproxEquals(0F, $opt$Rem(Float.MIN_VALUE, 1F));
+ expectApproxEquals(0F, $opt$Rem(Float.MIN_VALUE, -1F));
+
+ expectApproxEquals(0F, $opt$Rem(0F, 7F));
+ expectApproxEquals(0F, $opt$Rem(0F, Float.MAX_VALUE));
+ expectApproxEquals(0F, $opt$Rem(0F, Float.MIN_VALUE));
+
+ expectNaN($opt$Rem(Float.NaN, 3F));
+ expectNaN($opt$Rem(3F, Float.NaN));
+ expectNaN($opt$Rem(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY));
+ expectNaN($opt$Rem(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY));
+ expectNaN($opt$Rem(3F, 0F));
+
+ expectApproxEquals(4F, $opt$Rem(4F, Float.POSITIVE_INFINITY));
+ expectApproxEquals(4F, $opt$Rem(4F, Float.NEGATIVE_INFINITY));
+ }
+
+ private static void remDouble() {
+ expectApproxEquals(2D, $opt$RemConst(6D));
+
+ expectApproxEquals(2D, $opt$Rem(5.1D, 3.1D));
+ expectApproxEquals(2.1D, $opt$Rem(5.1D, 3D));
+ expectApproxEquals(-2D, $opt$Rem(-5.1D, 3.1D));
+ expectApproxEquals(-2.1D, $opt$Rem(-5.1D, -3D));
+
+ expectApproxEquals(2D, $opt$Rem(6D, 4D));
+ expectApproxEquals(2D, $opt$Rem(6D, -4D));
+ expectApproxEquals(0D, $opt$Rem(6D, 3D));
+ expectApproxEquals(0D, $opt$Rem(6D, -3D));
+ expectApproxEquals(0D, $opt$Rem(6D, 1D));
+ expectApproxEquals(0D, $opt$Rem(6D, -1D));
+ expectApproxEquals(-1D, $opt$Rem(-7D, 3D));
+ expectApproxEquals(-1D, $opt$Rem(-7D, -3D));
+ expectApproxEquals(0D, $opt$Rem(6D, 6D));
+ expectApproxEquals(0D, $opt$Rem(-6D, -6D));
+ expectApproxEquals(7D, $opt$Rem(7D, 9D));
+ expectApproxEquals(7D, $opt$Rem(7D, -9D));
+ expectApproxEquals(-7D, $opt$Rem(-7D, 9D));
+ expectApproxEquals(-7D, $opt$Rem(-7D, -9D));
+
+ expectApproxEquals(0D, $opt$Rem(Double.MAX_VALUE, 1D));
+ expectApproxEquals(0D, $opt$Rem(Double.MAX_VALUE, -1D));
+ expectApproxEquals(0D, $opt$Rem(Double.MIN_VALUE, 1D));
+ expectApproxEquals(0D, $opt$Rem(Double.MIN_VALUE, -1D));
+
+ expectApproxEquals(0D, $opt$Rem(0D, 7D));
+ expectApproxEquals(0D, $opt$Rem(0D, Double.MAX_VALUE));
+ expectApproxEquals(0D, $opt$Rem(0D, Double.MIN_VALUE));
+
+ expectNaN($opt$Rem(Double.NaN, 3D));
+ expectNaN($opt$Rem(3D, Double.NaN));
+ expectNaN($opt$Rem(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY));
+ expectNaN($opt$Rem(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
+ expectNaN($opt$Rem(3D, 0D));
+
+ expectApproxEquals(4D, $opt$Rem(4D, Double.POSITIVE_INFINITY));
+ expectApproxEquals(4D, $opt$Rem(4D, Double.NEGATIVE_INFINITY));
+ }
+
+ static float $opt$Rem(float a, float b) {
+ return a % b;
+ }
+
+ static float $opt$RemConst(float a) {
+ return a % 4F;
+ }
+
+ static double $opt$Rem(double a, double b) {
+ return a % b;
+ }
+
+ static double $opt$RemConst(double a) {
+ return a % 4D;
+ }
+
+ 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);
+ }
+ }
+
+}
diff --git a/test/Android.run-test.mk b/test/Android.run-test.mk
index 69ba288..c3fec5d 100644
--- a/test/Android.run-test.mk
+++ b/test/Android.run-test.mk
@@ -322,6 +322,7 @@
424-checkcast \
427-bounds \
430-live-register-slow-path \
+ 436-rem-float \
800-smali \
ifneq (,$(filter optimizing,$(COMPILER_TYPES)))