xref: /PHP-5.6/Zend/zend_float.h (revision 3537e95d)
1 /*
2    +----------------------------------------------------------------------+
3    | Zend Engine                                                          |
4    +----------------------------------------------------------------------+
5    | Copyright (c) 1998-2016 Zend Technologies Ltd. (http://www.zend.com) |
6    +----------------------------------------------------------------------+
7    | This source file is subject to version 2.00 of the Zend license,     |
8    | that is bundled with this package in the file LICENSE, and is        |
9    | available through the world-wide-web at the following url:           |
10    | http://www.zend.com/license/2_00.txt.                                |
11    | If you did not receive a copy of the Zend license and are unable to  |
12    | obtain it through the world-wide-web, please send a note to          |
13    | license@zend.com so we can mail you a copy immediately.              |
14    +----------------------------------------------------------------------+
15    | Authors: Christian Seiler <chris_se@gmx.net>                         |
16    +----------------------------------------------------------------------+
17 */
18 
19 /* $Id$ */
20 
21 #ifndef ZEND_FLOAT_H
22 #define ZEND_FLOAT_H
23 
24 BEGIN_EXTERN_C()
25 
26 /*
27   Define functions for FP initialization and de-initialization.
28 */
29 extern ZEND_API void zend_init_fpu(TSRMLS_D);
30 extern ZEND_API void zend_shutdown_fpu(TSRMLS_D);
31 extern ZEND_API void zend_ensure_fpu_mode(TSRMLS_D);
32 
33 END_EXTERN_C()
34 
35 /* Copy of the contents of xpfpa.h (which is under public domain)
36    See http://wiki.php.net/rfc/rounding for details.
37 
38    Cross Platform Floating Point Arithmetics
39 
40    This header file defines several platform-dependent macros that ensure
41    equal and deterministic floating point behaviour across several platforms,
42    compilers and architectures.
43 
44    The current macros are currently only used on x86 and x86_64 architectures,
45    on every other architecture, these macros expand to NOPs. This assumes that
46    other architectures do not have an internal precision and the operhand types
47    define the computational precision of floating point operations. This
48    assumption may be false, in that case, the author is interested in further
49    details on the other platform.
50 
51    For further details, please visit:
52    http://www.christian-seiler.de/projekte/fpmath/
53 
54    Version: 20090317 */
55 
56 /*
57  Implementation notes:
58 
59  x86_64:
60   - Since all x86_64 compilers use SSE by default, it is probably unecessary
61     to use these macros there. We define them anyway since we are too lazy
62     to differentiate the architecture. Also, the compiler option -mfpmath=i387
63     justifies this decision.
64 
65  General:
66   - It would be nice if one could detect whether SSE if used for math via some
67     funky compiler defines and if so, make the macros go to NOPs. Any ideas
68     on how to do that?
69 
70  MS Visual C:
71   - Since MSVC users tipically don't use autoconf or CMake, we will detect
72     MSVC via compile time define. Floating point precision change isn't
73     supported on 64 bit platforms, so it's NOP. See
74     http://msdn.microsoft.com/en-us/library/c9676k6h(v=vs.110).aspx
75 */
76 
77 /* MSVC detection (MSVC people usually don't use autoconf) */
78 #if defined(_MSC_VER) && !defined(_WIN64)
79 # if _MSC_VER >= 1500
80    /* Visual C++ 2008 or higher, supports _controlfp_s */
81 #  define HAVE__CONTROLFP_S
82 # else
83    /* Visual C++ (up to 2005), supports _controlfp */
84 #  define HAVE__CONTROLFP
85 # endif /* MSC_VER >= 1500 */
86   /* Tell MSVC optimizer that we access FP environment */
87 # if _MSC_VER >= 1500
88 #  pragma fenv_access (on)
89 # endif
90 #endif /* _MSC_VER */
91 
92 #ifdef HAVE__CONTROLFP_S
93 
94 /* float.h defines _controlfp_s */
95 # include <float.h>
96 
97 # define XPFPA_HAVE_CW 1
98 # define XPFPA_CW_DATATYPE \
99             unsigned int
100 
101 # define XPFPA_STORE_CW(vptr) do { \
102             _controlfp_s((unsigned int *)(vptr), 0, 0); \
103         } while (0)
104 
105 # define XPFPA_RESTORE_CW(vptr) do { \
106             unsigned int _xpfpa_fpu_cw; \
107             _controlfp_s(&_xpfpa_fpu_cw, *((unsigned int *)(vptr)), _MCW_PC); \
108         } while (0)
109 
110 # define XPFPA_DECLARE \
111             unsigned int _xpfpa_fpu_oldcw, _xpfpa_fpu_cw;
112 
113 # define XPFPA_SWITCH_DOUBLE() do { \
114             _controlfp_s(&_xpfpa_fpu_cw, 0, 0); \
115             _xpfpa_fpu_oldcw = _xpfpa_fpu_cw; \
116             _controlfp_s(&_xpfpa_fpu_cw, _PC_53, _MCW_PC); \
117         } while (0)
118 # define XPFPA_SWITCH_SINGLE() do { \
119             _controlfp_s(&_xpfpa_fpu_cw, 0, 0); \
120             _xpfpa_fpu_oldcw = _xpfpa_fpu_cw; \
121             _controlfp_s(&_xpfpa_fpu_cw, _PC_24, _MCW_PC); \
122         } while (0)
123 /* NOTE: This only sets internal precision. MSVC does NOT support double-
124    extended precision! */
125 # define XPFPA_SWITCH_DOUBLE_EXTENDED() do { \
126             _controlfp_s(&_xpfpa_fpu_cw, 0, 0); \
127             _xpfpa_fpu_oldcw = _xpfpa_fpu_cw; \
128             _controlfp_s(&_xpfpa_fpu_cw, _PC_64, _MCW_PC); \
129         } while (0)
130 # define XPFPA_RESTORE() \
131             _controlfp_s(&_xpfpa_fpu_cw, _xpfpa_fpu_oldcw, _MCW_PC)
132 /* We do NOT use the volatile return trick since _controlfp_s is a function
133    call and thus FP registers are saved in memory anyway. However, we do use
134    a variable to ensure that the expression passed into val will be evaluated
135    *before* switching back contexts. */
136 # define XPFPA_RETURN_DOUBLE(val) \
137             do { \
138                 double _xpfpa_result = (val); \
139                 XPFPA_RESTORE(); \
140                 return _xpfpa_result; \
141             } while (0)
142 # define XPFPA_RETURN_SINGLE(val) \
143             do { \
144                 float _xpfpa_result = (val); \
145                 XPFPA_RESTORE(); \
146                 return _xpfpa_result; \
147             } while (0)
148 /* This won't work, but we add a macro for it anyway. */
149 # define XPFPA_RETURN_DOUBLE_EXTENDED(val) \
150             do { \
151                 long double _xpfpa_result = (val); \
152                 XPFPA_RESTORE(); \
153                 return _xpfpa_result; \
154             } while (0)
155 
156 #elif defined(HAVE__CONTROLFP)
157 
158 /* float.h defines _controlfp */
159 # include <float.h>
160 
161 # define XPFPA_DECLARE \
162             unsigned int _xpfpa_fpu_oldcw;
163 
164 # define XPFPA_HAVE_CW 1
165 # define XPFPA_CW_DATATYPE \
166             unsigned int
167 
168 # define XPFPA_STORE_CW(vptr) do { \
169             *((unsigned int *)(vptr)) = _controlfp(0, 0); \
170         } while (0)
171 
172 # define XPFPA_RESTORE_CW(vptr) do { \
173             _controlfp(*((unsigned int *)(vptr)), _MCW_PC); \
174         } while (0)
175 
176 # define XPFPA_SWITCH_DOUBLE() do { \
177             _xpfpa_fpu_oldcw = _controlfp(0, 0); \
178             _controlfp(_PC_53, _MCW_PC); \
179         } while (0)
180 # define XPFPA_SWITCH_SINGLE() do { \
181             _xpfpa_fpu_oldcw = _controlfp(0, 0); \
182             _controlfp(_PC_24, _MCW_PC); \
183         } while (0)
184 /* NOTE: This will only work as expected on MinGW. */
185 # define XPFPA_SWITCH_DOUBLE_EXTENDED() do { \
186             _xpfpa_fpu_oldcw = _controlfp(0, 0); \
187             _controlfp(_PC_64, _MCW_PC); \
188         } while (0)
189 # define XPFPA_RESTORE() \
190             _controlfp(_xpfpa_fpu_oldcw, _MCW_PC)
191 /* We do NOT use the volatile return trick since _controlfp is a function
192    call and thus FP registers are saved in memory anyway. However, we do use
193    a variable to ensure that the expression passed into val will be evaluated
194    *before* switching back contexts. */
195 # define XPFPA_RETURN_DOUBLE(val) \
196             do { \
197                 double _xpfpa_result = (val); \
198                 XPFPA_RESTORE(); \
199                 return _xpfpa_result; \
200             } while (0)
201 # define XPFPA_RETURN_SINGLE(val) \
202             do { \
203                 float _xpfpa_result = (val); \
204                 XPFPA_RESTORE(); \
205                 return _xpfpa_result; \
206             } while (0)
207 /* This will only work on MinGW */
208 # define XPFPA_RETURN_DOUBLE_EXTENDED(val) \
209             do { \
210                 long double _xpfpa_result = (val); \
211                 XPFPA_RESTORE(); \
212                 return _xpfpa_result; \
213             } while (0)
214 
215 #elif defined(HAVE__FPU_SETCW) /* glibc systems */
216 
217 /* fpu_control.h defines _FPU_[GS]ETCW */
218 # include <fpu_control.h>
219 
220 # define XPFPA_DECLARE \
221             fpu_control_t _xpfpa_fpu_oldcw, _xpfpa_fpu_cw;
222 
223 # define XPFPA_HAVE_CW 1
224 # define XPFPA_CW_DATATYPE \
225             fpu_control_t
226 
227 # define XPFPA_STORE_CW(vptr) do { \
228             _FPU_GETCW((*((fpu_control_t *)(vptr)))); \
229         } while (0)
230 
231 # define XPFPA_RESTORE_CW(vptr) do { \
232             _FPU_SETCW((*((fpu_control_t *)(vptr)))); \
233         } while (0)
234 
235 # define XPFPA_SWITCH_DOUBLE() do { \
236             _FPU_GETCW(_xpfpa_fpu_oldcw); \
237             _xpfpa_fpu_cw = (_xpfpa_fpu_oldcw & ~_FPU_EXTENDED & ~_FPU_SINGLE) | _FPU_DOUBLE; \
238             _FPU_SETCW(_xpfpa_fpu_cw); \
239         } while (0)
240 # define XPFPA_SWITCH_SINGLE() do { \
241             _FPU_GETCW(_xpfpa_fpu_oldcw); \
242             _xpfpa_fpu_cw = (_xpfpa_fpu_oldcw & ~_FPU_EXTENDED & ~_FPU_DOUBLE) | _FPU_SINGLE; \
243             _FPU_SETCW(_xpfpa_fpu_cw); \
244         } while (0)
245 # define XPFPA_SWITCH_DOUBLE_EXTENDED()  do { \
246             _FPU_GETCW(_xpfpa_fpu_oldcw); \
247             _xpfpa_fpu_cw = (_xpfpa_fpu_oldcw & ~_FPU_SINGLE & ~_FPU_DOUBLE) | _FPU_EXTENDED; \
248             _FPU_SETCW(_xpfpa_fpu_cw); \
249         } while (0)
250 # define XPFPA_RESTORE() \
251             _FPU_SETCW(_xpfpa_fpu_oldcw)
252 /* We use a temporary volatile variable (in a new block) in order to ensure
253    that the optimizer does not mis-optimize the instructions. Also, a volatile
254    variable ensures truncation to correct precision. */
255 # define XPFPA_RETURN_DOUBLE(val) \
256             do { \
257                 volatile double _xpfpa_result = (val); \
258                 XPFPA_RESTORE(); \
259                 return _xpfpa_result; \
260             } while (0)
261 # define XPFPA_RETURN_SINGLE(val) \
262             do { \
263                 volatile float _xpfpa_result = (val); \
264                 XPFPA_RESTORE(); \
265                 return _xpfpa_result; \
266             } while (0)
267 # define XPFPA_RETURN_DOUBLE_EXTENDED(val) \
268             do { \
269                 volatile long double _xpfpa_result = (val); \
270                 XPFPA_RESTORE(); \
271                 return _xpfpa_result; \
272             } while (0)
273 
274 #elif defined(HAVE_FPSETPREC) /* FreeBSD */
275 
276 /* fpu_control.h defines _FPU_[GS]ETCW */
277 # include <machine/ieeefp.h>
278 
279 # define XPFPA_DECLARE \
280             fp_prec_t _xpfpa_fpu_oldprec;
281 
282 # define XPFPA_HAVE_CW 1
283 # define XPFPA_CW_DATATYPE \
284             fp_prec_t
285 
286 # define XPFPA_STORE_CW(vptr) do { \
287             *((fp_prec_t *)(vptr)) = fpgetprec(); \
288         } while (0)
289 
290 # define XPFPA_RESTORE_CW(vptr) do { \
291             fpsetprec(*((fp_prec_t *)(vptr))); \
292         } while (0)
293 
294 # define XPFPA_SWITCH_DOUBLE() do { \
295             _xpfpa_fpu_oldprec = fpgetprec(); \
296             fpsetprec(FP_PD); \
297         } while (0)
298 # define XPFPA_SWITCH_SINGLE() do { \
299             _xpfpa_fpu_oldprec = fpgetprec(); \
300             fpsetprec(FP_PS); \
301         } while (0)
302 # define XPFPA_SWITCH_DOUBLE_EXTENDED() do { \
303             _xpfpa_fpu_oldprec = fpgetprec(); \
304             fpsetprec(FP_PE); \
305         } while (0)
306 # define XPFPA_RESTORE() \
307             fpsetprec(_xpfpa_fpu_oldprec)
308 /* We use a temporary volatile variable (in a new block) in order to ensure
309    that the optimizer does not mis-optimize the instructions. Also, a volatile
310    variable ensures truncation to correct precision. */
311 # define XPFPA_RETURN_DOUBLE(val) \
312             do { \
313                 volatile double _xpfpa_result = (val); \
314                 XPFPA_RESTORE(); \
315                 return _xpfpa_result; \
316             } while (0)
317 # define XPFPA_RETURN_SINGLE(val) \
318             do { \
319                 volatile float _xpfpa_result = (val); \
320                 XPFPA_RESTORE(); \
321                 return _xpfpa_result; \
322             } while (0)
323 # define XPFPA_RETURN_DOUBLE_EXTENDED(val) \
324             do { \
325                 volatile long double _xpfpa_result = (val); \
326                 XPFPA_RESTORE(); \
327                 return _xpfpa_result; \
328             } while (0)
329 
330 #elif defined(HAVE_FPU_INLINE_ASM_X86)
331 
332 /*
333   Custom x86 inline assembler implementation.
334 
335   This implementation does not use predefined wrappers of the OS / compiler
336   but rather uses x86/x87 inline assembler directly. Basic instructions:
337 
338   fnstcw - Store the FPU control word in a variable
339   fldcw  - Load the FPU control word from a variable
340 
341   Bits (only bits 8 and 9 are relevant, bits 0 to 7 are for other things):
342      0x0yy: Single precision
343      0x1yy: Reserved
344      0x2yy: Double precision
345      0x3yy: Double-extended precision
346 
347   We use an unsigned int for the datatype. glibc sources add __mode__ (__HI__)
348   attribute to it (HI stands for half-integer according to docs). It is unclear
349   what the does exactly and how portable it is.
350 
351   The assembly syntax works with GNU CC, Intel CC and Sun CC.
352 */
353 
354 # define XPFPA_DECLARE \
355             unsigned int _xpfpa_fpu_oldcw, _xpfpa_fpu_cw;
356 
357 # define XPFPA_HAVE_CW 1
358 # define XPFPA_CW_DATATYPE \
359             unsigned int
360 
361 # define XPFPA_STORE_CW(vptr) do { \
362             __asm__ __volatile__ ("fnstcw %0" : "=m" (*((unsigned int *)(vptr)))); \
363         } while (0)
364 
365 # define XPFPA_RESTORE_CW(vptr) do { \
366             __asm__ __volatile__ ("fldcw %0" : : "m" (*((unsigned int *)(vptr)))); \
367         } while (0)
368 
369 # define XPFPA_SWITCH_DOUBLE() do { \
370             __asm__ __volatile__ ("fnstcw %0" : "=m" (*&_xpfpa_fpu_oldcw)); \
371             _xpfpa_fpu_cw = (_xpfpa_fpu_oldcw & ~0x100) | 0x200; \
372             __asm__ __volatile__ ("fldcw %0" : : "m" (*&_xpfpa_fpu_cw)); \
373         } while (0)
374 # define XPFPA_SWITCH_SINGLE() do { \
375             __asm__ __volatile__ ("fnstcw %0" : "=m" (*&_xpfpa_fpu_oldcw)); \
376             _xpfpa_fpu_cw = (_xpfpa_fpu_oldcw & ~0x300); \
377             __asm__ __volatile__ ("fldcw %0" : : "m" (*&_xpfpa_fpu_cw)); \
378         } while (0)
379 # define XPFPA_SWITCH_DOUBLE_EXTENDED() do { \
380             __asm__ __volatile__ ("fnstcw %0" : "=m" (*&_xpfpa_fpu_oldcw)); \
381             _xpfpa_fpu_cw = _xpfpa_fpu_oldcw | 0x300; \
382             __asm__ __volatile__ ("fldcw %0" : : "m" (*&_xpfpa_fpu_cw)); \
383         } while (0)
384 # define XPFPA_RESTORE() \
385             __asm__ __volatile__ ("fldcw %0" : : "m" (*&_xpfpa_fpu_oldcw))
386 /* We use a temporary volatile variable (in a new block) in order to ensure
387    that the optimizer does not mis-optimize the instructions. Also, a volatile
388    variable ensures truncation to correct precision. */
389 # define XPFPA_RETURN_DOUBLE(val) \
390             do { \
391                 volatile double _xpfpa_result = (val); \
392                 XPFPA_RESTORE(); \
393                 return _xpfpa_result; \
394             } while (0)
395 # define XPFPA_RETURN_SINGLE(val) \
396             do { \
397                 volatile float _xpfpa_result = (val); \
398                 XPFPA_RESTORE(); \
399                 return _xpfpa_result; \
400             } while (0)
401 # define XPFPA_RETURN_DOUBLE_EXTENDED(val) \
402             do { \
403                 volatile long double _xpfpa_result = (val); \
404                 XPFPA_RESTORE(); \
405                 return _xpfpa_result; \
406             } while (0)
407 
408 #else /* FPU CONTROL */
409 
410 /*
411   This is either not an x87 FPU or the inline assembly syntax was not
412   recognized. In any case, default to NOPs for the macros and hope the
413   generated code will behave as planned.
414 */
415 # define XPFPA_DECLARE                      /* NOP */
416 # define XPFPA_HAVE_CW                      0
417 # define XPFPA_CW_DATATYPE                  unsigned int
418 # define XPFPA_STORE_CW(variable)           /* NOP */
419 # define XPFPA_RESTORE_CW(variable)         /* NOP */
420 # define XPFPA_SWITCH_DOUBLE()              /* NOP */
421 # define XPFPA_SWITCH_SINGLE()              /* NOP */
422 # define XPFPA_SWITCH_DOUBLE_EXTENDED()     /* NOP */
423 # define XPFPA_RESTORE()                    /* NOP */
424 # define XPFPA_RETURN_DOUBLE(val)           return (val)
425 # define XPFPA_RETURN_SINGLE(val)           return (val)
426 # define XPFPA_RETURN_DOUBLE_EXTENDED(val)  return (val)
427 
428 #endif /* FPU CONTROL */
429 
430 #endif
431