sysdeps/arm/fenv_private.h

   1 /* Private floating point rounding and exceptions handling.  ARM VFP version.
   2    Copyright (C) 2014-2024 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library.  If not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #ifndef ARM_FENV_PRIVATE_H
  20 #define ARM_FENV_PRIVATE_H 1
  21
  22 #include <fenv.h>
  23 #include <fpu_control.h>
  24
  25 static __always_inline void
  26 libc_feholdexcept_vfp (fenv_t *envp)
  27 {
  28   fpu_control_t fpscr;
  29
  30   _FPU_GETCW (fpscr);
  31   envp->__cw = fpscr;
  32
  33   /* Clear exception flags and set all exceptions to non-stop.  */
  34   fpscr &= ~_FPU_MASK_EXCEPT;
  35   _FPU_SETCW (fpscr);
  36 }
  37
  38 static __always_inline void
  39 libc_fesetround_vfp (int round)
  40 {
  41   fpu_control_t fpscr;
  42
  43   _FPU_GETCW (fpscr);
  44
  45   /* Set new rounding mode if different.  */
  46   if (__glibc_unlikely ((fpscr & _FPU_MASK_RM) != round))
  47     _FPU_SETCW ((fpscr & ~_FPU_MASK_RM) | round);
  48 }
  49
  50 static __always_inline void
  51 libc_feholdexcept_setround_vfp (fenv_t *envp, int round)
  52 {
  53   fpu_control_t fpscr;
  54
  55   _FPU_GETCW (fpscr);
  56   envp->__cw = fpscr;
  57
  58   /* Clear exception flags, set all exceptions to non-stop,
  59      and set new rounding mode.  */
  60   fpscr &= ~(_FPU_MASK_EXCEPT | _FPU_MASK_RM);
  61   _FPU_SETCW (fpscr | round);
  62 }
  63
  64 static __always_inline void
  65 libc_feholdsetround_vfp (fenv_t *envp, int round)
  66 {
  67   fpu_control_t fpscr;
  68
  69   _FPU_GETCW (fpscr);
  70   envp->__cw = fpscr;
  71
  72   /* Set new rounding mode if different.  */
  73   if (__glibc_unlikely ((fpscr & _FPU_MASK_RM) != round))
  74     _FPU_SETCW ((fpscr & ~_FPU_MASK_RM) | round);
  75 }
  76
  77 static __always_inline void
  78 libc_feresetround_vfp (fenv_t *envp)
  79 {
  80   fpu_control_t fpscr, round;
  81
  82   _FPU_GETCW (fpscr);
  83
  84   /* Check whether rounding modes are different.  */
  85   round = (envp->__cw ^ fpscr) & _FPU_MASK_RM;
  86
  87   /* Restore the rounding mode if it was changed.  */
  88   if (__glibc_unlikely (round != 0))
  89     _FPU_SETCW (fpscr ^ round);
  90 }
  91
  92 static __always_inline int
  93 libc_fetestexcept_vfp (int ex)
  94 {
  95   fpu_control_t fpscr;
  96
  97   _FPU_GETCW (fpscr);
  98   return fpscr & ex & FE_ALL_EXCEPT;
  99 }
 100
 101 static __always_inline void
 102 libc_fesetenv_vfp (const fenv_t *envp)
 103 {
 104   fpu_control_t fpscr, new_fpscr;
 105
 106   _FPU_GETCW (fpscr);
 107   new_fpscr = envp->__cw;
 108
 109   /* Write new FPSCR if different (ignoring NZCV flags).  */
 110   if (__glibc_unlikely (((fpscr ^ new_fpscr) & ~_FPU_MASK_NZCV) != 0))
 111     _FPU_SETCW (new_fpscr);
 112 }
 113
 114 static __always_inline int
 115 libc_feupdateenv_test_vfp (const fenv_t *envp, int ex)
 116 {
 117   fpu_control_t fpscr, new_fpscr;
 118   int excepts;
 119
 120   _FPU_GETCW (fpscr);
 121
 122   /* Merge current exception flags with the saved fenv.  */
 123   excepts = fpscr & FE_ALL_EXCEPT;
 124   new_fpscr = envp->__cw | excepts;
 125
 126   /* Write new FPSCR if different (ignoring NZCV flags).  */
 127   if (__glibc_unlikely (((fpscr ^ new_fpscr) & ~_FPU_MASK_NZCV) != 0))
 128     _FPU_SETCW (new_fpscr);
 129
 130   /* Raise the exceptions if enabled in the new FP state.  */
 131   if (__glibc_unlikely (excepts & (new_fpscr >> FE_EXCEPT_SHIFT)))
 132     __feraiseexcept (excepts);
 133
 134   return excepts & ex;
 135 }
 136
 137 static __always_inline void
 138 libc_feupdateenv_vfp (const fenv_t *envp)
 139 {
 140   libc_feupdateenv_test_vfp (envp, 0);
 141 }
 142
 143 static __always_inline void
 144 libc_feholdsetround_vfp_ctx (struct rm_ctx *ctx, int r)
 145 {
 146   fpu_control_t fpscr, round;
 147
 148   _FPU_GETCW (fpscr);
 149   ctx->updated_status = false;
 150   ctx->env.__cw = fpscr;
 151
 152   /* Check whether rounding modes are different.  */
 153   round = (fpscr ^ r) & _FPU_MASK_RM;
 154
 155   /* Set the rounding mode if changed.  */
 156   if (__glibc_unlikely (round != 0))
 157     {
 158       ctx->updated_status = true;
 159       _FPU_SETCW (fpscr ^ round);
 160     }
 161 }
 162
 163 static __always_inline void
 164 libc_feresetround_vfp_ctx (struct rm_ctx *ctx)
 165 {
 166   /* Restore the rounding mode if updated.  */
 167   if (__glibc_unlikely (ctx->updated_status))
 168     {
 169       fpu_control_t fpscr;
 170
 171       _FPU_GETCW (fpscr);
 172       fpscr = (fpscr & ~_FPU_MASK_RM) | (ctx->env.__cw & _FPU_MASK_RM);
 173       _FPU_SETCW (fpscr);
 174     }
 175 }
 176
 177 static __always_inline void
 178 libc_fesetenv_vfp_ctx (struct rm_ctx *ctx)
 179 {
 180   fpu_control_t fpscr, new_fpscr;
 181
 182   _FPU_GETCW (fpscr);
 183   new_fpscr = ctx->env.__cw;
 184
 185   /* Write new FPSCR if different (ignoring NZCV flags).  */
 186   if (__glibc_unlikely (((fpscr ^ new_fpscr) & ~_FPU_MASK_NZCV) != 0))
 187     _FPU_SETCW (new_fpscr);
 188 }
 189
 190 #ifndef __SOFTFP__
 191
 192 # define libc_feholdexcept  libc_feholdexcept_vfp
 193 # define libc_feholdexceptf libc_feholdexcept_vfp
 194 # define libc_feholdexceptl libc_feholdexcept_vfp
 195
 196 # define libc_fesetround  libc_fesetround_vfp
 197 # define libc_fesetroundf libc_fesetround_vfp
 198 # define libc_fesetroundl libc_fesetround_vfp
 199
 200 # define libc_feresetround  libc_feresetround_vfp
 201 # define libc_feresetroundf libc_feresetround_vfp
 202 # define libc_feresetroundl libc_feresetround_vfp
 203
 204 # define libc_feresetround_noex  libc_fesetenv_vfp
 205 # define libc_feresetround_noexf libc_fesetenv_vfp
 206 # define libc_feresetround_noexl libc_fesetenv_vfp
 207
 208 # define libc_feholdexcept_setround  libc_feholdexcept_setround_vfp
 209 # define libc_feholdexcept_setroundf libc_feholdexcept_setround_vfp
 210 # define libc_feholdexcept_setroundl libc_feholdexcept_setround_vfp
 211
 212 # define libc_feholdsetround  libc_feholdsetround_vfp
 213 # define libc_feholdsetroundf libc_feholdsetround_vfp
 214 # define libc_feholdsetroundl libc_feholdsetround_vfp
 215
 216 # define libc_fetestexcept  libc_fetestexcept_vfp
 217 # define libc_fetestexceptf libc_fetestexcept_vfp
 218 # define libc_fetestexceptl libc_fetestexcept_vfp
 219
 220 # define libc_fesetenv  libc_fesetenv_vfp
 221 # define libc_fesetenvf libc_fesetenv_vfp
 222 # define libc_fesetenvl libc_fesetenv_vfp
 223
 224 # define libc_feupdateenv  libc_feupdateenv_vfp
 225 # define libc_feupdateenvf libc_feupdateenv_vfp
 226 # define libc_feupdateenvl libc_feupdateenv_vfp
 227
 228 # define libc_feupdateenv_test  libc_feupdateenv_test_vfp
 229 # define libc_feupdateenv_testf libc_feupdateenv_test_vfp
 230 # define libc_feupdateenv_testl libc_feupdateenv_test_vfp
 231
 232 /* We have support for rounding mode context.  */
 233 #define HAVE_RM_CTX 1
 234
 235 # define libc_feholdsetround_ctx        libc_feholdsetround_vfp_ctx
 236 # define libc_feresetround_ctx          libc_feresetround_vfp_ctx
 237 # define libc_feresetround_noex_ctx     libc_fesetenv_vfp_ctx
 238
 239 # define libc_feholdsetroundf_ctx       libc_feholdsetround_vfp_ctx
 240 # define libc_feresetroundf_ctx         libc_feresetround_vfp_ctx
 241 # define libc_feresetround_noexf_ctx    libc_fesetenv_vfp_ctx
 242
 243 # define libc_feholdsetroundl_ctx       libc_feholdsetround_vfp_ctx
 244 # define libc_feresetroundl_ctx         libc_feresetround_vfp_ctx
 245 # define libc_feresetround_noexl_ctx    libc_fesetenv_vfp_ctx
 246
 247 #endif
 248
 249 #include_next <fenv_private.h>
 250
 251 #endif /* ARM_FENV_PRIVATE_H */