FM / Zend

/opt/alt/php80/usr/include/php/Zend

Name	Size	Mode	Actions
zend.h	13855	0644	edit dl rm
zend_alloc.h	19293	0644	edit dl rm
zend_alloc_sizes.h	2629	0644	edit dl rm
zend_API.h	92119	0644	edit dl rm
zend_arena.h	6073	0644	edit dl rm
zend_ast.h	12616	0644	edit dl rm
zend_attributes.h	5235	0644	edit dl rm
zend_attributes_arginfo.h	503	0644	edit dl rm
zend_bitset.h	7940	0644	edit dl rm
zend_build.h	1626	0644	edit dl rm
zend_builtin_functions.h	1513	0644	edit dl rm
zend_builtin_functions_arginfo.h	13014	0644	edit dl rm
zend_closures.h	2216	0644	edit dl rm
zend_closures_arginfo.h	1751	0644	edit dl rm
zend_compile.h	44860	0644	edit dl rm
zend_config.h	32	0644	edit dl rm
zend_constants.h	6485	0644	edit dl rm
zend_cpuinfo.h	7492	0644	edit dl rm
zend_dtrace.h	2050	0644	edit dl rm
zend_errors.h	2400	0644	edit dl rm
zend_exceptions.h	4114	0644	edit dl rm
zend_exceptions_arginfo.h	8098	0644	edit dl rm
zend_execute.h	18683	0644	edit dl rm
zend_extensions.h	6194	0644	edit dl rm
zend_float.h	15438	0644	edit dl rm
zend_gc.h	3942	0644	edit dl rm
zend_gdb.h	1420	0644	edit dl rm
zend_generators.h	7433	0644	edit dl rm
zend_generators_arginfo.h	2015	0644	edit dl rm
zend_globals.h	8066	0644	edit dl rm
zend_globals_macros.h	2810	0644	edit dl rm
zend_hash.h	38614	0644	edit dl rm
zend_highlight.h	2289	0644	edit dl rm
zend_inheritance.h	1967	0644	edit dl rm
zend_ini.h	10117	0644	edit dl rm
zend_ini_parser.h	2730	0644	edit dl rm
zend_ini_scanner.h	1889	0644	edit dl rm
zend_ini_scanner_defs.h	225	0644	edit dl rm
zend_interfaces.h	4437	0644	edit dl rm
zend_interfaces_arginfo.h	5287	0644	edit dl rm
zend_istdiostream.h	1537	0644	edit dl rm
zend_iterators.h	3581	0644	edit dl rm
zend_language_parser.h	5960	0644	edit dl rm
zend_language_scanner.h	3058	0644	edit dl rm
zend_language_scanner_defs.h	310	0644	edit dl rm
zend_list.h	3475	0644	edit dl rm
zend_llist.h	3802	0644	edit dl rm
zend_long.h	4246	0644	edit dl rm
zend_map_ptr.h	3474	0644	edit dl rm
zend_modules.h	4830	0644	edit dl rm
zend_multibyte.h	4897	0644	edit dl rm
zend_multiply.h	9846	0644	edit dl rm
zend_objects.h	1814	0644	edit dl rm
zend_objects_API.h	4701	0644	edit dl rm
zend_object_handlers.h	13854	0644	edit dl rm
zend_observer.h	3419	0644	edit dl rm
zend_operators.h	31181	0644	edit dl rm
zend_portability.h	20848	0644	edit dl rm
zend_ptr_stack.h	4306	0644	edit dl rm
zend_range_check.h	3000	0644	edit dl rm
zend_signal.h	4084	0644	edit dl rm
zend_smart_str.h	5378	0644	edit dl rm
zend_smart_string.h	4237	0644	edit dl rm
zend_smart_string_public.h	1240	0644	edit dl rm
zend_smart_str_public.h	1127	0644	edit dl rm
zend_sort.h	1535	0644	edit dl rm
zend_stack.h	2364	0644	edit dl rm
zend_stream.h	3558	0644	edit dl rm
zend_string.h	18710	0644	edit dl rm
zend_strtod.h	1854	0644	edit dl rm
zend_strtod_int.h	3414	0644	edit dl rm
zend_system_id.h	1404	0644	edit dl rm
zend_ts_hash.h	5469	0644	edit dl rm
zend_types.h	44902	0644	edit dl rm
zend_type_info.h	3755	0644	edit dl rm
zend_variables.h	3065	0644	edit dl rm
zend_virtual_cwd.h	12613	0644	edit dl rm
zend_vm.h	1952	0644	edit dl rm
zend_vm_def.h	279918	0644	edit dl rm
zend_vm_execute.h	2073552	0644	edit dl rm
zend_vm_handlers.h	91415	0644	edit dl rm
zend_vm_opcodes.h	12523	0644	edit dl rm
zend_vm_trace_handlers.h	3212	0644	edit dl rm
zend_vm_trace_lines.h	1755	0644	edit dl rm
zend_vm_trace_map.h	2661	0644	edit dl rm
zend_weakrefs.h	1713	0644	edit dl rm
zend_weakrefs_arginfo.h	2549	0644	edit dl rm

Edit: /opt/alt/php80/usr/include/php/Zend/zend_float.h (15438B)

/*
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
   | Copyright (c) Zend Technologies Ltd. (http://www.zend.com)           |
   +----------------------------------------------------------------------+
   | This source file is subject to version 2.00 of the Zend license,     |
   | that is bundled with this package in the file LICENSE, and is        |
   | available through the world-wide-web at the following url:           |
   | http://www.zend.com/license/2_00.txt.                                |
   | If you did not receive a copy of the Zend license and are unable to  |
   | obtain it through the world-wide-web, please send a note to          |
   | license@zend.com so we can mail you a copy immediately.              |
   +----------------------------------------------------------------------+
   | Authors: Christian Seiler <chris_se@gmx.net>                         |
   +----------------------------------------------------------------------+
*/

#ifndef ZEND_FLOAT_H
#define ZEND_FLOAT_H

BEGIN_EXTERN_C()

/*
  Define functions for FP initialization and de-initialization.
*/
extern ZEND_API void zend_init_fpu(void);
extern ZEND_API void zend_shutdown_fpu(void);
extern ZEND_API void zend_ensure_fpu_mode(void);

END_EXTERN_C()

/* Copy of the contents of xpfpa.h (which is under public domain)
   See http://wiki.php.net/rfc/rounding for details.

Cross Platform Floating Point Arithmetics

This header file defines several platform-dependent macros that ensure
   equal and deterministic floating point behaviour across several platforms,
   compilers and architectures.

The current macros are currently only used on x86 and x86_64 architectures,
   on every other architecture, these macros expand to NOPs. This assumes that
   other architectures do not have an internal precision and the operhand types
   define the computational precision of floating point operations. This
   assumption may be false, in that case, the author is interested in further
   details on the other platform.

For further details, please visit:
   http://www.christian-seiler.de/projekte/fpmath/

Version: 20090317 */

/*
 Implementation notes:

x86_64:
  - Since all x86_64 compilers use SSE by default, we do not define these
    macros there. We ignore the compiler option -mfpmath=i387, because there is
    no reason to use it on x86_64.

General:
  - It would be nice if one could detect whether SSE if used for math via some
    funky compiler defines and if so, make the macros go to NOPs. Any ideas
    on how to do that?

MS Visual C:
  - Since MSVC users typically don't use autoconf or CMake, we will detect
    MSVC via compile time define.
*/

/* MSVC detection (MSVC people usually don't use autoconf) */
#if defined(_MSC_VER) && !defined(_WIN64)
#  define HAVE__CONTROLFP_S
#endif /* _MSC_VER */

#if defined(HAVE__CONTROLFP_S) && !defined(__x86_64__)

/* float.h defines _controlfp_s */
# include <float.h>

# define XPFPA_HAVE_CW 1
# define XPFPA_CW_DATATYPE \
            unsigned int

# define XPFPA_STORE_CW(vptr) do { \
            _controlfp_s((unsigned int *)(vptr), 0, 0); \
        } while (0)

# define XPFPA_RESTORE_CW(vptr) do { \
            unsigned int _xpfpa_fpu_cw; \
            _controlfp_s(&_xpfpa_fpu_cw, *((unsigned int *)(vptr)), _MCW_PC); \
        } while (0)

# define XPFPA_DECLARE \
            unsigned int _xpfpa_fpu_oldcw, _xpfpa_fpu_cw;

# define XPFPA_SWITCH_DOUBLE() do { \
            _controlfp_s(&_xpfpa_fpu_cw, 0, 0); \
            _xpfpa_fpu_oldcw = _xpfpa_fpu_cw; \
            _controlfp_s(&_xpfpa_fpu_cw, _PC_53, _MCW_PC); \
        } while (0)
# define XPFPA_SWITCH_SINGLE() do { \
            _controlfp_s(&_xpfpa_fpu_cw, 0, 0); \
            _xpfpa_fpu_oldcw = _xpfpa_fpu_cw; \
            _controlfp_s(&_xpfpa_fpu_cw, _PC_24, _MCW_PC); \
        } while (0)
/* NOTE: This only sets internal precision. MSVC does NOT support double-
   extended precision! */
# define XPFPA_SWITCH_DOUBLE_EXTENDED() do { \
            _controlfp_s(&_xpfpa_fpu_cw, 0, 0); \
            _xpfpa_fpu_oldcw = _xpfpa_fpu_cw; \
            _controlfp_s(&_xpfpa_fpu_cw, _PC_64, _MCW_PC); \
        } while (0)
# define XPFPA_RESTORE() \
            _controlfp_s(&_xpfpa_fpu_cw, _xpfpa_fpu_oldcw, _MCW_PC)
/* We do NOT use the volatile return trick since _controlfp_s is a function
   call and thus FP registers are saved in memory anyway. However, we do use
   a variable to ensure that the expression passed into val will be evaluated
   *before* switching back contexts. */
# define XPFPA_RETURN_DOUBLE(val) \
            do { \
                double _xpfpa_result = (val); \
                XPFPA_RESTORE(); \
                return _xpfpa_result; \
            } while (0)
# define XPFPA_RETURN_SINGLE(val) \
            do { \
                float _xpfpa_result = (val); \
                XPFPA_RESTORE(); \
                return _xpfpa_result; \
            } while (0)
/* This won't work, but we add a macro for it anyway. */
# define XPFPA_RETURN_DOUBLE_EXTENDED(val) \
            do { \
                long double _xpfpa_result = (val); \
                XPFPA_RESTORE(); \
                return _xpfpa_result; \
            } while (0)

#elif defined(HAVE__CONTROLFP) && !defined(__x86_64__)

/* float.h defines _controlfp */
# include <float.h>

# define XPFPA_DECLARE \
            unsigned int _xpfpa_fpu_oldcw;

# define XPFPA_HAVE_CW 1
# define XPFPA_CW_DATATYPE \
            unsigned int

# define XPFPA_STORE_CW(vptr) do { \
            *((unsigned int *)(vptr)) = _controlfp(0, 0); \
        } while (0)

# define XPFPA_RESTORE_CW(vptr) do { \
            _controlfp(*((unsigned int *)(vptr)), _MCW_PC); \
        } while (0)

# define XPFPA_SWITCH_DOUBLE() do { \
            _xpfpa_fpu_oldcw = _controlfp(0, 0); \
            _controlfp(_PC_53, _MCW_PC); \
        } while (0)
# define XPFPA_SWITCH_SINGLE() do { \
            _xpfpa_fpu_oldcw = _controlfp(0, 0); \
            _controlfp(_PC_24, _MCW_PC); \
        } while (0)
/* NOTE: This will only work as expected on MinGW. */
# define XPFPA_SWITCH_DOUBLE_EXTENDED() do { \
            _xpfpa_fpu_oldcw = _controlfp(0, 0); \
            _controlfp(_PC_64, _MCW_PC); \
        } while (0)
# define XPFPA_RESTORE() \
            _controlfp(_xpfpa_fpu_oldcw, _MCW_PC)
/* We do NOT use the volatile return trick since _controlfp is a function
   call and thus FP registers are saved in memory anyway. However, we do use
   a variable to ensure that the expression passed into val will be evaluated
   *before* switching back contexts. */
# define XPFPA_RETURN_DOUBLE(val) \
            do { \
                double _xpfpa_result = (val); \
                XPFPA_RESTORE(); \
                return _xpfpa_result; \
            } while (0)
# define XPFPA_RETURN_SINGLE(val) \
            do { \
                float _xpfpa_result = (val); \
                XPFPA_RESTORE(); \
                return _xpfpa_result; \
            } while (0)
/* This will only work on MinGW */
# define XPFPA_RETURN_DOUBLE_EXTENDED(val) \
            do { \
                long double _xpfpa_result = (val); \
                XPFPA_RESTORE(); \
                return _xpfpa_result; \
            } while (0)

#elif defined(HAVE__FPU_SETCW)  && !defined(__x86_64__) /* glibc systems */

/* fpu_control.h defines _FPU_[GS]ETCW */
# include <fpu_control.h>

# define XPFPA_DECLARE \
            fpu_control_t _xpfpa_fpu_oldcw, _xpfpa_fpu_cw;

# define XPFPA_HAVE_CW 1
# define XPFPA_CW_DATATYPE \
            fpu_control_t

# define XPFPA_STORE_CW(vptr) do { \
            _FPU_GETCW((*((fpu_control_t *)(vptr)))); \
        } while (0)

# define XPFPA_RESTORE_CW(vptr) do { \
            _FPU_SETCW((*((fpu_control_t *)(vptr)))); \
        } while (0)

# define XPFPA_SWITCH_DOUBLE() do { \
            _FPU_GETCW(_xpfpa_fpu_oldcw); \
            _xpfpa_fpu_cw = (_xpfpa_fpu_oldcw & ~_FPU_EXTENDED & ~_FPU_SINGLE) | _FPU_DOUBLE; \
            _FPU_SETCW(_xpfpa_fpu_cw); \
        } while (0)
# define XPFPA_SWITCH_SINGLE() do { \
            _FPU_GETCW(_xpfpa_fpu_oldcw); \
            _xpfpa_fpu_cw = (_xpfpa_fpu_oldcw & ~_FPU_EXTENDED & ~_FPU_DOUBLE) | _FPU_SINGLE; \
            _FPU_SETCW(_xpfpa_fpu_cw); \
        } while (0)
# define XPFPA_SWITCH_DOUBLE_EXTENDED()  do { \
            _FPU_GETCW(_xpfpa_fpu_oldcw); \
            _xpfpa_fpu_cw = (_xpfpa_fpu_oldcw & ~_FPU_SINGLE & ~_FPU_DOUBLE) | _FPU_EXTENDED; \
            _FPU_SETCW(_xpfpa_fpu_cw); \
        } while (0)
# define XPFPA_RESTORE() \
            _FPU_SETCW(_xpfpa_fpu_oldcw)
/* We use a temporary volatile variable (in a new block) in order to ensure
   that the optimizer does not mis-optimize the instructions. Also, a volatile
   variable ensures truncation to correct precision. */
# define XPFPA_RETURN_DOUBLE(val) \
            do { \
                volatile double _xpfpa_result = (val); \
                XPFPA_RESTORE(); \
                return _xpfpa_result; \
            } while (0)
# define XPFPA_RETURN_SINGLE(val) \
            do { \
                volatile float _xpfpa_result = (val); \
                XPFPA_RESTORE(); \
                return _xpfpa_result; \
            } while (0)
# define XPFPA_RETURN_DOUBLE_EXTENDED(val) \
            do { \
                volatile long double _xpfpa_result = (val); \
                XPFPA_RESTORE(); \
                return _xpfpa_result; \
            } while (0)

#elif defined(HAVE_FPSETPREC)  && !defined(__x86_64__) /* FreeBSD */

/* fpu_control.h defines _FPU_[GS]ETCW */
# include <machine/ieeefp.h>

# define XPFPA_DECLARE \
            fp_prec_t _xpfpa_fpu_oldprec;

# define XPFPA_HAVE_CW 1
# define XPFPA_CW_DATATYPE \
            fp_prec_t

# define XPFPA_STORE_CW(vptr) do { \
            *((fp_prec_t *)(vptr)) = fpgetprec(); \
        } while (0)

# define XPFPA_RESTORE_CW(vptr) do { \
            fpsetprec(*((fp_prec_t *)(vptr))); \
        } while (0)

# define XPFPA_SWITCH_DOUBLE() do { \
            _xpfpa_fpu_oldprec = fpgetprec(); \
            fpsetprec(FP_PD); \
        } while (0)
# define XPFPA_SWITCH_SINGLE() do { \
            _xpfpa_fpu_oldprec = fpgetprec(); \
            fpsetprec(FP_PS); \
        } while (0)
# define XPFPA_SWITCH_DOUBLE_EXTENDED() do { \
            _xpfpa_fpu_oldprec = fpgetprec(); \
            fpsetprec(FP_PE); \
        } while (0)
# define XPFPA_RESTORE() \
            fpsetprec(_xpfpa_fpu_oldprec)
/* We use a temporary volatile variable (in a new block) in order to ensure
   that the optimizer does not mis-optimize the instructions. Also, a volatile
   variable ensures truncation to correct precision. */
# define XPFPA_RETURN_DOUBLE(val) \
            do { \
                volatile double _xpfpa_result = (val); \
                XPFPA_RESTORE(); \
                return _xpfpa_result; \
            } while (0)
# define XPFPA_RETURN_SINGLE(val) \
            do { \
                volatile float _xpfpa_result = (val); \
                XPFPA_RESTORE(); \
                return _xpfpa_result; \
            } while (0)
# define XPFPA_RETURN_DOUBLE_EXTENDED(val) \
            do { \
                volatile long double _xpfpa_result = (val); \
                XPFPA_RESTORE(); \
                return _xpfpa_result; \
            } while (0)

#elif defined(HAVE_FPU_INLINE_ASM_X86) && !defined(__x86_64__)

/*
  Custom x86 inline assembler implementation.

This implementation does not use predefined wrappers of the OS / compiler
  but rather uses x86/x87 inline assembler directly. Basic instructions:

fnstcw - Store the FPU control word in a variable
  fldcw  - Load the FPU control word from a variable

Bits (only bits 8 and 9 are relevant, bits 0 to 7 are for other things):
     0x0yy: Single precision
     0x1yy: Reserved
     0x2yy: Double precision
     0x3yy: Double-extended precision

We use an unsigned int for the datatype. glibc sources add __mode__ (__HI__)
  attribute to it (HI stands for half-integer according to docs). It is unclear
  what the does exactly and how portable it is.

The assembly syntax works with GNU CC, Intel CC and Sun CC.
*/

# define XPFPA_DECLARE \
            unsigned int _xpfpa_fpu_oldcw, _xpfpa_fpu_cw;

# define XPFPA_HAVE_CW 1
# define XPFPA_CW_DATATYPE \
            unsigned int

# define XPFPA_STORE_CW(vptr) do { \
            __asm__ __volatile__ ("fnstcw %0" : "=m" (*((unsigned int *)(vptr)))); \
        } while (0)

# define XPFPA_RESTORE_CW(vptr) do { \
            __asm__ __volatile__ ("fldcw %0" : : "m" (*((unsigned int *)(vptr)))); \
        } while (0)

# define XPFPA_SWITCH_DOUBLE() do { \
            __asm__ __volatile__ ("fnstcw %0" : "=m" (*&_xpfpa_fpu_oldcw)); \
            _xpfpa_fpu_cw = (_xpfpa_fpu_oldcw & ~0x100) | 0x200; \
            __asm__ __volatile__ ("fldcw %0" : : "m" (*&_xpfpa_fpu_cw)); \
        } while (0)
# define XPFPA_SWITCH_SINGLE() do { \
            __asm__ __volatile__ ("fnstcw %0" : "=m" (*&_xpfpa_fpu_oldcw)); \
            _xpfpa_fpu_cw = (_xpfpa_fpu_oldcw & ~0x300); \
            __asm__ __volatile__ ("fldcw %0" : : "m" (*&_xpfpa_fpu_cw)); \
        } while (0)
# define XPFPA_SWITCH_DOUBLE_EXTENDED() do { \
            __asm__ __volatile__ ("fnstcw %0" : "=m" (*&_xpfpa_fpu_oldcw)); \
            _xpfpa_fpu_cw = _xpfpa_fpu_oldcw | 0x300; \
            __asm__ __volatile__ ("fldcw %0" : : "m" (*&_xpfpa_fpu_cw)); \
        } while (0)
# define XPFPA_RESTORE() \
            __asm__ __volatile__ ("fldcw %0" : : "m" (*&_xpfpa_fpu_oldcw))
/* We use a temporary volatile variable (in a new block) in order to ensure
   that the optimizer does not mis-optimize the instructions. Also, a volatile
   variable ensures truncation to correct precision. */
# define XPFPA_RETURN_DOUBLE(val) \
            do { \
                volatile double _xpfpa_result = (val); \
                XPFPA_RESTORE(); \
                return _xpfpa_result; \
            } while (0)
# define XPFPA_RETURN_SINGLE(val) \
            do { \
                volatile float _xpfpa_result = (val); \
                XPFPA_RESTORE(); \
                return _xpfpa_result; \
            } while (0)
# define XPFPA_RETURN_DOUBLE_EXTENDED(val) \
            do { \
                volatile long double _xpfpa_result = (val); \
                XPFPA_RESTORE(); \
                return _xpfpa_result; \
            } while (0)

#else /* FPU CONTROL */

/*
  This is either not an x87 FPU or the inline assembly syntax was not
  recognized. In any case, default to NOPs for the macros and hope the
  generated code will behave as planned.
*/
# define XPFPA_DECLARE                      /* NOP */
# define XPFPA_HAVE_CW                      0
# define XPFPA_CW_DATATYPE                  unsigned int
# define XPFPA_STORE_CW(variable)           /* NOP */
# define XPFPA_RESTORE_CW(variable)         /* NOP */
# define XPFPA_SWITCH_DOUBLE()              /* NOP */
# define XPFPA_SWITCH_SINGLE()              /* NOP */
# define XPFPA_SWITCH_DOUBLE_EXTENDED()     /* NOP */
# define XPFPA_RESTORE()                    /* NOP */
# define XPFPA_RETURN_DOUBLE(val)           return (val)
# define XPFPA_RETURN_SINGLE(val)           return (val)
# define XPFPA_RETURN_DOUBLE_EXTENDED(val)  return (val)

#endif /* FPU CONTROL */

#endif

cmd: