Move math source files. (#151)

This is split out from the LTO change. It's needed by the LTO build so
that we can easily build these files in non-LTO mode, since they satisfy
calls emitted by LLVM codegen after LTO.

diff --git a/Makefile b/Makefile
index a169b4f2e73ef929512023da8e104e16ed476fd6..4fa5fcb96b55c18165632b924c9b71d0c2631caf 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -34,7 +34,9 @@ endif
 BASICS_DIR = $(CURDIR)/basics
 BASICS_INC = $(BASICS_DIR)/include
 BASICS_CRT_SOURCES = $(wildcard $(BASICS_DIR)/crt/*.c)
-BASICS_SOURCES = $(wildcard $(BASICS_DIR)/sources/*.c)
+BASICS_SOURCES = \
+    $(wildcard $(BASICS_DIR)/sources/*.c) \
+    $(wildcard $(BASICS_DIR)/sources/math/*.c)
 DLMALLOC_DIR = $(CURDIR)/dlmalloc
 DLMALLOC_SRC_DIR = $(DLMALLOC_DIR)/src
 DLMALLOC_SOURCES = $(DLMALLOC_SRC_DIR)/dlmalloc.c

diff --git a/basics/sources/fmin-fmax.c b/basics/sources/fmin-fmax.c
deleted file mode 100644 (file)
index 9293798..0000000
--- a/basics/sources/fmin-fmax.c
+++ /dev/null
@@ -1,34 +0,0 @@
-// Wasm's `min` and `max` operators implement the IEEE 754-2019
-// `minimum` and `maximum` operations, meaning that given a choice
-// between NaN and a number, they return NaN. This differs from
-// the C standard library's `fmin` and `fmax` functions, which
-// return the number. However, we can still use wasm's builtins
-// by handling the NaN cases explicitly, and it still turns out
-// to be faster than doing the whole operation in
-// target-independent C. And, it's smaller.
-
-#include <math.h>
-
-float fminf(float x, float y) {
-    if (isnan(x)) return y;
-    if (isnan(y)) return x;
-    return __builtin_wasm_min_f32(x, y);
-}
-
-float fmaxf(float x, float y) {
-    if (isnan(x)) return y;
-    if (isnan(y)) return x;
-    return __builtin_wasm_max_f32(x, y);
-}
-
-double fmin(double x, double y) {
-    if (isnan(x)) return y;
-    if (isnan(y)) return x;
-    return __builtin_wasm_min_f64(x, y);
-}
-
-double fmax(double x, double y) {
-    if (isnan(x)) return y;
-    if (isnan(y)) return x;
-    return __builtin_wasm_max_f64(x, y);
-}

diff --git a/basics/sources/math-builtins.c b/basics/sources/math-builtins.c
deleted file mode 100644 (file)
index a5eb7cd..0000000
--- a/basics/sources/math-builtins.c
+++ /dev/null
@@ -1,69 +0,0 @@
-// Each of the following math functions can be implemented with a single
-// wasm instruction, so use that implementation rather than the portable
-// one in libm.
-
-#include <math.h>
-
-float fabsf(float x) {
-    return __builtin_fabsf(x);
-}
-
-double fabs(double x) {
-    return __builtin_fabs(x);
-}
-
-float sqrtf(float x) {
-    return __builtin_sqrtf(x);
-}
-
-double sqrt(double x) {
-    return __builtin_sqrt(x);
-}
-
-float copysignf(float x, float y) {
-    return __builtin_copysignf(x, y);
-}
-
-double copysign(double x, double y) {
-    return __builtin_copysign(x, y);
-}
-
-float ceilf(float x) {
-    return __builtin_ceilf(x);
-}
-
-double ceil(double x) {
-    return __builtin_ceil(x);
-}
-
-float floorf(float x) {
-    return __builtin_floorf(x);
-}
-
-double floor(double x) {
-    return __builtin_floor(x);
-}
-
-float truncf(float x) {
-    return __builtin_truncf(x);
-}
-
-double trunc(double x) {
-    return __builtin_trunc(x);
-}
-
-float nearbyintf(float x) {
-    return __builtin_nearbyintf(x);
-}
-
-double nearbyint(double x) {
-    return __builtin_nearbyint(x);
-}
-
-float rintf(float x) {
-    return __builtin_rintf(x);
-}
-
-double rint(double x) {
-    return __builtin_rint(x);
-}

diff --git a/basics/sources/math/fmin-fmax.c b/basics/sources/math/fmin-fmax.c
new file mode 100644 (file)
index 0000000..9293798
--- /dev/null
+++ b/basics/sources/math/fmin-fmax.c
@@ -0,0 +1,34 @@
+// Wasm's `min` and `max` operators implement the IEEE 754-2019
+// `minimum` and `maximum` operations, meaning that given a choice
+// between NaN and a number, they return NaN. This differs from
+// the C standard library's `fmin` and `fmax` functions, which
+// return the number. However, we can still use wasm's builtins
+// by handling the NaN cases explicitly, and it still turns out
+// to be faster than doing the whole operation in
+// target-independent C. And, it's smaller.
+
+#include <math.h>
+
+float fminf(float x, float y) {
+    if (isnan(x)) return y;
+    if (isnan(y)) return x;
+    return __builtin_wasm_min_f32(x, y);
+}
+
+float fmaxf(float x, float y) {
+    if (isnan(x)) return y;
+    if (isnan(y)) return x;
+    return __builtin_wasm_max_f32(x, y);
+}
+
+double fmin(double x, double y) {
+    if (isnan(x)) return y;
+    if (isnan(y)) return x;
+    return __builtin_wasm_min_f64(x, y);
+}
+
+double fmax(double x, double y) {
+    if (isnan(x)) return y;
+    if (isnan(y)) return x;
+    return __builtin_wasm_max_f64(x, y);
+}

diff --git a/basics/sources/math/math-builtins.c b/basics/sources/math/math-builtins.c
new file mode 100644 (file)
index 0000000..a5eb7cd
--- /dev/null
+++ b/basics/sources/math/math-builtins.c
@@ -0,0 +1,69 @@
+// Each of the following math functions can be implemented with a single
+// wasm instruction, so use that implementation rather than the portable
+// one in libm.
+
+#include <math.h>
+
+float fabsf(float x) {
+    return __builtin_fabsf(x);
+}
+
+double fabs(double x) {
+    return __builtin_fabs(x);
+}
+
+float sqrtf(float x) {
+    return __builtin_sqrtf(x);
+}
+
+double sqrt(double x) {
+    return __builtin_sqrt(x);
+}
+
+float copysignf(float x, float y) {
+    return __builtin_copysignf(x, y);
+}
+
+double copysign(double x, double y) {
+    return __builtin_copysign(x, y);
+}
+
+float ceilf(float x) {
+    return __builtin_ceilf(x);
+}
+
+double ceil(double x) {
+    return __builtin_ceil(x);
+}
+
+float floorf(float x) {
+    return __builtin_floorf(x);
+}
+
+double floor(double x) {
+    return __builtin_floor(x);
+}
+
+float truncf(float x) {
+    return __builtin_truncf(x);
+}
+
+double trunc(double x) {
+    return __builtin_trunc(x);
+}
+
+float nearbyintf(float x) {
+    return __builtin_nearbyintf(x);
+}
+
+double nearbyint(double x) {
+    return __builtin_nearbyint(x);
+}
+
+float rintf(float x) {
+    return __builtin_rintf(x);
+}
+
+double rint(double x) {
+    return __builtin_rint(x);
+}