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