>From 50fc05566ba7479844949d727233c04a5e8151e8 Mon Sep 17 00:00:00 2001
From: Sergey Fedorov <vital....@gmail.com>
Date: Sat, 29 Apr 2023 14:55:44 +0800
Subject: [PATCH] libgfortran: implement fpu-macppc for Darwin, support IEEE
arithmetic
Signed-off-by: Sergey Fedorov <vital....@gmail.com>
---
.../gfortran.dg/ieee/signaling_2_c.c | 9 +
libgfortran/config/fpu-macppc.h | 414 ++++++++++++++++++
libgfortran/configure.host | 9 +
3 files changed, 432 insertions(+)
create mode 100644 libgfortran/config/fpu-macppc.h
diff --git a/gcc/testsuite/gfortran.dg/ieee/signaling_2_c.c
b/gcc/testsuite/gfortran.dg/ieee/signaling_2_c.c
index ea7fc0467bd..4a8f72c5bf2 100644
--- a/gcc/testsuite/gfortran.dg/ieee/signaling_2_c.c
+++ b/gcc/testsuite/gfortran.dg/ieee/signaling_2_c.c
@@ -1,3 +1,11 @@
+#ifdef __POWERPC__ // No support for issignaling in math.h on Darwin PPC
+
+int isnansf (float x) { return __builtin_issignaling (x) ? 1 : 0; }
+int isnans (double x) { return __builtin_issignaling (x) ? 1 : 0; }
+int isnansl (long double x) { return __builtin_issignaling (x) ? 1 : 0; }
+
+#else
+
#define _GNU_SOURCE
#include <math.h>
#include <float.h>
@@ -6,3 +14,4 @@ int isnansf (float x) { return issignaling (x) ? 1 :
0; }
int isnans (double x) { return issignaling (x) ? 1 : 0; }
int isnansl (long double x) { return issignaling (x) ? 1 : 0; }
+#endif
diff --git a/libgfortran/config/fpu-macppc.h
b/libgfortran/config/fpu-macppc.h
new file mode 100644
index 00000000000..d43d3caa3dd
--- /dev/null
+++ b/libgfortran/config/fpu-macppc.h
@@ -0,0 +1,414 @@
+/* FPU-related code for PowerPC.
+ Copyright (C) 2023-2024 Free Software Foundation, Inc.
+ Contributed by Sergey Fedorov <vital....@gmail.com>
+
+This file is part of the GNU Fortran runtime library (libgfortran).
+
+Libgfortran is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+Libgfortran is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+the GNU General Public License for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version 3.1,
+as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+<http://www.gnu.org/licenses/>. */
+
+/* While some of the definitions and functions used here are available
+ with Apple libm, we on purpose avoid pulling it in: to avoid potential
+ conflicts and not self-impose unnecessary constraints. */
+
+/* FP exception flags */
+#define FE_INEXACT 0x02000000
+#define FE_DIVBYZERO 0x04000000
+#define FE_UNDERFLOW 0x08000000
+#define FE_OVERFLOW 0x10000000
+#define FE_INVALID 0x20000000
+
+#define FE_ALL_EXCEPT 0x3E000000
+#define FE_NO_EXCEPT 0xC1FFFFFF
+
+/* Extra invalid flags */
+#define FE_INVALID_SNAN 0x01000000
+#define FE_INVALID_ISI 0x00800000
+#define FE_INVALID_IDI 0x00400000
+#define FE_INVALID_ZDZ 0x00200000
+#define FE_INVALID_IMZ 0x00100000
+#define FE_INVALID_XVC 0x00080000
+#define FE_INVALID_SOFT 0x00000400
+#define FE_INVALID_SQRT 0x00000200
+#define FE_INVALID_CVI 0x00000100
+
+/* Rounding modes */
+#define FE_TONEAREST 0x00000000
+#define FE_TOWARDZERO 0x00000001
+#define FE_UPWARD 0x00000002
+#define FE_DOWNWARD 0x00000003
+
+/* There is no consistency re what is to be included in all_invalid.
+ Apple libm has 0x01f80300, Openlibm/FreeBSD/NetBSD has 0x21f80700
+ and OpenBSD has 0x01f80700. In particular, FE_INVALID_SOFT and
+ FE_INVALID are contested. */
+#define FE_ALL_INVALID 0x01F80700
+#define FE_NO_INVALID 0xFE07F8FF
+
+/* Apple libm has 0xFFF80300 and 0x0007FCFF here. */
+#define FE_ALL_FLAGS 0xFFF80700
+#define FE_NO_FLAGS 0x0007F8FF
+
+#define FE_ALL_RND 0x00000003
+#define FE_NO_RND 0xFFFFFFFC
+
+/* Floating-point exception summary (FX) bit. */
+#define FE_SET_FX 0x80000000
+#define FE_CLR_FX 0x7FFFFFFF
+
+/* Some implementations use FE_INVALID_SOFT here. */
+#define SET_INVALID 0x01000000
+
+#define FE_EXCEPT_SHIFT 22
+#define EXCEPT_MASK FE_ALL_EXCEPT >> FE_EXCEPT_SHIFT
+
+typedef unsigned int fenv_t;
+typedef unsigned int fexcept_t;
+
+/* default environment object */
+extern const fenv_t _FE_DFL_ENV;
+/* pointer to default environment */
+#define FE_DFL_ENV &_FE_DFL_ENV
+
+typedef union {
+ struct {
+ unsigned int hi;
+ fenv_t lo;
+ } i;
+ double d;
+} hexdouble;
+
+#define HEXDOUBLE(hi, lo) {{ hi, lo }}
+
+
+/* Check we can actually store the FPU state in the allocated size. */
+_Static_assert (sizeof(fenv_t) <= (size_t) GFC_FPE_STATE_BUFFER_SIZE,
+ "GFC_FPE_STATE_BUFFER_SIZE is too small");
+
+
+static inline int fegetexcept(void)
+{
+ hexdouble fe;
+
+ fe.d = __builtin_mffs();
+ return ((fe.i.lo & EXCEPT_MASK) << FE_EXCEPT_SHIFT);
+}
+
+static inline int feclearexcept(int excepts)
+{
+ hexdouble fe;
+
+ if (excepts & FE_INVALID)
+ excepts |= FE_ALL_INVALID;
+ fe.d = __builtin_mffs();
+ fe.i.lo &= ~excepts;
+ if ((fe.i.lo & FE_ALL_EXCEPT) == 0)
+ fe.i.lo &= FE_CLR_FX;
+ __builtin_mtfsf(0xFF, fe.d);
+ return 0;
+}
+
+/* It is not possible to set VX bit directly. */
+static inline int feraiseexcept(int excepts)
+{
+ hexdouble fe;
+
+ if (excepts & FE_INVALID)
+ excepts |= SET_INVALID;
+ fe.d = __builtin_mffs();
+ fe.i.lo |= excepts;
+ __builtin_mtfsf(0xFF, fe.d);
+ return 0;
+}
+
+static inline int fetestexcept(int excepts)
+{
+ hexdouble fe;
+
+ excepts &= FE_ALL_EXCEPT;
+ fe.d = __builtin_mffs();
+ return (fe.i.lo & (excepts & FE_ALL_EXCEPT));
+}
+
+static inline int feenableexcept(int mask)
+{
+ hexdouble fe;
+ fenv_t oldmask;
+
+ fe.d = __builtin_mffs();
+ oldmask = fe.i.lo;
+ fe.i.lo |= (mask & FE_ALL_EXCEPT) >> FE_EXCEPT_SHIFT;
+ __builtin_mtfsf(0xFF, fe.d);
+ return ((oldmask & EXCEPT_MASK) << FE_EXCEPT_SHIFT);
+}
+
+static inline int fedisableexcept(int mask)
+{
+ hexdouble fe;
+ fenv_t oldmask;
+
+ fe.d = __builtin_mffs();
+ oldmask = fe.i.lo;
+ fe.i.lo &= ~((mask & FE_ALL_EXCEPT) >> FE_EXCEPT_SHIFT);
+ __builtin_mtfsf(0xFF, fe.d);
+ return ((oldmask & EXCEPT_MASK) << FE_EXCEPT_SHIFT);
+}
+
+static inline int fegetround(void)
+{
+ hexdouble fe;
+
+ fe.d = __builtin_mffs();
+ return (fe.i.lo & FE_ALL_RND);
+}
+
+static inline int fesetround(int round)
+{
+ hexdouble fe;
+
+ if (round & FE_NO_RND)
+ return (-1);
+ fe.d = __builtin_mffs();
+ fe.i.lo = (fe.i.lo & FE_NO_RND) | round;
+ __builtin_mtfsf(0xFF, fe.d);
+ return 0;
+}
+
+static inline int fegetenv(fenv_t *envp)
+{
+ hexdouble fe;
+
+ fe.d = __builtin_mffs();
+ *envp = fe.i.lo;
+ return 0;
+}
+
+static inline int fesetenv(const fenv_t *envp)
+{
+ hexdouble fe;
+
+ fe.i.lo = *envp;
+ __builtin_mtfsf(0xFF, fe.d);
+ return 0;
+}
+
+
+int get_fpu_trap_exceptions (void)
+{
+ int exceptions = fegetexcept();
+ int res = 0;
+
+ if (exceptions & FE_INVALID) res |= GFC_FPE_INVALID;
+ if (exceptions & FE_DIVBYZERO) res |= GFC_FPE_ZERO;
+ if (exceptions & FE_OVERFLOW) res |= GFC_FPE_OVERFLOW;
+ if (exceptions & FE_UNDERFLOW) res |= GFC_FPE_UNDERFLOW;
+ if (exceptions & FE_INEXACT) res |= GFC_FPE_INEXACT;
+
+ return res;
+}
+
+void set_fpu (void)
+{
+ if (options.fpe & GFC_FPE_DENORMAL)
+ estr_write ("Fortran runtime warning: Floating point 'denormal
operand' "
+ "exception not supported.\n");
+
+ set_fpu_trap_exceptions (options.fpe, 0);
+}
+
+void set_fpu_trap_exceptions (int trap, int notrap)
+{
+ unsigned int mode_set = 0, mode_clr = 0;
+
+ if (trap & GFC_FPE_INVALID)
+ mode_set |= FE_INVALID;
+ if (notrap & GFC_FPE_INVALID)
+ mode_clr |= FE_INVALID;
+
+ if (trap & GFC_FPE_ZERO)
+ mode_set |= FE_DIVBYZERO;
+ if (notrap & GFC_FPE_ZERO)
+ mode_clr |= FE_DIVBYZERO;
+
+ if (trap & GFC_FPE_OVERFLOW)
+ mode_set |= FE_OVERFLOW;
+ if (notrap & GFC_FPE_OVERFLOW)
+ mode_clr |= FE_OVERFLOW;
+
+ if (trap & GFC_FPE_UNDERFLOW)
+ mode_set |= FE_UNDERFLOW;
+ if (notrap & GFC_FPE_UNDERFLOW)
+ mode_clr |= FE_UNDERFLOW;
+
+ if (trap & GFC_FPE_INEXACT)
+ mode_set |= FE_INEXACT;
+ if (notrap & GFC_FPE_INEXACT)
+ mode_clr |= FE_INEXACT;
+
+ /* Clear stalled exception flags. */
+ feclearexcept (FE_ALL_EXCEPT);
+
+ feenableexcept (mode_set);
+ fedisableexcept (mode_clr);
+}
+
+int get_fpu_except_flags (void)
+{
+ int result, set_excepts;
+ result = 0;
+ set_excepts = fetestexcept (FE_ALL_EXCEPT);
+
+ if (set_excepts & FE_INVALID)
+ result |= GFC_FPE_INVALID;
+ if (set_excepts & FE_DIVBYZERO)
+ result |= GFC_FPE_ZERO;
+ if (set_excepts & FE_OVERFLOW)
+ result |= GFC_FPE_OVERFLOW;
+ if (set_excepts & FE_UNDERFLOW)
+ result |= GFC_FPE_UNDERFLOW;
+ if (set_excepts & FE_INEXACT)
+ result |= GFC_FPE_INEXACT;
+
+ return result;
+}
+
+void set_fpu_except_flags (int set, int clear)
+{
+ unsigned int exc_set = 0, exc_clr = 0;
+
+ if (set & GFC_FPE_INVALID)
+ exc_set |= FE_INVALID;
+ else if (clear & GFC_FPE_INVALID)
+ exc_clr |= FE_INVALID;
+
+ if (set & GFC_FPE_ZERO)
+ exc_set |= FE_DIVBYZERO;
+ else if (clear & GFC_FPE_ZERO)
+ exc_clr |= FE_DIVBYZERO;
+
+ if (set & GFC_FPE_OVERFLOW)
+ exc_set |= FE_OVERFLOW;
+ else if (clear & GFC_FPE_OVERFLOW)
+ exc_clr |= FE_OVERFLOW;
+
+ if (set & GFC_FPE_UNDERFLOW)
+ exc_set |= FE_UNDERFLOW;
+ else if (clear & GFC_FPE_UNDERFLOW)
+ exc_clr |= FE_UNDERFLOW;
+
+ if (set & GFC_FPE_INEXACT)
+ exc_set |= FE_INEXACT;
+ else if (clear & GFC_FPE_INEXACT)
+ exc_clr |= FE_INEXACT;
+
+ feclearexcept (exc_clr);
+ feraiseexcept (exc_set);
+}
+
+void get_fpu_state (void *state)
+{
+ fegetenv (state);
+}
+
+void set_fpu_state (void *state)
+{
+ fesetenv (state);
+}
+
+int get_fpu_rounding_mode (void)
+{
+ int rnd_mode;
+ rnd_mode = fegetround();
+
+ switch (rnd_mode)
+ {
+ case FE_TONEAREST:
+ return GFC_FPE_TONEAREST;
+ case FE_UPWARD:
+ return GFC_FPE_UPWARD;
+ case FE_DOWNWARD:
+ return GFC_FPE_DOWNWARD;
+ case FE_TOWARDZERO:
+ return GFC_FPE_TOWARDZERO;
+ default:
+ return 0; /* Should be unreachable. */
+ }
+}
+
+void set_fpu_rounding_mode (int round)
+{
+ int rnd_mode;
+
+ switch (round)
+ {
+ case GFC_FPE_TONEAREST:
+ rnd_mode = FE_TONEAREST;
+ break;
+ case GFC_FPE_UPWARD:
+ rnd_mode = FE_UPWARD;
+ break;
+ case GFC_FPE_DOWNWARD:
+ rnd_mode = FE_DOWNWARD;
+ break;
+ case GFC_FPE_TOWARDZERO:
+ rnd_mode = FE_TOWARDZERO;
+ break;
+ default:
+ return; /* Should be unreachable. */
+ }
+
+ fesetround (rnd_mode);
+}
+
+int support_fpu_flag (int flag)
+{
+ if (flag & GFC_FPE_DENORMAL)
+ return 0;
+
+ return 1;
+}
+
+int support_fpu_trap (int flag)
+{
+ if (flag & GFC_FPE_DENORMAL)
+ return 0;
+
+ return 1;
+}
+
+int support_fpu_rounding_mode(int mode __attribute__((unused)))
+{
+ return 1;
+}
+
+/* The following are not supported. */
+
+int support_fpu_underflow_control(int kind __attribute__((unused)))
+{
+ return 0;
+}
+
+int get_fpu_underflow_mode(void)
+{
+ return 0;
+}
+
+void set_fpu_underflow_mode(int gradual __attribute__((unused)))
+{
+}
diff --git a/libgfortran/configure.host b/libgfortran/configure.host
index b15969f0e65..291188d19c2 100644
--- a/libgfortran/configure.host
+++ b/libgfortran/configure.host
@@ -61,6 +61,15 @@ case "${host_cpu}" in
ieee_support='yes'
;;
esac
+ ;;
+
+ powerpc*)
+ case "${host_os}" in
+ darwin*)
+ fpu_host='fpu-macppc'
+ ieee_support='yes'
+ ;;
+ esac
esac
--
2.39.3 (Apple Git-146)
