1 /* Private floating point rounding and exceptions handling. C-SKY version.
2 Copyright (C) 2018-2023 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 CSKY_FENV_PRIVATE_H
20 #define CSKY_FENV_PRIVATE_H 1
21
22 #include <fenv.h>
23 #include <fpu_control.h>
24 #include <fenv_libc.h>
25
26 static __always_inline void
27 libc_feholdexcept_vfp (fenv_t *envp)
28 {
29 fpu_control_t fpsr, fpcr;
30
31 _FPU_GETCW (fpcr);
32 envp->__fpcr = fpcr;
33
34 _FPU_GETFPSR (fpsr);
35 envp->__fpsr = fpsr;
36
37 /* Now set all exceptions to non-stop. */
38 fpcr &= ~FE_ALL_EXCEPT;
39
40 /* And clear all exception flags. */
41 fpsr &= ~(FE_ALL_EXCEPT << CAUSE_SHIFT);
42
43 _FPU_SETFPSR (fpsr);
44
45 _FPU_SETCW (fpcr);
46 }
47
48 static __always_inline void
49 libc_fesetround_vfp (int round)
50 {
51 fpu_control_t fpcr;
52
53 _FPU_GETCW (fpcr);
54
55 /* Set new rounding mode if different. */
56 if (__glibc_unlikely ((fpcr & FE_DOWNWARD) != round))
57 _FPU_SETCW ((fpcr & ~FE_DOWNWARD) | round);
58 }
59
60 static __always_inline void
61 libc_feholdexcept_setround_vfp (fenv_t *envp, int round)
62 {
63 fpu_control_t fpsr, fpcr;
64
65 _FPU_GETCW (fpcr);
66 envp->__fpcr = fpcr;
67
68 _FPU_GETFPSR (fpsr);
69 envp->__fpsr = fpsr;
70
71 /* Clear exception flags, set all exceptions to non-stop,
72 and set new rounding mode. */
73 fpsr &= ~(FE_ALL_EXCEPT << CAUSE_SHIFT);
74 _FPU_SETFPSR (fpsr);
75
76 fpcr &= ~(FE_ALL_EXCEPT | FE_DOWNWARD);
77 _FPU_SETCW (fpcr | round);
78 }
79
80 static __always_inline void
81 libc_feholdsetround_vfp (fenv_t *envp, int round)
82 {
83 fpu_control_t fpcr;
84
85 _FPU_GETCW (fpcr);
86 envp->__fpcr = fpcr;
87
88 /* Set new rounding mode if different. */
89 if (__glibc_unlikely ((fpcr & FE_DOWNWARD) != round))
90 _FPU_SETCW ((fpcr & ~FE_DOWNWARD) | round);
91 }
92
93 static __always_inline void
94 libc_feresetround_vfp (fenv_t *envp)
95 {
96 fpu_control_t fpcr, round;
97
98 _FPU_GETCW (fpcr);
99
100 /* Check whether rounding modes are different. */
101 round = (envp->__fpcr ^ fpcr) & FE_DOWNWARD;
102
103 /* Restore the rounding mode if it was changed. */
104 if (__glibc_unlikely (round != 0))
105 _FPU_SETCW (fpcr ^ round);
106 }
107
108 static __always_inline int
109 libc_fetestexcept_vfp (int ex)
110 {
111 fpu_control_t fpsr;
112
113 _FPU_GETFPSR (fpsr);
114 fpsr = fpsr >> CAUSE_SHIFT;
115 return fpsr & ex & FE_ALL_EXCEPT;
116 }
117
118 static __always_inline void
119 libc_fesetenv_vfp (const fenv_t *envp)
120 {
121 fpu_control_t fpcr, fpsr, new_fpcr, new_fpsr;
122
123 _FPU_GETCW (fpcr);
124 _FPU_GETFPSR (fpsr);
125
126 new_fpcr = envp->__fpcr;
127 new_fpsr = envp->__fpsr;
128
129 if (__glibc_unlikely (fpsr ^ new_fpsr) != 0)
130 _FPU_SETFPSR (new_fpsr);
131
132 if (__glibc_unlikely (fpcr ^ new_fpcr) != 0)
133 _FPU_SETCW (new_fpcr);
134 }
135
136 static __always_inline int
137 libc_feupdateenv_test_vfp (const fenv_t *envp, int ex)
138 {
139 fpu_control_t fpcr, fpsr, new_fpcr, new_fpsr, excepts;
140
141 _FPU_GETCW (fpcr);
142 _FPU_GETFPSR (fpsr);
143
144 /* Merge current exception flags with the saved fenv. */
145 excepts = (fpsr >> CAUSE_SHIFT) & FE_ALL_EXCEPT;
146 new_fpcr = envp->__fpcr;
147 new_fpsr = envp->__fpsr | (excepts << CAUSE_SHIFT);
148
149 /* Write FCR and FESR if different. */
150 if (__glibc_unlikely (fpsr ^ new_fpsr) != 0)
151 _FPU_SETFPSR (new_fpsr);
152
153 if (__glibc_unlikely (fpcr ^ new_fpcr) != 0)
154 _FPU_SETCW (new_fpcr);
155
156 /* Raise the exceptions if enabled in the new FP state. */
157 if (__glibc_unlikely (excepts & new_fpcr))
158 __feraiseexcept (excepts);
159
160 return excepts & ex;
161 }
162
163 static __always_inline void
164 libc_feupdateenv_vfp (const fenv_t *envp)
165 {
166 libc_feupdateenv_test_vfp (envp, 0);
167 }
168
169 static __always_inline void
170 libc_feholdsetround_vfp_ctx (struct rm_ctx *ctx, int r)
171 {
172 fpu_control_t fpcr, fpsr, round;
173
174 _FPU_GETCW (fpcr);
175 _FPU_GETFPSR (fpsr);
176 ctx->updated_status = false;
177 ctx->env.__fpcr = fpcr;
178 ctx->env.__fpsr = fpsr;
179
180 /* Check whether rounding modes are different. */
181 round = (fpcr ^ r) & FE_DOWNWARD;
182
183 /* Set the rounding mode if changed. */
184 if (__glibc_unlikely (round != 0))
185 {
186 ctx->updated_status = true;
187 _FPU_SETCW (fpcr ^ round);
188 }
189 }
190
191 static __always_inline void
192 libc_feresetround_vfp_ctx (struct rm_ctx *ctx)
193 {
194 /* Restore the rounding mode if updated. */
195 if (__glibc_unlikely (ctx->updated_status))
196 {
197 fpu_control_t fpcr;
198
199 _FPU_GETCW (fpcr);
200 fpcr = (fpcr & ~FE_DOWNWARD) | (ctx->env.__fpcr & FE_DOWNWARD);
201 _FPU_SETCW (fpcr);
202 }
203 }
204
205 static __always_inline void
206 libc_fesetenv_vfp_ctx (struct rm_ctx *ctx)
207 {
208 fpu_control_t fpcr, fpsr, new_fpcr, new_fpsr;
209
210 _FPU_GETCW (fpcr);
211 _FPU_GETFPSR (fpsr);
212
213 new_fpcr = ctx->env.__fpcr;
214 new_fpsr = ctx->env.__fpsr;
215
216 if (__glibc_unlikely (fpsr ^ new_fpsr) != 0)
217 _FPU_SETFPSR (new_fpsr);
218
219 if (__glibc_unlikely (fpcr ^ new_fpcr) != 0)
220 _FPU_SETCW (new_fpcr);
221 }
222
223 #define libc_feholdexcept libc_feholdexcept_vfp
224 #define libc_feholdexceptf libc_feholdexcept_vfp
225 #define libc_feholdexceptl libc_feholdexcept_vfp
226
227 #define libc_fesetround libc_fesetround_vfp
228 #define libc_fesetroundf libc_fesetround_vfp
229 #define libc_fesetroundl libc_fesetround_vfp
230
231 #define libc_feresetround libc_feresetround_vfp
232 #define libc_feresetroundf libc_feresetround_vfp
233 #define libc_feresetroundl libc_feresetround_vfp
234
235 #define libc_feresetround_noex libc_fesetenv_vfp
236 #define libc_feresetround_noexf libc_fesetenv_vfp
237 #define libc_feresetround_noexl libc_fesetenv_vfp
238
239 #define libc_feholdexcept_setround libc_feholdexcept_setround_vfp
240 #define libc_feholdexcept_setroundf libc_feholdexcept_setround_vfp
241 #define libc_feholdexcept_setroundl libc_feholdexcept_setround_vfp
242
243 #define libc_feholdsetround libc_feholdsetround_vfp
244 #define libc_feholdsetroundf libc_feholdsetround_vfp
245 #define libc_feholdsetroundl libc_feholdsetround_vfp
246
247 #define libc_fetestexcept libc_fetestexcept_vfp
248 #define libc_fetestexceptf libc_fetestexcept_vfp
249 #define libc_fetestexceptl libc_fetestexcept_vfp
250
251 #define libc_fesetenv libc_fesetenv_vfp
252 #define libc_fesetenvf libc_fesetenv_vfp
253 #define libc_fesetenvl libc_fesetenv_vfp
254
255 #define libc_feupdateenv libc_feupdateenv_vfp
256 #define libc_feupdateenvf libc_feupdateenv_vfp
257 #define libc_feupdateenvl libc_feupdateenv_vfp
258
259 #define libc_feupdateenv_test libc_feupdateenv_test_vfp
260 #define libc_feupdateenv_testf libc_feupdateenv_test_vfp
261 #define libc_feupdateenv_testl libc_feupdateenv_test_vfp
262
263 /* We have support for rounding mode context. */
264 #define HAVE_RM_CTX 1
265
266 #define libc_feholdsetround_ctx libc_feholdsetround_vfp_ctx
267 #define libc_feresetround_ctx libc_feresetround_vfp_ctx
268 #define libc_feresetround_noex_ctx libc_fesetenv_vfp_ctx
269
270 #define libc_feholdsetroundf_ctx libc_feholdsetround_vfp_ctx
271 #define libc_feresetroundf_ctx libc_feresetround_vfp_ctx
272 #define libc_feresetround_noexf_ctx libc_fesetenv_vfp_ctx
273
274 #define libc_feholdsetroundl_ctx libc_feholdsetround_vfp_ctx
275 #define libc_feresetroundl_ctx libc_feresetround_vfp_ctx
276 #define libc_feresetround_noexl_ctx libc_fesetenv_vfp_ctx
277
278 #include_next <fenv_private.h>
279
280 #endif /* CSKY_FENV_PRIVATE_H */