600.perlbench

600.perlbench_s.flags 600.perlbench_s Flags

These are flags that appear in the benchmark sources, categorized as to whether they are portability candidates, mandatory, or forbidden. The descriptions of the pre-existing Perl preprocessor macros are in general taken from src/spec_config.h.

]]>

The preprocessor macro PERL_CORE is always defined when building 600.perlbench_s. It is forbidden to undefine this mandatory flag. These flags instruct the compiler to search for header files in the specified subdirectories. -I., -Idist/IO, -Icpan/Time-HiRes, -Icpan/HTML-Parser, -Iext/re, -Ispecrand -D_LARGE_FILES, -D_LARGEFILE_SOURCE, -D_FILE_OFFSET_BITS=64 These flags are used to attempt to enable large file support on the various platforms that CPU2017 supports. Though no files larger than 2^32 bytes are used, the support for large files is tested by the test workload. This may also be necessary for normal operation on filesystems with 64-bit inodes. This flag specifies that the File::Spec module should not treat double slashes specially when canonicalizing Unix-style pathnames. Windows systems need access to some portability header files contained in the win32 subdirectory when building 600.perlbench_s. This flag is set when building 600.perlbench_s on Windows systems, unless SPEC_NO_WIN32 is set. This flag is can be used on Windows to keep WIN32 from being defined; this may be necessary in compilation environments that do not mimic Microsoft Visual C++. It is forbidden to undefine this mandatory flag. This flag is set when building 600.perlbench_s on Windows systems. It is forbidden to undefine this mandatory flag. This flag is set when building 600.perlbench_s on Windows systems. It is forbidden to undefine this mandatory flag. This macro indicates that none of the available platform selection flags are acceptable and that manual configuration will be done by specifying individual macro settings when building the benchmark. This macro indicates that the benchmark is being compiled on a system running Linux. This macro indicates that the benchmark is being compiled on an Intel IA32-compatible system running the Linux operating system. This macro indicates that the benchmark is being compiled on an Intel IA64-compatible system running the Linux operating system. This macro indicates that the benchmark is being compiled on an SPARC system running the Linux operating system. This macro indicates that the benchmark is being compiled on a big-endian PowerPC system running the Linux operating system. This macro indicates that the benchmark is being compiled on a little-endian PowerPC system running the Linux operating system. This macro indicates that the benchmark is being compiled on an Alpha system running the Linux operating system. This macro indicates that the benchmark is being compiled on a MIPS-based system running the Linux operating system. This macro indicates that the benchmark is being compiled on an AMD64-compatible system running the Linux operating system. This macro indicates that the benchmark is being compiled on an ARM system running the Linux operating system in the AArch64 execution environment. This macro indicates that the benchmark is being compiled on an ARM system running the Linux operating system in the AArch32 execution environment. This macro indicates that the benchmark is being compiled on an Intel IA32-compatible system running some variant of BSD Unix. This macro indicates that the benchmark is being compiled on an Intel IA64-compatible system running some variant of BSD Unix. This macro indicates that the benchmark is being compiled on a SPARC system running some variant of BSD Unix. This macro indicates that the benchmark is being compiled on a PowerPC system running some variant of BSD Unix. This macro indicates that the benchmark is being compiled on an Alpha system running some variant of BSD Unix. This macro indicates that the benchmark is being compiled on a MIPS-based system running some variant of BSD Unix. This macro indicates that the benchmark is being compiled on an AMD64-compatible system running some variant of BSD Unix. This macro indicates that the benchmark is being compiled on a SPARC/Solaris system. This macro indicates that the benchmark is being compiled on an x86/Solaris system. This macro indicates that the benchmark is being compiled on an x64/Solaris system. This macro indicates that the benchmark is being compiled on an Intel IA64-compatible system running HP-UX. This macro indicates that the benchmark is being compiled on an HP PA-RISC system running HP-UX. This macro indicates that the benchmark is being built on an AMD64-compatible system. This macro indicates that the benchmark is being built on an ARMv8 system. This macro indicates that the benchmark is being built on a MIPS-based Reliant Unix system. This macro indicates that the benchmark is being built on a 32-bit Windows system. This macro indicates that the benchmark is being built on a MIPS-based IRIX system. This macro indicates that the benchmark is being built on a PowerPC-based AIX system. This macro indicates that the benchmark is being built on a PowerPC-based MacOS X system. This macro indicates that the benchmark is being built on an Intel-based MacOS X system. This macro indicates that the benchmark is being built on an Intel-based MacOS X system in 64-bit mode. This macro indicates that the benchmark is being built on a MacOS X system. This macro indicates that the benchmark is being compiled on an Intel IA32-compatible system. This macro indicates that the benchmark is being compiled on an Alpha-based Tru64 Unix system. This macro indicates that the benchmark is being compiled on an ARM system running in the AArch32 execution environment. This macro indicates that the benchmark is being compiled on an ARM system running in the AArch64 execution environment. This macro indicates that the target system runs an Alpha processor. This macro indicates that the target system runs an IA64 processor in little-endian mode. This macro indicates that the target system runs a big-endian PowerPC processor. This macro indicates that the target system runs a little-endian PowerPC processor. This macro indicates that the target system runs a SPARC processor. This macro indicates that the target system runs an HP PA-RISC processor. This macro indicates that the target system runs an IA64 processor in big-endian mode. This macro indicates that the target system runs a MIPS processor. This macro specifies that the target system uses the LP64 data model; specifically, that integers are 32 bits, while longs and pointers are 64 bits. This macro specifies that the target system uses the ILP64 data model; specifically, that integers, longs and pointers are 64 bits. This macro specifies that the target system uses some strange data model that is not ILP32, ILP64, LP64, or P64. All of the settings related to the datamodel (type selection and sizes, etc) must be made by hand. This macro indicates that the benchmark is being compiled on a 64-bit Windows system running an AMD64-compliant processor. This macro indicates that the benchmark is being compiled on a 64-bit Windows system running an Itanium processor. This macro specifies that the target system uses the P64 data model; specifically, that integers and longs are 32 bits, while pointers are 64 bits. This macro causes a dummy element of type __float80 to be inserted into the jmpenv struct in order to force the je_buf element to be properly aligned on IA-64. This macro specifies the size (in octets) of a native C double on the target system. -DDOUBLESIZE=XXX This macro specifies the size (in octets) of a native C long long integer on the target system. -DLONGLONGSIZE=XXX This macro specifies the size (in octets) of the native C type specified by I16TYPE on the target system. -DI16SIZE=XXX This macro specifies a native C type that can contain a signed 16-bit integer value. -DI16TYPE=XXX This macro specifies the size (in octets) of the native C type specified by I32TYPE on the target system. -DI32SIZE=XXX This macro specifies a native C type that can contain a signed 32-bit integer value. -DI32TYPE=XXX This macro specifies the size (in octets) of the native C type specified by I64TYPE on the target system. -DI64SIZE=XXX This macro specifies a native C type that can contain a signed 64-bit integer value. -DI64TYPE=XXX This macro specifies the size (in octets) of the native C type specified by I8TYPE on the target system. -DI8SIZE=XXX This macro specifies a native C type that can contain a signed 8-bit integer value. -DI8TYPE=XXX This macro specifies the size (in octets) of the native C type specified by U16TYPE on the target system. -DU16SIZE=XXX This macro specifies a native C type that can contain an unsigned 16-bit integer value. -DU16TYPE=XXX This macro specifies the size (in octets) of the native C type specified by U32TYPE on the target system. -DU32SIZE=XXX This macro specifies a native C type that can contain an unsigned 32-bit integer value. -DU32TYPE=XXX This macro specifies the size (in octets) of the native C type specified by U64TYPE on the target system. -DU64SIZE=XXX This macro specifies a native C type that can contain an unsigned 64-bit integer value. -DU64TYPE=XXX This macro specifies the size (in octets) of the native C type specified by U8TYPE on the target system. -DU8SIZE=XXX This macro specifies a native C type that can contain an unsigned 8-bit integer value. -DU8TYPE=XXX This macro specifies the size (in octets) of a native C int on the target system. -DINTSIZE=XXX This macro specifies the size (in octets) of the native C type specified by IVTYPE on the target system. -DIVSIZE=XXX This macro specifies the native C type that will be used in the IV (Integer Value) slot in Perl's scalar struct. -DIVTYPE=XXX This macro specifies the size (in octets) of a native C long on the target system. -DLONGSIZE=XXX This macro specifies the size (in octets) of the native C type specified by NVTYPE on the target system. -DNVSIZE=XXX This macro specifies the native C type that will be used in the NV (Natural Value) slot in Perl's scalar struct. -DNVTYPE=XXX This macro specifies the size (in octets) of a native C pointer on the target system. -DPTRSIZE=XXX

QUAD_IS_INT (use 'int')

QUAD_IS_LONG (use 'long')

QUAD_IS_LONG_LONG (use 'long long')

QUAD_IS_INT64_T (use 'int64_t')

QUAD_IS___INT64 (use '__int64')

]]> -DQUADKIND=XXX This macro specifies the native C type that can be used to hold signed quad values. -DQuad_t=XXX This macro specifies the size (in octets) of a native C short on the target system. -DSHORTSIZE=XXX This macro specifies a native C integer type that is at least 32 bits wide. It is used by the SPEC pseudo-random number generator. -DSPEC_INT32_T=XXX This macro specifies the size (in octets) of a C size_t on the target system. -DSize_t_size=XXX This macro specifies the size (in octets) of the native C type specified by UVTYPE on the target system. -DUVSIZE=XXX This macro specifies the native C type that will be used in the UV (Unsigned Value) slot in Perl's scalar struct. -DUVTYPE=XXX This macro specifies the native C type that can be used to hold unsigned quad values. -DUquad_t=XXX This macro specifies that the target system uses big-endian (MSB first) byte order. This macro specifies that the target system uses little-endian (LSB first) byte order. The opposite of LIBERAL. If this macro is set, some assumptions about how some automatic variables are aligned will not be made. Vector operations and the complement operator may be slower as a result. This macro indicates the presence of a 64-bit integer type (Quad_t) and its unsigned counterpart (Uquad_t). In cases where this is automatically defined, it can be disabled by also defining SPEC_NO_HAS_QUAD. This macro prevents HAS_QUAD from being defined. This macro indicates the presence of a fork routine. In cases where this is automatically defined, it can be disabled by also defining SPEC_NO_HAS_FORK. This macro prevents HAS_FORK from being defined. This symbol defines the format string used for printing a Perl IV as a signed decimal integer. -DIVdf=XXX This symbol defines the format string used for printing a Perl UV as an unsigned decimal integer. -DUVuf=XXX This symbol defines the format string used for printing a Perl UV as an unsigned octal integer. -DUVof=XXX This symbol defines the format string used for printing a Perl UV as an unsigned hexadecimal integer in lowercase abcdef. -DUVxf=XXX This symbol defines the format string used for printing a Perl UV as an unsigned hexadecimal integer in uppercase ABCDEF. -DUVXf=XXX This symbol defines the format string used for printing a Perl NV using %e-ish floating point format. -DNVef=XXX This symbol defines the format string used for printing a Perl NV using %f-ish floating point format. -DNVff=XXX This symbol defines the format string used for printing a Perl NV using %g-ish floating point format. -DNVgf=XXX This symbol holds the type used to declare offsets in the kernel. -DOff_t=XXX This symbol holds the number of bytes used by the type specified by Off_t. -DLSEEKSIZE=XXX This symbol holds the number of bytes used by the type specified by Off_t. -DOff_t_size=XXX This symbol holds the type used by functions that return a count of bytes or an error condition. It must be a signed type. It is usually ssize_t, but may be long or int, etc. -DSSize_t=XXX This symbol holds the type used to declare process IDs in the kernel. -DPid_t=XXX This symbol holds the type used for the 2nd, 3rd, and 4th arguments to select. This is only useful if you have select(), of course. -DSelect_fd_set_t=XXX This symbol, if defined, indicates that 64-bit integers should be used when available. This macro indicates that the benchmark is being compiled on a 64-bit Windows system. This macro indicates that the benchmark is being compiled on a Windows system. This macro indicates that the benchmark is being compiled on a Solaris system. This macro indicates that the benchmark is being compiled on a BSD Unix system. This macro indicates that the benchmark is being compiled on an HP-UX system. This macro indicates that the benchmark is being compiled on a Reliant Unix system. This macro indicates that the benchmark is being compiled on a system running an Intel IA64-compatible processor. This macro indicates that Perl should use its own implementation of the htonl and ntohl byte-swapping routines. This macro indicates that sys/param.h should be included. This macro indicates that fcntl.h should be included. In cases where this is set automatically, it can be disabled by also defining SPEC_NO_I_FCNTL. Prevent I_FCNTL from being automatically defined. This macro indicates that sys/file.h should be included. In cases where this is set automatically, it can be disabled by also defining SPEC_NO_I_SYS_FILE. Prevent I_SYS_FILE from being automatically defined. This symbol contains the number of bytes required to align a double, or a long double when applicable. Usual values are 2, 4 and 8. -DMEM_ALIGNBYTES=XXX This macro indicates that the length of directory entry names is provided by a d_namlen field. In cases where this is set automatically, it can be disabled by also defining SPEC_NO_DIRNAMLEN. Prevent DIRNAMLEN from being automatically defined. This symbol is set to 'struct dirent' or 'struct direct' depending on whether dirent is available or not. -DDirentry_t=struct.dirS+ This macro indicates that time.h should be included. In cases where this is set automatically, it can be disabled by also defining SPEC_NO_I_TIME. Prevent I_TIME from being automatically defined.

0 = no troubles

1 = couldn't cast < 0

2 = couldn't cast >= 0x80000000

4 = couldn't cast in argument expression list

]]> -DCASTFLAGS=XXX This symbol holds the size of a long double. -DLONG_DOUBLESIZE=XXX This symbol is defined if calling fflush(NULL) really does flush all pending stdio output. In cases where this is set automatically, it can be disabled by also defining SPEC_NO_FFLUSH_NULL. Prevent FFLUSH_NULL from being automatically defined. This symbol is defined to be the type of char used in stdio.h. -DSTDCHAR=XXX This symbol, if defined, indicates that va_copy should NOT be used to copy variable argument lists even when the default config for the platforms says it should be used. This symbol, if defined, indicates that the system stores the variable argument list datatype, va_list, in a format that cannot be copied by simple assignment, so that some other means must be used when copying is required. As such systems vary in their provision (or non-provision) of copying mechanisms, handy.h defines a platform-independent macro, Perl_va_copy(src, dst), to do the job. This symbol is defined if the dup2 routine is available to duplicate file descriptors. In cases where this is set automatically, it can be disabled by also defining SPEC_NO_HAS_DUP2. Prevent HAS_DUP2 from being automatically defined.

d_Gconvert='gconvert((x),(n),(t),(b))'

d_Gconvert='gcvt((x),(n),(b))'

d_Gconvert='sprintf((b),"%.*g",(n),(x))'

The last two assume trailing zeros should not be kept. ]]> -DGconvert=XXX This symbol holds the signedness of the Uid_t type. -DUid_t_sign=XXX This symbol holds the signedness of the Gid_t type. -DGid_t_sign=XXX This symbol indicates that a variable of type NVTYPE can preserve all the bits of a variable of type UVTYPE. In cases where this is set automatically, it can be disabled by also defining SPEC_NO_NV_PRESERVES_UV. Prevent NV_PRESERVES_UV from being automatically defined. This symbol contains the number of bits a variable of type NVTYPE can preserve of a variable of type UVTYPE. -DNV_PRESERVES_UV_BITS=XXX This symbol holds the minimum number of bits operated by select. That is, if you do select(n, ...), how many bits at least will be cleared in the masks if some activity is detected. Usually this is either n or 32*ceil(n/32), especially many little-endians do the latter. This is only useful if you have select(), naturally. -DSELECT_MIN_BITS=XXX This symbol, if defined, contains the string used by stdio to format long doubles (format 'f') for output. -DPERL_PRIfldbl=XXX This symbol, if defined, contains the string used by stdio to format long doubles (format 'g') for output. -DPERL_PRIgldbl=XXX This symbol, if defined, contains the string used by stdio to format long doubles (format 'e') for output. -DPERL_PRIeldbl=XXX This symbol, if defined, contains the string used by stdio to format long doubles (format 'f') for input. -DPERL_SCNfldbl=XXX This macro indicates to the C program that the sigsetjmp() routine is available to save the calling process's registers and stack environment for later use by siglongjmp(), and to optionally save the process's signal mask. In cases where this is set automatically, it can be disabled by also defining SPEC_NO_HAS_SIGSETJMP. Prevent HAS_SIGSETJMP from being automatically defined. This macro indicates that sys/ioctl.h exists and should be included. Prevent I_SYS_IOCTL from being automatically defined. This macro indicates that unistd.h exists and should be included. Prevent I_UNISTD from being automatically defined. This macro indicates that inttypes.h exists and should be included. Prevent I_INTTYPES from being automatically defined. This macro indicates that the C compiler supports a 'long long' type. Prevent HAS_LONG_LONG from being automatically defined. This macro indicates that the fcntl() function exists. Prevent HAS_FCNTL from being automatically defined. This macro indicates that sys/time.h exists and should be included. Prevent I_SYS_TIME from being automatically defined. This macro indicates that sys/times.h exists and should be included. Prevent I_SYS_TIMES from being automatically defined. This macro indicates that sys/wait.h exists and should be included. Prevent I_SYS_WAIT from being automatically defined. This macro indicates that the truncate() function exists. Prevent HAS_TRUNCATE from being automatically defined. This macro indicates that arpa/inet.h exists and should be included. Prevent I_ARPA_INET from being automatically defined. This macro prevents the usual (empty) definition of dXSUB_SYS. This macro must remain defined, but empty. -DdXSUB_SYS=XXX This symbol is defined if the rdev return from Perl's stat() function should be taken from the st_rdev field of C's struct stat. In cases where this is set automatically, it can be disabled by also defining SPEC_NO_USE_STAT_RDEV. Prevent USE_STAT_RDEV from being automatically defined. This symbol is defined if the _ptr and _cnt fields (or similar) of the stdio FILE structure can be used to access the stdio buffer for a file handle. In cases where this is set automatically, it can be disabled by also defining SPEC_NO_USE_STDIO_PTR. Prevent USE_STDIO_PTR from being automatically defined. This symbol is defined if the _base field (or similar) of the stdio FILE structure can be used to access the stdio buffer for a file handle. In cases where this is set automatically, it can be disabled by also defining SPEC_NO_USE_STDIO_BASE. Prevent USE_STDIO_BASE from being automatically defined. Definition of this symbol is forbidden. Definition of this symbol is forbidden. Definition of this symbol is forbidden. Definition of this symbol is forbidden. Definition of this symbol is forbidden. Definition of this symbol is forbidden. Definition of this symbol is forbidden. Prevent any non-C locales from being used. This is the default. Prevent NO_LOCALE from being automatically defined. Doing so will probably cause validation to fail. This symbol, if defined, indicates that this C compiler knows about the const type. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HASCONST. Prevent HASCONST from being automatically defined. If defined, this macro indicates that the C compiler can handle function prototypes. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_CAN_PROTOTYPE. Prevent CAN_PROTOTYPE from being automatically defined. If defined, this macro indicates that the C compiler can handle function prototypes with variable argument lists. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_CAN_VAPROTO. Prevent CAN_VAPROTO from being automatically defined. This symbol, if defined, indicates that the getcwd routine is available to get the current working directory. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_GETCWD. Prevent HAS_GETCWD from being automatically defined. This symbol, if defined, indicates that the isnan routine is available to check whether a double is a NaN. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_ISNAN. Prevent HAS_ISNAN from being automatically defined. This symbol, if defined, indicates that the isinf routine is available to check whether a double is an infinity. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_ISINF. Prevent HAS_ISINF from being automatically defined. This symbol, if defined, indicates that the memchr routine is available to locate characters within a C string. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_MEMCHR. Prevent HAS_MEMCHR from being automatically defined. This symbol, if defined, indicates that the memcmp routine is available to compare blocks of memory. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_MEMCMP. Prevent HAS_MEMCMP from being automatically defined. This symbol, if defined, indicates that the memcmp routine is available and can be used to compare relative magnitudes of chars with their high bits set. If it is not defined, roll your own version. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_SANE_MEMCMP. Prevent HAS_SANE_MEMCMP from being automatically defined. This symbol, if defined, indicates that the memcpy routine is available to copy blocks of memory. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_MEMCPY. Prevent HAS_MEMCPY from being automatically defined. This symbol, if defined, indicates that the memmove routine is available to copy potentially overlapping blocks of memory. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_MEMMOVE. Prevent HAS_MEMMOVE from being automatically defined. This symbol, if defined, indicates that the memset routine is available to set blocks of memory. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_MEMSET. Prevent HAS_MEMSET from being automatically defined. This symbol, if defined, indicates that the select routine is available to select active file descriptors. If the timeout field is used, sys/time.h may need to be included. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_SELECT. Prevent HAS_SELECT from being automatically defined. This symbol, if defined, indicates that the signbit routine is available to check whether a floating point value is negative. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_SIGNBIT. Prevent HAS_SIGNBIT from being automatically defined. This symbol is defined to indicate that the strchr()/strrchr() functions are available for string searching. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_STRCHR. Prevent HAS_STRCHR from being automatically defined. This symbol, if defined, indicates that the strtod routine is available to provide better numeric string conversion than atof(). In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_STRTOD. Prevent HAS_STRTOD from being automatically defined. This symbol, if defined, indicates that the strtol routine is available to provide better numeric string conversion than atoi() and friends. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_STRTOL. Prevent HAS_STRTOL from being automatically defined. This symbol, if defined, indicates that the strxfrm() routine is available to transform strings. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_STRXFRM. Prevent HAS_STRXFRM from being automatically defined.

1 = supports declaration of void

2 = supports arrays of pointers to functions returning void

4 = supports comparisons between pointers to void functions and addresses of void functions

8 = suports declaration of generic void pointers

]]> -DVOIDFLAGS=XXX This symbol, if defined, indicates that this C compiler knows about the volatile declaration. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HASVOLATILE. Prevent HASVOLATILE from being automatically defined. This symbol, if defined, indicates that the vprintf routine is available to printf with a pointer to an argument list. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_VPRINTF. Prevent HAS_VPRINTF from being automatically defined. Prevent HAS_DBL_DIG from being automatically defined. Prevent HAS_LDBL_DIG from being automatically defined. This symbol will be defined if the C compiler supports long doubles. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_LONG_DOUBLE. Prevent HAS_LONG_DOUBLE from being automatically defined. -DMAX_SIG_DIG_PLUS=4 Perl's internal atof() implementation stops looking at a string once the maximum number of significant digits that can be represented by an NV (double or long double) has been seen. The NV_DIG (set to DBL_DIG or LDBL_DIG) sets a lower bound for this, but what's needed is an upper bound. By default this is set to NV_DIG+2, but if necessary this macro can be set to a value other than 2 to change that upper bound. In theory, this might be necessary when non-IEEE floating point is used, but there's a good chance that that will cause the benchmark to miscompare. Still, you're allowed to set it if you need it. This symbol, if defined, indicates that the system supports filenames longer than 14 characters. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_FLEXFILENAMES. Prevent FLEXFILENAMES from being automatically defined. This symbol, if defined, indicates that you must access character data through U32-aligned pointers. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_U32_ALIGNMENT_REQUIRED. Prevent U32_ALIGNMENT_REQUIRED from being automatically defined. Indicates that the utime.h header file exists and should be included. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_I_UTIME. Prevent I_UTIME from being automatically defined. Indicates that the stdbool.h header file exists and should be included. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_I_STDBOOL. Use of this macro automatically disables PERL_BOOL_AS_CHAR. Prevent I_STDBOOL from being automatically defined. Defining this macro indicates that no native boolean type is available and that some other type should be used instead. Doing this will require setting the "bool" macro to the name of the type to be used. When PERL_BOOL_AS_CHAR is defined, you may use this symbol name as a macro to define the type that should be used internally for booleans. If your compilation environment supports a native bool type, this will likely cause the build to completely break. Indicates that the stddef.h header file exists and should be included. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_I_STDDEF. Prevent I_STDDEF from being automatically defined. Indicates that the dirent.h header file exists and should be included. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_I_DIRENT. Prevent I_DIRENT from being automatically defined. Indicates that the float.h header file exists and should be included. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_I_FLOAT. Prevent I_FLOAT from being automatically defined. Indicates that the limits.h header file exists and should be included. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_I_LIMITS. Prevent I_LIMITS from being automatically defined. Indicates that the math.h header file exists and should be included. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_I_MATH. Prevent I_MATH from being automatically defined. Indicates that the sys/stat.h header file exists and should be included. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_I_SYS_STAT. Prevent I_SYS_STAT from being automatically defined. Indicates that the stdarg.h header file exists and should be included. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_I_STDARG. Prevent I_STDARG from being automatically defined. Indicates that the stdlib.h header file exists and should be included. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_I_STDLIB. Prevent I_STDLIB from being automatically defined. Indicates that the string.h header file exists and should be included. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_I_STRING. Prevent I_STRING from being automatically defined. This symbol, if defined, indicates that this C compiler knows how to copy structures. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_STRUCT_COPY. Prevent USE_STRUCT_COPY from being automatically defined. This symbol, if defined, indicates that the rmdir routine is available to remove directories. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_RMDIR. Prevent HAS_RMDIR from being automatically defined. This symbol, if defined, indicates that the gettimeofday() system call is available for a sub-second accuracy clock. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_GETTIMEOFDAY. Prevent HAS_GETTIMEOFDAY from being automatically defined. This symbol, if defined, indicates that the ioctl routine is available. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_IOCTL. Prevent HAS_IOCTL from being automatically defined. This symbol, if defined, indicates that the wait4 routine is available to wait for child process. This symbol, if defined, indicates that the waitpid routine is available to wait for child process. In cases where this macro is automatically defined, it can be disabled by defining SPEC_NO_HAS_WAITPID. Prevent HAS_WAITPID from being automatically defined. This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. -DPF_INET, -DAF_INET, -DAF_UNIX This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. This flag indicates that the source is being compiled on an Amiga running AmigaOS. The Amiga was not a porting target for CPU2017, so it's unlikely that this will work. This macro has no function in the benchmark version of the source; its use is forbidden. -DAPPLLIB_EXP=XXX, -DARCHLIB_EXP=XXX, -DPRIVLIB_EXP=XXX, -DSITEARCH_EXP=XXX, -DSITELIB_EXP=XXX, -DSITELIB_STEM=XXX, -DPERL_VENDORARCH_EXP=XXX, -DPERL_VENDORLIB_EXP=XXX, -DPERL_VENDORLIB_NAME=XXX, -DPERL_VENDORLIB_STEM=XXX, -DUSE_SITECUSTOMIZE=XXX This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. Setting this macro to a value other than its default is forbidden. -DAtoul=XXX, -DAtol=XXX This macro defines the contents of one of Perl's internal data structures. Setting it to a non-default value is forbidden. If the size of a Time_t is too large to fit into a Perl IV, this define should be set. It will cause time values to be put into an NV. This macro has no function in the benchmark version of the source; its use is forbidden. This macro should be set to the name of an openable file that will return EOF immediately upon read. On Unix and Unix-like systems, this is "/dev/null". On Windows systems, it is "nul". -DBIT_BUCKET=XXX This macro has no function in the benchmark version of the source; its use is forbidden. This macro indicates that the source is being built on a BSD system. This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. This macro indicates that the system for which the benchmark is being compiled has some characteristics in common with BSD Unix systems. This macro has no function in the benchmark version of the source; its use is forbidden. This macro controls the default size for the buffer in the PerlIO abstraction layer. Its default value is 8192 or BUFSIZ, whichever is larger, and it may not be changed for a reportable run. This macro indicates the byte order and width of an IV. Possible values are

0x87654321 - Big-endian 64-bit system
0x4321 - Big-endian 32-bit system
0x12345678 - Little-endian 64-bit system
0x1234 - Little-endian 32-bit system

]]> -DBYTEORDER=12345 When at least 32-bit alignment is required on a big-endian platform, this macro is used in the MD5 routines to do endian-reversal on 32-bit quantities. Otherwise an alignment-safe function is used. Changing this setting from its default is not allowed. -DBYTESWAP=XXX This flag indicates that casting floating point values to integers should be done in-line via macros. Its use is forbidden. Setting this macro to a value other than its default is forbidden. Setting this macro to a value other than its default is forbidden. This macro is used in place of HZ if HZ is not defined. -DCLK_TCK=XXX If the nl_langinfo function is available, AND if locales are in use (which would likely cause the benchmark to miscompare), this macro provides the argument to nl_langinfo. -DCODESET=XXX Setting this macro to a value other than its default is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. -DCOND_DESTROY=XXX, -DCOND_BROADCAST=XXX, -DCOND_INIT=XXX, -DCOND_SIGNAL=XXX, -DCOND_WAIT=XXX Setting this macro to a value other than its default is forbidden. -DCP_UTF8=XXX This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. -DENDGRENT_R_PROTO=XXX, -DENDHOSTENT_R_PROTO=XXX, -DENDNETENT_R_PROTO=XXX, -DENDPROTOENT_R_PROTO=XXX, -DENDSERVENT_R_PROTO=XXX, -DENDPWENT_R_PROTO=XXX, -DGETGRENT_R_PROTO=XXX, -DGETHOSTENT_R_PROTO=XXX, -DGETNETENT_R_PROTO=XXX, -DGETPROTOENT_R_PROTO=XXX, -DGETSERVENT_R_PROTO=XXX, -DGETPWENT_R_PROTO=XXX, -DSETGRENT_R_PROTO=XXX, -DSETHOSTENT_R_PROTO=XXX, -DSETNETENT_R_PROTO=XXX, -DSETPROTOENT_R_PROTO=XXX, -DSETSERVENT_R_PROTO=XXX, -DSETPWENT_R_PROTO=XXX This macro has no function in the benchmark version of the source; its use is forbidden. -DREADDIR_R_PROTO=XXX, -DREADDIR64_R_PROTO=XXX This macro has no function in the benchmark version of the source; its use is forbidden. -DGETGRGID_R_PROTO=XXX, -DGETGRNAM_R_PROTO=XXX, -DGETPWNAM_R_PROTO=XXX, -DGETHOSTBYADDR_R_PROTO=XXX, -DGETHOSTBYNAME_R_PROTO=XXX, -DGETNETBYADDR_R_PROTO=XXX, -DGETNETBYNAME_R_PROTO=XXX, -DGETPROTOBYADDR_R_PROTO=XXX, -DGETPROTOBYNAME_R_PROTO=XXX, -DGETSERVBYADDR_R_PROTO=XXX, -DGETSERVBYNAME_R_PROTO=XXX, -DGETLOGIN_R_PROTO=XXX, -DGETPWUID_R_PROTO=XXX, -DGETSPNAM_R_PROTO=XXX, -DGETPROTOBYNUMBER_R_PROTO=XXX, -DGETSERVBYPORT_R_PROTO=XXX This macro has no function in the benchmark version of the source; its use is forbidden. -DCTIME_R_PROTO=XXX, -DGMTIME_R_PROTO=XXX, -DLOCALTIME_R_PROTO=XXX, -DASCTIME_R_PROTO=XXX This macro has no function in the benchmark version of the source; its use is forbidden. -DCRYPT_R_PROTO=XXX, -DCTERMID_R_PROTO=XXX, -DSETLOCALE_R_PROTO=XXX, -DSTRERROR_R_PROTO=XXX, -DTMPNAM_R_PROTO=XXX, -DTTYNAME_R_PROTO=XXX This macro has no function in the benchmark version of the source; its use is forbidden. -DCSH=XXX Setting this macro to a value other than its default is forbidden. This macro is defined automatically when building under Cygwin with the Win32 API. This macro is a Perl-internal data type accessor; setting it to something other than its default is forbidden. -DAvFILLp=XXX, -DCopyD=XXX, -DCopFILE=XXX, -DCopFILEAV=XXX, -DCopFILEGV=XXX, -DCopFILEGV_set=XXX, -DCopFILESV=XXX, -DCopFILE_set=XXX, -DCopSTASH=XXX, -DCopSTASHPV=XXX, -DCopSTASHPV_set=XXX, -DCopSTASH_eq=XXX, -DCopSTASH_set=XXX, -DHvHASKFLAGS=XXX, -DHvNAMELEN_get=XXX, -DHvNAMEUTF8=XXX, -DHvNAME_HEK=XXX, -DHvPLACEHOLDERS=XXX, -DHvSHAREKEYS_off=XXX, -DHvTOTALKEYS=XXX, -DCVf_ASSERTION=XXX, -DCVf_LVALUE=XXX, -DboolSV=XXX Enable assertions in the Storable module. Use of this flag is forbidden for reportable runs. This flag is used to indicate the number of significant digits in a double precision number. Normally this would be set by the system's "float.h" or "limits.h" header file. -DOVR_DBL_DIG=XXX, -DDBL_DIG=XXX This flag is used to indicate the number of significant digits in a long double. Normally this would be set by the system's "float.h" or "limits.h" header file. -DOVR_LDBL_DIG=XXX, -DLDBL_DIG=XXX This macro has no function in the benchmark version of the source; its use is forbidden. -DLDBL_EPSILON=XXX, -DDBL_EPSILON=XXX, -DNV_EPSILON=XXX This flag is used to set the largest value representable in a variable of type long double. -DLDBL_INFINITY=12345 This flag is used to set the largest value representable in a variable of type double. -DDBL_INFINITY=12345 This macro has no function in the benchmark version of the source; its use is forbidden. -DLDBL_MANT_DIG=XXX, -DDBL_MANT_DIG=XXX This symbol, if defined, contains the minimum value that can be stored in a variable of type double. -DDBL_MIN=12345 This symbol, if defined, contains the minimum value that can be stored in a variable of type long double. -DLDBL_MIN=12345 -DDBL_MAX=3.40282347E+38L, -DHUGE_VAL=3.40282347E+38L This symbol, if defined, contains the maximum value that can be stored in a variable of type double. -DLDBL_MAX=1.7976931348623157E+308L, -DHUGE_VAL=1.7976931348623157E+308L This symbol, if defined, contains the maximum value that can be stored in a variable of type long double. This symbol, if defined, contains the smallest power of 10 that can be stored in a variable of type double. -DDBL_MIN_10_EXP=XXX This symbol, if defined, contains the smallest power of 10 that can be stored in a variable of type long double. -DLDBL_MIN_10_EXP=XXX This symbol, if defined, contains the largest power of 10 that can be stored in a variable of type double. -DDBL_MAX_10_EXP=XXX This symbol, if defined, contains the largest power of 10 that can be stored in a variable of type long double. -DLDBL_MAX_10_EXP=XXX This macro has no function in the benchmark version of the source; its use is forbidden. -DLDBL_QNAN=XXX, -DLDBL_SNAN=XXX, -DLDBL_NAN=XXX, -DDBL_QNAN=XXX, -DDBL_SNAN=XXX, -DDBL_NAN=XXX, -DQNAN=XXX, -DSNAN=XXX, -DNAN=XXX These flags may enable various Perl internal debugging features. Their use is prohibited. -DDEBUGGING=XXX, -DMDH_HAS_SIZE=XXX, -DPERL_DEBUG_READONLY_COW=XXX, -DPERL_MEMORY_DEBUG_HEADER_SIZE=XXX, -DPERL_TRACE_OPS=XXX, -DTIME_64_DEBUG=XXX, -DUSE_HASH_SEED_DEBUG=XXX, -DUSE_MDH Enable debugging and assertions in the Storable module. Use of this flag is forbidden for reportable runs. Enables debugging output for leaked scalar variables. Its use will probably cause the benchmark to miscompare, and is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. Setting this macro to a value other than its default is forbidden. -DERRSV=XXX, -DDEFSV=XXX This macro has no function in the benchmark version of the source; its use is forbidden. -DDETACH=XXX This macro has no function in the benchmark version of the source; its use is forbidden. -DDIRSIZ=XXX This flag indicates that the source is being compiled on an MS-DOS system using the DJGPP development environment. This was not a porting target for CPU2017, so it's unlikely that using this flag will work. Setting this macro to a value other than its default is forbidden. This flag indicates that the source should not provide prototypes for standard functions. Setting this macro to a value other than its default is forbidden. This flag indicates that the benchmark is being built on a system that is like MS-DOS. This macro has no function in the benchmark version of the source; its use is forbidden. -DDPPP_NAMESPACE=XXX This macro has no function in the benchmark version of the source; its use is forbidden. Setting this macro to a value other than its default is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. -DDllMain=XXX Setting this macro to a value other than its default is forbidden. -DEACCES=XXX, -DEAI_AGAIN=XXX, -DEAI_BADFLAGS=XXX, -DEAI_FAIL=XXX, -DEAI_MEMORY=XXX, -DEAI_NODATA=XXX, -DEBADMSG=XXX, -DEIDRM=XXX, -DEINVAL=XXX, -DENODATA=XXX, -DENOMSG=XXX, -DENOSR=XXX, -DENOSTR=XXX, -DENOTRECOVERABLE=XXX, -DENOTSOCK=XXX, -DEOTHER=XXX, -DEOVERFLOW=XXX, -DETIME=XXX, -DETXTBSY=XXX This macro has no function in the benchmark version of the source; its use is forbidden. -DEAFNOSUPPORT=XXX, -DEAI_FAMILY=XXX, -DEAI_NONAME=XXX, -DEAI_SERVICE=XXX, -DEAI_SOCKTYPE=XXX, -DECONNABORTED=XXX, -DECONNREFUSED=XXX, -DECONNRESET=XXX, -DENOLINK=XXX This flag indicates that the benchmark is being built on an EBCDIC system. Good luck with that. This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. -DENDPWENT_R_HAS_FPTR, -DENDGRENT_R_HAS_FPTR, -DGETPWENT_R_HAS_FPTR, -DGETGRENT_R_HAS_FPTR, -DSETPWENT_R_HAS_FPTR, -DSETGRENT_R_HAS_FPTR, -DGETGRNAM_R_HAS_FPTR, -DGETPWNAM_R_HAS_FPTR, -DGETPWUID_R_HAS_FPTR, -DGETGRGID_R_HAS_FPTR This macro has no function in the benchmark version of the source; its use is forbidden. -DGETGRGID_R_HAS_PTR, -DGETGRGID_R_HAS_BUFFER, -DGETPROTOBYNUMBER_R_HAS_PTR, -DGETPROTOBYNUMBER_R_HAS_BUFFER, -DGETPWUID_R_HAS_PTR, -DGETPWUID_R_HAS_BUFFER, -DGETPWGID_R_HAS_PTR, -DGETPWGID_R_HAS_BUFFER, -DGETSERVBYPORT_R_HAS_PTR, -DGETSERVBYPORT_R_HAS_BUFFER, -DGETHOSTBYADDR_R_HAS_PTR, -DGETHOSTBYADDR_R_HAS_BUFFER, -DGETNETBYADDR_R_HAS_PTR, -DGETNETBYADDR_R_HAS_BUFFER, -DGETSERVBYNAME_R_HAS_PTR, -DGETSERVBYNAME_R_HAS_BUFFER, -DGETPROTOBYNAME_R_HAS_PTR, -DGETPROTOBYNAME_R_HAS_BUFFER, -DGETNETBYNAME_R_HAS_PTR, -DGETNETBYNAME_R_HAS_BUFFER, -DGETHOSTBYNAME_R_HAS_PTR, -DGETHOSTBYNAME_R_HAS_BUFFER, -DGETHOSTENT_R_HAS_PTR, -DGETHOSTENT_R_HAS_BUFFER, -DGETNETENT_R_HAS_PTR, -DGETNETENT_R_HAS_BUFFER, -DGETPROTOENT_R_HAS_PTR, -DGETPROTOENT_R_HAS_BUFFER, -DGETSERVENT_R_HAS_PTR, -DGETSERVENT_R_HAS_BUFFER, -DGETPWENT_R_HAS_PTR, -DGETPWENT_R_HAS_BUFFER, -DGETSPENT_R_HAS_PTR, -DGETSPENT_R_HAS_BUFFER, -DGETGRENT_R_HAS_PTR, -DGETGRENT_R_HAS_BUFFER, -DGETPWNAM_R_HAS_PTR, -DGETPWNAM_R_HAS_BUFFER, -DGETGRNAM_R_HAS_PTR, -DGETGRNAM_R_HAS_BUFFER, -DGETSPNAM_R_HAS_PTR, -DGETSPNAM_R_HAS_BUFFER, -DUSE_GRENT_BUFFER, -DUSE_HOSTENT_BUFFER, -DUSE_NETENT_BUFFER, -DUSE_PROTOENT_BUFFER, -DUSE_PWENT_BUFFER, -DUSE_SERVENT_BUFFER This macro has no function in the benchmark version of the source; its use is forbidden. -DGETHOSTBYADDR_R_HAS_ERRNO, -DGETHOSTBYNAME_R_HAS_ERRNO, -DGETHOSTENT_R_HAS_ERRNO, -DGETNETBYADDR_R_HAS_ERRNO, -DGETNETBYNAME_R_HAS_ERRNO, -DGETNETENT_R_HAS_ERRNO This flag indicates that environment variable names are not case-sensitive. This flag may be used to set the value returned by stdio functions upon encountering an end-of-file condition. -DEOF=XXX This macro has no function in the benchmark version of the source; its use is forbidden. If the "argv" argument to exec must be cast to a specific type, this flag may be used to do so. -DEXEC_ARGV_CAST=XXX Setting this macro to a value other than its default is forbidden. -DEXTERN=XXX, -DEXT=XXX This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. -DFAKE_THREADS, -DFAKE_PERSISTENT_SIGNAL_HANDLERS, -DFAKE_DEFAULT_SIGNAL_HANDLERS This macro has no function in the benchmark version of the source; its use is forbidden. -DFALSE=XXX, -DTRUE=XXX This flag should be used if the fcntl() function should be used for file locking. Setting this macro to a value other than its default is forbidden. -DFCNTL_EMULATE_FLOCK, -DLOCKF_EMULATE_FLOCK This macro has no function in the benchmark version of the source; its use is forbidden. -DUSE_SYSTEM_GMTIME, -DUSE_SYSTEM_LOCALTIME These macros may not be changed from their default values. This macro has no function in the benchmark version of the source; its use is forbidden. -DHAS_CRYPT_R, -DHAS_CTERMID_R, -DHAS_DDRAND48_R, -DHAS_SDRAND48_R, -DHAS_GETGRENT_R, -DHAS_GETHOSTENT_R, -DHAS_GETNETENT_R, -DHAS_GETPROTOENT_R, -DHAS_GETPWENT_R, -DHAS_GETSERVENT_R, -DHAS_SETGRENT_R, -DHAS_SETHOSTENT_R, -DHAS_SETNETENT_R, -DHAS_SETPROTOENT_R, -DHAS_SETPWENT_R, -DHAS_SETSERVENT_R, -DHAS_ENDGRENT_R, -DHAS_ENDHOSTENT_R, -DHAS_ENDNETENT_R, -DHAS_ENDPROTOENT_R, -DHAS_ENDPWENT_R, -DHAS_ENDSERVENT_R, -DHAS_GETGRGID_R, -DHAS_GETGRNAM_R, -DHAS_GETHOSTBYNAME_R, -DHAS_GETHOSTBYADDR_R, -DHAS_GETNETBYNAME_R, -DHAS_GETNETBYADDR_R, -DHAS_GETLOGIN_R, -DHAS_GETPROTOBYNAME_R, -DHAS_GETPROTOBYNUMBER_R, -DHAS_GETPWNAM_R, -DHAS_GETPWUID_R, -DHAS_GETSERVBYNAME_R, -DHAS_GETSERVBYPORT_R, -DHAS_GETSPNAM_R, -DHAS_CTIME_R, -DHAS_ASCTIME_R, -DHAS_LOCALTIME_R, -DHAS_GMTIME_R, -DHAS_SRANDOM_R, -DHAS_RANDOM_R, -DHAS_READDIR64_R, -DHAS_READDIR_R, -DHAS_SETLOCALE_R, -DHAS_STRERROR_R, -DHAS_TMPNAM_R, -DHAS_TTYNAME_R If the close-on-exec flag must or must not be set for open file descriptors before exec()ing, this flag may be used. -DFD_CLOEXEC=0, -DFD_CLOEXEC=1 This flag says that to flush all pending stdio output one must loop through all the stdio file handles and fflush them individually. This flag is ignored if FFLUSH_NULL is defined. Setting this macro to a value other than its default is forbidden. -DFILE=XXX This macro is used to access the _base field (or equivalent) of the FILE structure which is its argument. USE_STDIO_PTR must be defined for this to have any effect. -DFILE_base=XXX This macro is used to determine the number of bytes in the I/O buffer pointed to by the _base field (or equivalent) of the FILE structure which is its argument. USE_STDIO_PTR must be defined for this to have any effect. -DFILE_bufsiz=XXX This macro is used to access the _cnt field (or equivalent) of the FILE structure which is its argument. USE_STDIO_PTR must be defined for this to have any effect. -DFILE_cnt=XXX This macro is used to access the _ptr field (or equivalent) of the FILE structure which is its argument. USE_STDIO_PTR must be defined for this to have any effect. -DFILE_ptr=XXX Setting this macro to a value other than its default is forbidden. Attempting to setting this macro to a value other than its default is forbidden. -DBOOTSTRAP_CHARSET=XXX, -DFORMAT=XXX, -DSPACE=XXX This macro has no function in the benchmark version of the source; its use is forbidden. -DFP_INFINITE=XXX, -DFP_POS_DENORM=XXX, -DFP_POS_INF=XXX, -DFP_POS_NORM=XXX, -DFP_POS_ZERO=XXX, -DFP_PLUS_DENORM=XXX, -DFP_PLUS_INF=XXX, -DFP_PLUS_NORM=XXX, -DFP_PLUS_ZERO=XXX, -DFP_NEG_DENORM=XXX, -DFP_NEG_INF=XXX, -DFP_NEG_NORM=XXX, -DFP_NEG_ZERO=XXX, -DFP_MINUS_DENORM=XXX, -DFP_MINUS_INF=XXX, -DFP_MINUS_NORM=XXX, -DFP_MINUS_ZERO=XXX, -DFP_QNANS=XXX, -DFP_QNANQ=XXX, -DFP_QNAN=XXX, -DFP_SNANS=XXX, -DFP_SNANQ=XXX, -DFP_SNAN=XXX, -DFP_NANS=XXX, -DFP_NANQ=XXX, -DFP_NAN=XXX, -DFP_SUBNORMAL=XXX, -DFP_NORMAL=XXX, -DFP_NDENORM=XXX, -DFP_NNORM=XXX, -DFP_PDENORM=XXX, -DFP_PNORM=XXX, -DFP_NINF=XXX, -DFP_NZERO=XXX, -DFP_PINF=XXX, -DFP_PZERO=XXX, -DFP_INF=XXX, -DFP_ZERO=XXX This macro has no function in the benchmark version of the source; its use is forbidden. -DFREE_THREAD_KEY=XXXn -DALLOC_THREAD_KEY=XXXn This flag can be used to specify the size of the return value of fseek() (or fseeko()) in bytes. -DFSEEKSIZE=XXX -DStrerror=XXX This flag may be used to specify the name of the function that performs the equivalent of strerror(), if strerror() is not available on your system. -DStrtol=XXX This flag may be used to specify the name of the function that performs the equivalent of strtol(), if strtol() is not available on your system. -DStrtoul=XXX This flag may be used to specify the name of the function that performs the equivalent of strtoul(), if strtoul() is not available on your system. This flag may be used to specify the name of the function that performs the equivalent of fflush(), if fflush() is not available on your system. -DFflush=XXX This flag can be used to set the type used to declare file positions. -DFpos_t=XXX This flag can be used to set the return type of free(). -DFree_t=XXX This flag can be used to define the equivalent of the fstat() function. -DFstat=XXX Setting this macro to a value other than its default is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. Attempting to change the value of this macro is not allowed. -DG_WARN_ALL_OFF=XXX, -DG_WARN_ALL_ON=XXX, -DG_WARN_ALL_ONCE=XXX, -DG_WARN_ALL_MASK=XXX, -DG_WARN_OFF=XXX, -DG_WARN_ON=XXX, -DG_WARN_ONCE=XXX, -DG_WARN_MASK=XXX, -DpWARN_STD=XXX, -DpWARN_ALL=XXX, -DpWARN_NONE=XXX, -DspecialWARN=XXX, -DckWARN=XXX, -DpackWARN=XXX This macro holds the return type of getgid() and the type of the argument to setrgid() and related functions. -DGid_t=XXX Use this flag to set the size of Gid_t in bytes. -DGid_t_size=XXX Setting this macro to a value other than its default is forbidden. -DGpREFCNT_inc=XXX This flag lets the benchmark know that the access() system call is available to check for accessibility using real UID/GID. This flag lets the benchmark know that the accessx() call is available to do extended access checks. This macro has no function in the benchmark version of the source; its use is forbidden. This flag lets the benchmark know that the alarm() routine is available. This flag lets the benchmark know that the atoll() routine is available to convert strings into long longs. This flag lets the benchmark know that the bcmp() routine is available to compare blocks of memory. This flag lets the benchmark know that the bcopy() routine is available to copy blocks of memory. This flag indicates that a bool type is available. This flag lets the benchmark know that the bzero() routine is available to set a block of memory to 0. Setting this macro to a value other than its default is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. a function (like drand48(), flock(), etc; there are a large number of such functions) This flag is used to indicate that a prototype for $1 (this should be in lower-case) is available. -DHAS_DRAND48_PROTOS, -DHAS_DRAND48_PROTOTYPE, -DHAS_DRAND48_PROTO, -DHAS_FLOCK_PROTOS, -DHAS_FLOCK_PROTOTYPE, -DHAS_FLOCK_PROTO, -DHAS_GETENV_PROTOS, -DHAS_GETENV_PROTOTYPE, -DHAS_GETENV_PROTO, -DHAS_GETHOST_PROTOS, -DHAS_GETHOST_PROTOTYPE, -DHAS_GETHOST_PROTO, -DHAS_GETNET_PROTOS, -DHAS_GETNET_PROTOTYPE, -DHAS_GETNET_PROTO, -DHAS_GETPROTO_PROTOS, -DHAS_GETPROTO_PROTOTYPE, -DHAS_GETPROTO_PROTO, -DHAS_GETSERV_PROTOS, -DHAS_GETSERV_PROTOTYPE, -DHAS_GETSERV_PROTO, -DHAS_LSEEK_PROTOS, -DHAS_LSEEK_PROTOTYPE, -DHAS_LSEEK_PROTO, -DHAS_MODFL_PROTOS, -DHAS_MODFL_PROTOTYPE, -DHAS_MODFL_PROTO, -DHAS_REALLOC_PROTOS, -DHAS_REALLOC_PROTOTYPE, -DHAS_REALLOC_PROTO, -DHAS_SETRESUID_PROTO, -DHAS_SETRESGID_PROTO, -DHAS_SHMAT_PROTOS, -DHAS_SHMAT_PROTOTYPE, -DHAS_SHMAT_PROTO, -DHAS_SOCKATMARK_PROTOS, -DHAS_SOCKATMARK_PROTOTYPE, -DHAS_SOCKATMARK_PROTO, -DHAS_SYSCALL_PROTOS, -DHAS_SYSCALL_PROTOTYPE, -DHAS_SYSCALL_PROTO, -DHAS_TELLDIR_PROTOS, -DHAS_TELLDIR_PROTOTYPE, -DHAS_TELLDIR_PROTO, -DHAS_USLEEP_PROTOS, -DHAS_USLEEP_PROTOTYPE, -DHAS_USLEEP_PROTO This flag lets the benchmark know that the eaccess() call is available to do extended access checks. It is forbidden to set this macro to a value other than its default. -DHAS_FAST_STDIO, -DUSE_FAST_STDIO It is forbidden to set this macro to a value other than its default. This flag indicates that the "floatingpoint.h" header file is available. -DHAS_FPOS64_T, -DHAS_OFF64_T It is forbidden to set this macro to a value other than its default. Setting this macro to a value other than its default is forbidden. It is forbidden to set this macro to a value other than its default. Setting this macro to a value other than its default is forbidden. Setting this macro to a value other than its default is forbidden. Setting this macro to a value other than its default is forbidden. This enables code that tries to deal with a bug with Irix/NonStop-UX/PowerUX when calling sprintf with a long double argument. Setting this macro indicates that the sprintf() bug indicated by the HAS_LDBL_SPRINTF_BUG macro only affects values between -1L and 1L. Setting this macro to a value other than its default is forbidden. Setting this macro to a value other than its default is forbidden. Setting this macro to a value other than its default is forbidden. Setting this macro to a value other than its default is forbidden. -DNEED_PTHREAD_INIT, -DOLD_PTHREADS_API, -DOLD_PTHREAD_CREATE_JOINABLE, -DPTHREAD_ATFORK, -DPTHREAD_ATTR_SETDETACHSTATE, -DPTHREAD_CREATE_JOINABLE, -DPTHREAD_CREATE, -DPTHREAD_H_FIRST, -DHAS_PTHREAD_ATFORK, -DHAS_PTHREAD_YIELD, -DHAS_PTHREAD_UNCHECKED_GETSPECIFIC_NP, -DHAS_SCHED_YIELD, -DSCHED_YIELD=XXX, -DYIELD=XXX, -DSET_THR, -DTHR This macro has no function in the benchmark version of the source; its use is forbidden. This flag indicates that bcopy() can copy overlapping blocks of memory. Normally memcpy() should be used. This flag indicates that memcpy() can copy overlapping blocks of memory. This macro has no function in the benchmark version of the source; its use is forbidden. Setting this macro to a value other than its default is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. Setting this macro to a value other than its default is forbidden. This flag tells that there is an array holding the stdio streams. It is always enabled. It is forbidden to set this macro to a value other than its default. This macro has no function in the benchmark version of the source; its use is forbidden. -DHAS_TM_TM_GMTOFF, -DHAS_TM_TM_ZONE Setting this macro to a value other than its default is forbidden. -DHAS_UTF8_ALL, -DHAS_UTF8_HASHES, -DHAS_UTF8_SCALARS This macro should be set to indicate the presence of "w32api/windows.h" under Cygwin on Windows. This flag indicates that the benchmark code should emulate the behavior of waitpid. This macro has no function in the benchmark version of the source; its use is forbidden. -DHAS_GETGRENT, -DHAS_GETPWENT, -DHAS_SETGRENT, -DHAS_SETPWENT, -DHAS_ENDGRENT, -DHAS_ENDPWENT, -DHAS_GETGROUPS, -DHAS_SETGROUPS This macro has no function in the benchmark version of the source; its use is forbidden. -DHAS_GETHOSTENT, -DHAS_GETNETENT, -DHAS_GETPROTOENT, -DHAS_GETSERVENT, -DHAS_SETHOSTENT, -DHAS_SETNETENT, -DHAS_SETPROTOENT, -DHAS_SETSERVENT, -DHAS_ENDHOSTENT, -DHAS_ENDNETENT, -DHAS_ENDPROTOENT, -DHAS_ENDSERVENT, -DHAS_GETHOSTBYADDR, -DHAS_GETHOSTBYNAME, -DHAS_GETNETBYADDR, -DHAS_GETNETBYNAME, -DHAS_GETPROTOBYNAME, -DHAS_GETPROTOBYNUMBER, -DHAS_GETSERVBYNAME, -DHAS_GETSERVBYPORT, -DHAS_GETSPNAM, -DHAS_SOCKATMARK, -DHAS_SOCKET, -DHAS_SOCKETPAIR, -DHAS_SOCKS5_INIT This macro has no function in the benchmark version of the source; its use is forbidden. -DHAS_MNTENT, -DHAS_MNT, -DHAS_FSTATFS, -DHAS_FSTATVFS, -DHAS_FSTAT, -DHAS_HASMNTOPT, -DHAS_USTAT a function (like htonl(), ntohs(), etc; there are a large number of such functions) This flag is used to indicate that the $1 (this should be in lower-case) routine is available. -DHAS_HTONL, -DHAS_HTONS, -DHAS_HTOVL, -DHAS_HTOVS, -DHAS_HTOHL, -DHAS_HTOHS, -DHAS_VTONL, -DHAS_VTONS, -DHAS_VTOVL, -DHAS_VTOVS, -DHAS_VTOHL, -DHAS_VTOHS, -DHAS_NTONL, -DHAS_NTONS, -DHAS_NTOVL, -DHAS_NTOVS, -DHAS_NTOHL, -DHAS_NTOHS This macro has no function in the benchmark version of the source; its use is forbidden. a function (like fchdir(), fgetpos(), etc; there are a large number of such functions) This flag is used to indicate that the $1 (this should be in lower-case) routine is available. -DHAS_FCHDIR, -DHAS_FCHMOD, -DHAS_FSETPOS, -DHAS_FGETPOS, -DHAS_FSEEKO, -DHAS_FTELLO -DHAS_FINITE, -DHAS_FINITEL, -DHAS_FPCLASS, -DHAS_FPCLASSIFY, -DHAS_FPCLASSL, -DHAS_FPSETMASK, -DHAS_FP_CLASS, -DHAS_FREXPL, -DHAS_ISFINITE, -DHAS_ISNANL, -DHAS_MODFL, -DHAS_SQRTL, -DHAS_UNORDERED This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. -DHAS_FLOCK, -DHAS_FSYNC, -DHAS_LOCKF This macro has no function in the benchmark version of the source; its use is forbidden. -DHAS_READDIR, -DHAS_REWINDDIR, -DHAS_SEEKDIR, -DHAS_TELLDIR This macro has no function in the benchmark version of the source; its use is forbidden. -DHAS_GETPGID, -DHAS_GETPGRP2, -DHAS_GETPGRP, -DHAS_GETPRIORITY, -DHAS_SETPGID, -DHAS_SETPGRP2, -DHAS_SETPGRP, -DHAS_SETPRIORITY, -DHAS_GETPPID This macro has no function in the benchmark version of the source; its use is forbidden. -DHAS_SETEGID, -DHAS_SETEUID, -DHAS_SETREGID, -DHAS_SETREUID, -DHAS_SETRESGID, -DHAS_SETRESUID, -DHAS_SETRGID, -DHAS_SETRUID a function (like strerror(), strftime(), etc; there are a large number of such functions) This flag is used to indicate that the $1 (this should be in lower-case) routine is available. -DHAS_STRERROR, -DHAS_STRFTIME, -DHAS_STRLCAT, -DHAS_STRLCPY, -DHAS_STRTOLL, -DHAS_STRTOQ, -DHAS_STRTOUL, -DHAS_STRTOULL, -DHAS_STRTOUQ, -DHAS_INDEX -DHAS_SETITIMER, -DHAS_GETITIMER, -DHAS_UALARM, -DHAS_USLEEP, -DHAS_TIMES, -DHAS_MKTIME, -DHAS_UTIME Setting this macro to a value other than its default is forbidden. -DCPERLscope=XXX, -DHAS_UMASK, -DHAS_SETVBUF, -DHAS_GETLOGIN, -DHAS_GETPAGESIZE, -DHAS_ILOGBL, -DHAS_ISASCII, -DHAS_ISBLANK This macro has no function in the benchmark version of the source; its use is forbidden. -DHAS_KILL, -DHAS_KILLPG, -DHAS_SIGACTION, -DHAS_SIGPROCMASK Setting this macro to a value other than its default is forbidden. -DHAS_LINK, -DHAS_PIPE, -DHAS_READLINK, -DHAS_LSTAT, -DHAS_RENAME, -DHAS_MKSTEMP, -DHAS_MMAP, -DHAS_PAUSE, -DHAS_POLL, -DHAS_PRCTL_SET_NAME, -DHAS_SETLINEBUF, -DHAS_SETPROCTITLE, -DHAS_SYMLINK, -DHAS_SYSCALL, -DHAS_SYSCONF, -DHAS_UNAME, -DHAS__FWALK Setting this macro to a value other than its default is forbidden. -DHAS_LOCALECONV, -DHAS_MBTOWC, -DHAS_MSG, -DHAS_NL_LANGINFO, -DHAS_SETLOCALE localeconv(), msg(), etc This flag is used to indicate that the $1 (this should be in lower-case) routine is available. -DUSE_LOCALE_MESSAGES, -DUSE_LOCALE_MONETARY, -DUSE_LOCALE_TIME MESSAGES, LC_MONETARY, LC_TIME This flag is used to indicate that the setting of the LC_$1 variable should be honored. This will cause the benchmark to fail to validate, and may not be set. -DNO_LOCALE_MESSAGES, -DNO_LOCALE_MONETARY MESSAGES, LC_MONETARY This flag is used to indicate that the setting of the LC_$1 variable should not be honored. This is the default and may not be changed. This macro has no function in the benchmark version of the source; its use is forbidden. -DHAVE_INTERP_INTERN, -DHAVE_THREAD_INTERN This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. -DHZ=100 Contains the number of clock ticks in one second. It should be set by a system header file, but in case it's not, you can set it with this flag. -DH_PERL, -D_INC_PERL_XSUB_H, -D__Inc__IPerl___, -D__PATCHLEVEL_H_INCLUDED__, -D__perlapi_h__, -D___PerlHost_H___, -D_PERLIO_H, -D_PERLIOL_H, -DPOLL_H, -D_P_P_PORTABILITY_H_, -DREENTR_H, -DREENTRINC, -D_config_h_, -D___VDir_H___, -D___VMEM_H_INC___, -D_INC_WIN32_PERL5, -DWIN32IOP_H, -D_WIN32THREAD_H, -D_INC_DIRENT, -D_INC_NETDB, -D_INC_SYS_SOCKET, -D_specconfig_h, -D_STDINT_H, -DH_REGCHARCLASS, -DH_UNICODE_CONSTANTS, -DH_UTF8, -DPERL_SEEN_HV_FUNC_H, -DTIME64_CONFIG_H, -DTIME64_H, -DHANDY_H These macros are used to prevent multiple header inclusion; setting them explicitly is forbidden. Setting this macro to a value other than its default is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. -DINT16_MAX=32767, -DINT32_MAX=2147483647, -DINT64_MAX=9223372036854775807 16 (or 32 or 64) This flag can be used to set the largest positive number that can fit in an $1-bit integer. Its value is not used in all cases. -DINT16_MIN=-32768, -DINT32_MIN=-2147483648, -DINT64_MIN=-9223372036854775808 16 (or 32 or 64) This flag can be used to set the smallest negative number that can fit in an $1-bit integer. Its value is not used in all cases. -DUINT8_MAX=256, -DUINT16_MAX=65536, -DUINT32_MAX=4294967296, -DUINT64_MAX=18446744073709551616LL 8 (or 16 or 32 or 64) This flag can be used to set the largest positive number that can fit in an unsigned $1-bit integer. Its value is not used in all cases. -DUINT32_MIN=0, -DUINT64_MIN=0 32 (or 64) This flag can be used to set the smallest number that can fit in an unsigned $1-bit integer. Its value is not used in all cases. -DUCHAR_MAX=256, -DMAXUCHAR=256 This flag can be used to indicate to the benchmark the largest value that can be stored in an unsigned char. -DUSHORT_MAX=65536, -DMAXUSHORT=65536, -DUSHRT_MAX=65536 This flag can be used to indicate to the benchmark the largest value that can be stored in an unsigned short integer. -DUINT_MAX=4294967296, -DMAXUINT=4294967296 This flag can be used to indicate to the benchmark the largest value that can be stored in an unsigned integer. -DULONG_MAX=4294967296, -DMAXULONG=4294967296 This flag can be used to indicate to the benchmark the largest value that can be stored in an unsigned long integer. -DULLONG_MAX=18446744073709551616LL, -DULONG_LONG_MAX=18446744073709551616LL, -DULONGLONG_MAX=18446744073709551616LL, -DMAXULONGLONG=18446744073709551616LL This flag can be used to indicate to the benchmark the largest value that can be stored in an unsigned long long integer. -DMAXDOUBLE=23482749729348729384 This flag can be use to indicate to the benchmark the largest value that is representable by a double. -DMINDOUBLE=-23482749729348729384 This flag can be use to indicate to the benchmark the smallest value that is representable by a double. -DMAXSHORT=32767, -DSHORT_MAX=32767, -DSHRT_MAX=32767 This flag can be used to indicate to the benchmark the largest value that can be stored in a short integer. -DINT_MAX=2147483647, -DMAXINT=2147483647 This flag can be used to indicate to the benchmark the largest value that can be stored in an integer. -DLONG_MAX=2147483647, -DMAXLONG=2147483647 This flag can be used to set the largest positive number that can fit in a long integer. Its value is not used in all cases. -DLONGLONG_MAX=9223372036854775807, -DMAXLONGLONG=9223372036854775807 This flag can be used to set the largest positive number that can fit in a long long integer. Its value is not used in all cases. -DMINSHORT=-32768, -DSHORT_MIN=-32768, -DSHRT_MIN=-32768 This flag can be used to indicate to the benchmark the smallest value that can be stored in a short integer. -DINT_MIN=-2147483648, -DMININT=-2147483648 This flag can be used to indicate to the benchmark the smallest value that can be stored in an integer. -DMINLONG=-2147483648, -DLONG_MIN=-2147483648 This flag can be used to indicate to the benchmark the smallest value that can be stored in a long integer. -DMINLONGLONG=-9223372036854775808LL, -DLONGLONG_MIN=-9223372036854775808LL This flag can be used to indicate to the benchmark the smallest value that can be stored in a long long integer. The values for these macros may not be set directly. -DPERL_INT_MAX=0, -DPERL_INT_MIN=0, -DPERL_LONG_MAX=0, -DPERL_LONG_MIN=0, -DPERL_QUAD_MAX=0, -DPERL_QUAD_MIN=0, -DPERL_SHORT_MAX=0, -DPERL_SHORT_MIN=0, -DPERL_UCHAR_MAX=0, -DPERL_UCHAR_MIN=0, -DPERL_UINT_MAX=0, -DPERL_UINT_MIN=0, -DPERL_ULONG_MAX=0, -DPERL_ULONG_MIN=0, -DPERL_UQUAD_MAX=0, -DPERL_UQUAD_MIN=0, -DPERL_USHORT_MAX=0, -DPERL_USHORT_MIN=0, -DINT32_MIN_BROKEN, -DINT32_MAX_BROKEN, -DINT64_MIN_BROKEN, -DINT64_MAX_BROKEN, -DUINT32_MAX_BROKEN INT32_MAX (or INT32_MIN, or INT64_MAX, or INT64_MIN, or UINT32_MAX) If the macro $1 is set incorrectly by default, this flag may be used to indicate that that macro's value should not be used. -DINT2PTR=XXX, -DNUM2PTR=XXX, -DPTR2INT=XXX Setting this macro to a value other than its default is forbidden. Setting this macro to a value other than its default is forbidden. -DIN_LOCALE=XXX, -DIN_LOCALE_COMPILETIME=XXX, -DIN_LOCALE_RUNTIME=XXX, -DIN_PERL_COMPILETIME=XXX This macro has no function in the benchmark version of the source; its use is forbidden. -D_SOCKADDR_LEN=XXX, -DPIPESOCK_MODE=XXX, -DPIPE_OPEN_MODE=XXX, -DSOCKET_OPEN_MODE=XXX, -DSOCKS5_VERSION_NAME=XXX, -DSock_size_t=XXX, -DSOCK_DGRAM, -DPERL_SOCKS_NEED_PROTOTYPES, -DPERL_SOCK_SYSREAD_IS_RECV, -DPERL_SOCK_SYSWRITE_IS_SEND, -DUSE_SOCKETS_AS_HANDLES, -DUSE_SOCKS, -DVMS_DO_SOCKETS, -DDECCRTL_SOCKETS, -DEMULATE_SOCKETPAIR_UDP, -DHAS_SOCKET__bad_code_maybe This macro has no function in the benchmark version of the source; its use is forbidden. -DIOCPARM_LEN=XXX, -DIOCPARM_MASK=XXX It is forbidden to set this macro to a value other than its default. -DIOf_UNTAINT=XXX This macro has no function in the benchmark version of the source; its use is forbidden. These macros hold Perl internal values, and must not be changed. -DIS_NUMBER_GREATER_THAN_UV_MAX=XXX, -DIS_NUMBER_INFINITY=XXX, -DIS_NUMBER_IN_UV=XXX, -DIS_NUMBER_NAN=XXX, -DIS_NUMBER_NEG=XXX, -DIS_NUMBER_NOT_INT=XXX It is forbidden to set this macro to a value other than its default. -DITIMER_PROF, -DITIMER_REAL, -DITIMER_REALPROF, -DITIMER_VIRTUAL -DIV_IS_QUAD, -DUV_IS_QUAD IV (or UV) This flag indicates that the Perl $1 is a quad type. It is set automatically. This macro has no function in the benchmark version of the source; its use is forbidden. -DI_MACH_CTHREADS, -DI_NETINET_IN, -DI_NET_ERRNO Use of this flag indicates that the "$1.h" (lower-case, of course) should be used. -DI_CRYPT, -DI_FP, -DI_FP_CLASS, -DI_GRP, -DI_IEEEFP, -DI_IEEFP, -DI_LANGINFO, -DI_LIBUTIL, -DI_LOCALE, -DI_MEMORY, -DI_MNTENT, -DI_NDBM, -DI_NETDB, -DI_POLL, -DI_PTHREAD, -DI_PWD, -DI_SFIO, -DI_SHADOW, -DI_SOCKS, -DI_SUNMATH, -DI_USTAT, -DI_VALUES, -DI_VARARGS Use of this flag indicates that the "sys/$1.h" (lower-case, of course) should be used. -DI_SYSMODE, -DI_SYSUTSNAME, -DI_SYS_ACCESS, -DI_SYS_DIR, -DI_SYS_MOUNT, -DI_SYS_NDIR, -DI_SYS_RESOURCE, -DI_SYS_SECURITY, -DI_SYS_SELECT, -DI_SYS_SOCKIO, -DI_SYS_STATFS, -DI_SYS_STATVFS, -DI_SYS_TIME_KERNEL, -DI_SYS_VFS These flags are used to set the locale at compilation time. You're allowed to set them, but use of ANY locale other than "C" will almost certainly cause the benchmark to miscompare. -DLC_ALL=ja_JP, -DLC_COLLATE=ja_JP, -DLC_CTYPE=ja_JP, -DLC_MESSAGES=ja_JP, -DLC_MONETARY=ja_JP, -DLC_NUMERIC=ja_JP It is forbidden to set this macro to a value other than its default. This flag indicates that libm exports _LIB_VERSION and that math.h defines the enum to manipulate it. This flag indicates that setlocale() requires that at least one of the standard locate environment variables be defined. Using locales will probably break the benchmark, but you're welcome to try anyway. -DLOCAL_PATCH_COUNT=1 This macro has no function in the benchmark version of the source; its use is forbidden. Setting this macro to a value other than its default is forbidden. -DLOCK_CRED_MUTEX=XXX, -DLOCK_DOLLARZERO_MUTEX=XXX, -DLOCK_FDPID_MUTEX=XXX, -DLOCK_STRTAB_MUTEX=XXX, -DLOCK_SV_LOCK_MUTEX=XXX, -DLOCK_SV_MUTEX=XXX, -DUNLOCK_CRED_MUTEX=XXX, -DUNLOCK_DOLLARZERO_MUTEX=XXX, -DUNLOCK_FDPID_MUTEX=XXX, -DUNLOCK_STRTAB_MUTEX=XXX, -DUNLOCK_SV_LOCK_MUTEX=XXX, -DUNLOCK_SV_MUTEX=XXX These lock constants should be supplied by your system header files. They may not be set directly. -DLOCK_EX=XXX, -DLOCK_NB=XXX, -DLOCK_SH=XXX, -DLOCK_UN=XXX These macros are used to indicate compilation on a system that is not supported. They may not be used. -DMACOS_TRADITIONAL, -DMPE, -DMSDOS, -D__LIBCATAMOUNT__, -DSYMBIAN, -DWINS It is forbidden to set this macro to a value other than its default. -DMAXPATHLEN=2048, -DPATH_MAX=2048, -D_POSIX_PATH_MAX=2048 This macro contains the maximum length for a path name. It should be supplied by system header files, but in case it is not, you can specify it using this flag. This macro has no function in the benchmark version of the source; its use is forbidden. -DMAXHOSTNAMELEN=XXX, -DMAXSYMLINKS=XXX, -DMAXSYSFD=XXX This flag enables debugging output from the Digest::MD5 module. This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. -DMULTIPLICITY, -DMULTIPLICTY This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. -DMUTEX_DESTROY=XXX, -DMUTEX_INIT=XXX, -DMUTEX_INIT_CALLS_MALLOC=XXX, -DMUTEX_INIT_NEEDS_MUTEX_ZEROED=XXX, -DMUTEX_LOCK=XXX, -DMUTEX_UNLOCK=XXX, -DMY_CXT_CLONE=XXX, -DMY_CXT_KEY=XXX, -DSTART_MY_CXT=XXX, -DUSE_MY_CXT=XXX, -D_REENTRANT, -DJOIN=XXX It is forbidden to set this macro to a value other than its default. This flag can be used to define the equivalent of the mkdir() function. -DMkdir=XXX This flag can be used to define the equivalent of the stat() function. -DStat=XXX -DMoveD=XXX It is forbidden to set this macro to a value other than its default. This macro has no function in the benchmark version of the source; its use is forbidden. It is forbidden to set this macro to a value other than its default. -DNBBY=XXX This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. -DNEED_GETPID_PROTO, -DNEED_TELLDIR_PROTO This macro has no function in the benchmark version of the source; its use is forbidden. -DNEED_eval_pv, -DNEED_eval_pv_GLOBAL, -DNEED_grok_bin, -DNEED_grok_bin_GLOBAL, -DNEED_grok_hex, -DNEED_grok_hex_GLOBAL, -DNEED_grok_number, -DNEED_grok_number_GLOBAL, -DNEED_grok_numeric_radix, -DNEED_grok_numeric_radix_GLOBAL, -DNEED_grok_oct, -DNEED_grok_oct_GLOBAL, -DNEED_newCONSTSUB, -DNEED_newCONSTSUB_GLOBAL, -DNEED_newRV_noinc, -DNEED_newRV_noinc_GLOBAL, -DNEED_sv_2pv_nolen, -DNEED_sv_2pv_nolen_GLOBAL, -DNEED_sv_2pvbyte, -DNEED_sv_2pvbyte_GLOBAL, -DNEED_sv_catpvf_mg, -DNEED_sv_catpvf_mg_GLOBAL, -DNEED_sv_catpvf_mg_nocontext, -DNEED_sv_catpvf_mg_nocontext_GLOBAL, -DNEED_sv_setpvf_mg, -DNEED_sv_setpvf_mg_GLOBAL, -DNEED_sv_setpvf_mg_nocontext, -DNEED_sv_setpvf_mg_nocontext_GLOBAL, -DNEED_vnewSVpvf, -DNEED_vnewSVpvf_GLOBAL This macro has no function in the benchmark version of the source; its use is forbidden. -DNFDBITS=XXX This macro has no function in the benchmark version of the source; its use is forbidden. -DNGROUPS=XXX This macro has no function in the benchmark version of the source; its use is forbidden. Setting this macro to a value other than its default is forbidden. -DNOFILE=XXX This macro has no function in the benchmark version of the source; its use is forbidden. -DNOOP=XXX This macro defines the contents of one of Perl's internal functions. Setting it to a non-default value is forbidden. This flag un-does the effect of its non-NO counterpart. These are ALL the defaults, so there's no reason to use one. -DNO_56_INTERWORK_KLUDGE, -DNO_64_BIT_RAWIO, -DNO_64_BIT_STDIO, -DNO_EFF_ONLY_OK, -DNO_ENVIRON_ARRAY, -DNO_HASH_SEED, -DNO_LOCALE_COLLATE, -DNO_LOCALE_CTYPE, -DNO_LOCALE_NUMERIC, -DNO_PERL_PRESERVE_IVUV, -DNO_UNARY_PLUS, -DNO_XSLOCKS -DNX_CURRENT_COMPILER_RELEASE=XXX This constant should be supplied by your system header files. It may not be set directly. -DOPpENTERSUB_HASTARG=XXX This macro defines the contents of one of Perl's internal constants. Setting it to a non-default value is forbidden. -DOutputStream=XXX This macro defines the contents of one of Perl's internal types. Setting it to a non-default value is forbidden. -DPAGESIZE=XXX Setting this macro to a value other than its default is forbidden. This flag can be used if sys/types.h should be included before sys/param.h. -DPATCHLEVEL=XXX, -DPERL_PATCHNUM=XXX Setting these macros to values other than default is forbidden. In some cases, this flag may be used to set the maximum number of stdio FILE objects that will be fflush()ed when attempting to flush all streams. -DPERL_FFLUSH_ALL_FOPEN_MAX=XXX, -DFOPEN_MAX=XXX, -DOPEN_MAX=XXX, -D_NFILE=XXX This macro is used internally by Perl. Setting it explicitly is not allowed. -DALWAYS_NEED_THX, -DMGf_COPY, -DMGf_DUP, -DMGf_LOCAL, -DPERL_ALLOC_CHECK, -DPERL_ANY_COW, -DPERL_ARGS_ASSERT_CK_WARNER, -DPERL_ARGS_ASSERT_CROAK_XS_USAGE, -DPERL_ARGS_ASSERT__INVLISTEQ, -DPERL_ARENA_SIZE, -DPERL_ASYNC_CHECK, -DPERL_BLOCKSIG_ADD, -DPERL_BLOCKSIG_BLOCK, -DPERL_BLOCKSIG_UNBLOCK, -DPERL_BLOCK_SIGNALS, -DPERL_CALLCONV, -DPERL_CALLCONV_NO_RET, -DPERL_CAPI, -DPERL_CHECK_INITED, -DPERL_CR_FILTER, -DPERL_DARWIN, -DPERL_DECIMAL_VERSION, -DPERL_DECL_PROT, -DPERL_DISABLE_PMC, -DPERL_EFF_ACCESS, -DPERL_EFF_ACCESS_R_OK, -DPERL_EFF_ACCESS_W_OK, -DPERL_EFF_ACCESS_X_OK, -DPERL_EXT, -DPERL_EXTERNAL_GLOB, -DPERL_EXTMALLOC_DEF, -DPERL_EXT_IO, -DPERL_EXT_POSIX, -DPERL_EXT_RE_BUILD, -DPERL_EXT_RE_DEBUG, -DPERL_FD_SETSIZE, -DPERLIO_IS_BINMODE_FD, -DPERLIO_IS_STDIO, -DPERLIO_LAYERS, -DPERLIO_NOT_STDIO, -DPERLIO_USING_CRLF, -DPERLLIB_MANGLE, -DPERL_FLEXIBLE_EXCEPTIONS, -DPERL_FLUSHALL_FOR_CHILD, -DPERL_FOR_X2P, -DPERL_FPU_INIT, -DPERL_FPU_PRE_EXEC, -DPERL_FS_VERSION, -DPERL_FS_VER_FMT, -DPERL_USE_GCC_BRACE_GROUPS, -DPERL_GCC_BRACE_GROUPS_FORBIDDEN, -DPERL_GCC_PEDANTIC, -DPERL_GET_CONTEXT, -DPERL_GET_CONTEXT_DEFINED, -DPERL_GET_INTERP, -DPERL_GET_SIG_CONTEXT, -DPERL_GET_THX, -DPERL_GLOBAL_STRUCT, -DPERL_GLOBAL_STRUCT_INIT, -DPERL_GLOBAL_STRUCT_PRIVATE, -DPERL_GPROF_CONTROL, -DPERL_HASH, -DPERL_HASH_INTERNAL_ACCESS, -DPERL_HASH_FUNC, -DPERL_HASH_FUNC_DJB2, -DPERL_HASH_FUNC_MURMUR3, -DPERL_HASH_FUNC_ONE_AT_A_TIME, -DPERL_HASH_FUNC_ONE_AT_A_TIME_HARD, -DPERL_HASH_FUNC_ONE_AT_A_TIME_OLD, -DPERL_HASH_FUNC_SDBM, -DPERL_HASH_FUNC_SIPHASH, -DPERL_HASH_FUNC_SUPERFAST, -DPERL_HASH_RANDOMIZE_KEYS, -DPERL_HASH_SEED, -DPERL_HASH_SEED_BYTES, -DPERL_IMPLICIT_CONTEXT, -DPERL_IMPLICIT_SYS, -DPERL_INC_VERSION_LIST, -DPERL_IN_XSUB_RE, -DPERL_IRIX5_SELECT_TIMEVAL_VOID_CAST, -DPERL_MG_UFUNC, -DPERL_MICRO, -DPERL_MSVCRT_READFIX, -DPERL_NOCOMPAT, -DPERL_NO_COW, -DPERL_NO_INLINE_FUNCTIONS, -DPERL_NO_DEV_RANDOM, -DPERL_NO_FORCE_LINK, -DPERL_NO_GET_CONTEXT, -DPERL_NO_SHORT_NAMES, -DPERL_NO_UTF16_FILTER, -DPERL_OBJECT, -DPERL_OTHERLIBDIRS, -DPERL_PACK_CAN_BYTEORDER, -DPERL_PACK_CAN_SHRIEKSIGN, -DPERL_PATCHLEVEL_H_IMPLICIT, -DPERL_POLLUTE, -DPERL_POLLUTE_MALLOC, -DPERL_PRESERVE_IVUV, -DPERL_RANDOM_DEVICE, -DPERL_REVISION, -DPERL_SCAN_ALLOW_UNDERSCORES, -DPERL_SCAN_DISALLOW_PREFIX, -DPERL_SCAN_GREATER_THAN_UV_MAX, -DPERL_SCAN_SILENT_ILLDIGIT, -DPERL_SCO, -DPERL_SCRIPT_MODE, -DPERL_SET_CONTEXT, -DPERL_SET_INTERP, -DPERL_SET_THX, -DPERL_SLAB_SIZE, -DPERL_STACK_OVERFLOW_CHECK, -DPERL_STATIC_SYMS, -DPERL_STRICT_CR, -DPERL_SUBVERSION, -DSUBVERSION, -DPERL_SYNC_FORK, -DPERL_SYS_INIT, -DPERL_SYS_INIT3, -DPERL_SYS_TERM, -DPERL_TEXTMODE_SCRIPTS, -DPERL_TRY_UV_DIVIDE, -DPERL_USE_SAFE_PUTENV, -DPERL_USE_THREADS, -DPERL_UTF8_CACHE_ASSERT, -DPERL_VERSION, -DPERL_VERSION_DECIMAL, -DPERL_VERSION_GE, -DPERL_VERSION_LE, -DPERL_VERSION_LT, -DPERL_WAIT_FOR_CHILDREN, -DPERL_WRITE_MSG_TO_CONSOLE, -DPERL_XSUB_OLDSTYLE, -DPERL_Y2KWARN, -DMEMBER_TO_FPTR=XXX These macros are used to indicate that a particular module is being compiled. Setting them explicitly is not allowed. -DPERL_IN_XS_APITEST, -DPERL_IN_AV_C, -DPERL_IN_DEB_C, -DPERL_IN_DOOP_C, -DPERL_IN_DOIO_C, -DPERL_IN_DUMP_C, -DPERL_IN_GV_C, -DPERL_IN_HV_C, -DPERL_IN_LOCALE_C, -DPERL_IN_MG_C, -DPERL_IN_MALLOC_C, -DPERL_IN_NUMERIC_C, -DPERL_IN_OP_C, -DPERL_IN_PAD_C, -DPERL_IN_PERL_C, -DPERL_IN_PP_C, -DPERL_IN_PP_CTL_C, -DPERL_IN_PP_HOT_C, -DPERL_IN_PP_PACK_C, -DPERL_IN_PP_SYS_C, -DPERL_IN_REGCOMP_C, -DPERL_IN_REGEXEC_C, -DPERL_IN_SCOPE_C, -DPERL_IN_SV_C, -DPERL_IN_TOKE_C, -DPERL_IN_UNIVERSAL_C, -DPERL_IN_UTIL_C, -DPERL_IN_MADLY_C, -DPERL_IN_MRO_C, -DPERL_IN_PERLY_C, -DPERL_IN_PP_CTL_C, -DPERL_IN_PP_SORT_C, -DPERL_IN_UTF8_C These macros contain values that are "special" to Perl. They may not be changed. -DPERL_MAGIC_arylen=XXX, -DPERL_MAGIC_backref=XXX, -DPERL_MAGIC_bm=XXX, -DPERL_MAGIC_collxfrm=XXX, -DPERL_MAGIC_dbfile=XXX, -DPERL_MAGIC_dbline=XXX, -DPERL_MAGIC_defelem=XXX, -DPERL_MAGIC_env=XXX, -DPERL_MAGIC_envelem=XXX, -DPERL_MAGIC_ext=XXX, -DPERL_MAGIC_fm=XXX, -DPERL_MAGIC_glob=XXX, -DPERL_MAGIC_isa=XXX, -DPERL_MAGIC_isaelem=XXX, -DPERL_MAGIC_mutex=XXX, -DPERL_MAGIC_nkeys=XXX, -DPERL_MAGIC_overload=XXX, -DPERL_MAGIC_overload_elem=XXX, -DPERL_MAGIC_overload_table=XXX, -DPERL_MAGIC_pos=XXX, -DPERL_MAGIC_qr=XXX, -DPERL_MAGIC_regdata=XXX, -DPERL_MAGIC_regdatum=XXX, -DPERL_MAGIC_regex_global=XXX, -DPERL_MAGIC_shared=XXX, -DPERL_MAGIC_shared_scalar=XXX, -DPERL_MAGIC_sig=XXX, -DPERL_MAGIC_sigelem=XXX, -DPERL_MAGIC_substr=XXX, -DPERL_MAGIC_sv=XXX, -DPERL_MAGIC_taint=XXX, -DPERL_MAGIC_tied=XXX, -DPERL_MAGIC_tiedelem=XXX, -DPERL_MAGIC_tiedscalar=XXX, -DPERL_MAGIC_utf8=XXX, -DPERL_MAGIC_uvar=XXX, -DPERL_MAGIC_uvar_elem=XXX, -DPERL_MAGIC_vec=XXX, -DPERL_MAGIC_vstring=XXX, This macro is used to hold the name of a Perl internal function. It may not be set explicitly. -DPL_dowarn=XXX, -DPL_hexdigit=XXX, -DPL_numeric_radix_sv=XXX, -DPL_sv_undef=XXX, -DPerlIO=XXX, -DPerlIO_apply_layers=XXX, -DPerlIO_binmode=XXX, -DPerlIO_canset_cnt=XXX, -DPerlIO_clearerr=XXX, -DPerlIO_eof=XXX, -DPerlIO_error=XXX, -DPerlIO_exportFILE=XXX, -DPerlIO_fast_gets=XXX, -DPerlIO_fdopen=XXX, -DPerlIO_fdupopen=XXX, -DPerlIO_findFILE=XXX, -DPerlIO_get_base=XXX, -DPerlIO_get_bufsiz=XXX, -DPerlIO_get_cnt=XXX, -DPerlIO_get_ptr=XXX, -DPerlIO_getc=XXX, -DPerlIO_getname=XXX, -DPerlIO_getpos=XXX, -DPerlIO_has_base=XXX, -DPerlIO_has_cntptr=XXX, -DPerlIO_importFILE=XXX, -DPerlIO_init=XXX, -DPerlIO_isutf8=XXX, -DPerlIO_modestr=XXX, -DPerlIO_open=XXX, -DPerlIO_openn=XXX, -DPerlIO_printf=XXX, -DPerlIO_putc=XXX, -DPerlIO_puts=XXX, -DPerlIO_read=XXX, -DPerlIO_releaseFILE=XXX, -DPerlIO_rewind=XXX, -DPerlIO_seek=XXX, -DPerlIO_set_cnt=XXX, -DPerlIO_set_ptrcnt=XXX, -DPerlIO_setlinebuf=XXX, -DPerlIO_setpos=XXX, -DPerlIO_sprintf=XXX, -DPerlIO_stderr=XXX, -DPerlIO_stdin=XXX, -DPerlIO_stdout=XXX, -DPerlIO_stdoutf=XXX, -DPerlIO_tell=XXX, -DPerlIO_tmpfile=XXX, -DPerlIO_ungetc=XXX, -DPerlIO_unread=XXX, -DPerlIO_vprintf=XXX, -DPerlIO_vsprintf=XXX, -DPerlIO_write=XXX, -DPerl_debug_log=XXX, -DPerl_error_log=XXX, -DPerl_fp_class=XXX, -DPerl_fp_class_finite=XXX, -DPerl_fp_class_inf=XXX, -DPerl_fp_class_nan=XXX, -DPerl_isfinite=XXX, -DPerl_isinf=XXX, -DPerl_isnan=XXX Setting this macro to a value other than its default is forbidden. -DPOLLERR, -DPOLLHUP, -DPOLLIN, -DPOLLNORM, -DPOLLNVAL, -DPOLLOUT, -DPOLLPRI, -DPOLLRDBAND, -DPOLLRDNORM, -DPOLLWRBAND, -DPOLLWRNORM, -D_IOFBF, -D_IOLBF, -D_IONBF This macro has no function in the benchmark version of the source; its use is forbidden. -DPROCESSOR_ARCHITECTURE_ALPHA64, -DPROCESSOR_ARCHITECTURE_AMD64, -DPROCESSOR_ARCHITECTURE_ARM, -DPROCESSOR_ARCHITECTURE_IA32_ON_WIN64, -DPROCESSOR_ARCHITECTURE_IA64, -DPROCESSOR_ARCHITECTURE_MSIL, -DPROCESSOR_ARCHITECTURE_SHX, -DPROCESSOR_ARCHITECTURE_UNKNOWN -DPROCSELFEXE_PATH=XXX This macro has no function in the benchmark version of the source; its use is forbidden. -DPSHIFT=XXX Setting this macro to a value other than its default is forbidden. -DPSTAT_SETCMD=XXX This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. -DPWAGE, -DPWCHANGE, -DPWCLASS, -DPWCOMMENT, -DPWEXPIRE, -DPWGECOS, -DPWPASSWD, -DPWQUOTA -DPerlProc_pause=XXX This macro defines the contents of one of Perl's internal functions. Setting it to a non-default value is forbidden. This symbol is set automatically and may not be set explicitly. -DPoison=XXX, -DPoisonFree=XXX, -DPoisonNew=XXX, -DPoisonWith=XXX This macro defines the contents of one of Perl's internal functions. Setting it to a non-default value is forbidden. Setting this macro to a value other than its default is forbidden. -DQSORT_BREAK_EVEN, -DQSORT_DEBUG, -DQSORT_MAX_STACK, -DQSORT_ORDER_GUESS, -DQSORT_PLAY_SAFE Use this flag if __int64 is the quad data type available. Use this flag if int64_t is the quad data type available. Use this flag if long is the quad data type available. Use this flag if long long is the quad data type available. This macro may be used to change the default value of CHARBITS on systems that need it. -DRANDBITS=32 This macro has no function in the benchmark version of the source; its use is forbidden. This flag can be used to indicate the return code from read() when no data is present on the non-blocking file descriptor. -DRD_NODATA=XXX Setting this macro to a value other than its default is forbidden. -DREENTRANT_PROTO_B_B=XXX, -DREENTRANT_PROTO_B_BI=XXX, -DREENTRANT_PROTO_B_BW=XXX, -DREENTRANT_PROTO_B_CCD=XXX, -DREENTRANT_PROTO_B_CCS=XXX, -DREENTRANT_PROTO_B_IBI=XXX, -DREENTRANT_PROTO_B_IBW=XXX, -DREENTRANT_PROTO_B_SB=XXX, -DREENTRANT_PROTO_B_SBI=XXX, -DREENTRANT_PROTO_I_BI=XXX, -DREENTRANT_PROTO_I_BW=XXX, -DREENTRANT_PROTO_I_CCSBWR=XXX, -DREENTRANT_PROTO_I_CCSD=XXX, -DREENTRANT_PROTO_I_CII=XXX, -DREENTRANT_PROTO_I_CIISD=XXX, -DREENTRANT_PROTO_I_CSBI=XXX, -DREENTRANT_PROTO_I_CSBIR=XXX, -DREENTRANT_PROTO_I_CSBWR=XXX, -DREENTRANT_PROTO_I_CSBWRE=XXX, -DREENTRANT_PROTO_I_CSD=XXX, -DREENTRANT_PROTO_I_CWISBWRE=XXX, -DREENTRANT_PROTO_I_CWISD=XXX, -DREENTRANT_PROTO_I_D=XXX, -DREENTRANT_PROTO_I_H=XXX, -DREENTRANT_PROTO_I_IBI=XXX, -DREENTRANT_PROTO_I_IBW=XXX, -DREENTRANT_PROTO_I_ICBI=XXX, -DREENTRANT_PROTO_I_ICSBWR=XXX, -DREENTRANT_PROTO_I_ICSD=XXX, -DREENTRANT_PROTO_I_ID=XXX, -DREENTRANT_PROTO_I_IISD=XXX, -DREENTRANT_PROTO_I_ISBWR=XXX, -DREENTRANT_PROTO_I_ISD=XXX, -DREENTRANT_PROTO_I_LISBI=XXX, -DREENTRANT_PROTO_I_LISD=XXX, -DREENTRANT_PROTO_I_LS=XXX, -DREENTRANT_PROTO_I_SB=XXX, -DREENTRANT_PROTO_I_SBI=XXX, -DREENTRANT_PROTO_I_SBIE=XXX, -DREENTRANT_PROTO_I_SBIH=XXX, -DREENTRANT_PROTO_I_SBIR=XXX, -DREENTRANT_PROTO_I_SBWR=XXX, -DREENTRANT_PROTO_I_SBWRE=XXX, -DREENTRANT_PROTO_I_SD=XXX, -DREENTRANT_PROTO_I_ST=XXX, -DREENTRANT_PROTO_I_St=XXX, -DREENTRANT_PROTO_I_TISD=XXX, -DREENTRANT_PROTO_I_TS=XXX, -DREENTRANT_PROTO_I_TSBI=XXX, -DREENTRANT_PROTO_I_TSBIR=XXX, -DREENTRANT_PROTO_I_TSBWR=XXX, -DREENTRANT_PROTO_I_TSR=XXX, -DREENTRANT_PROTO_I_TsISBWRE=XXX, -DREENTRANT_PROTO_I_UISBWRE=XXX, -DREENTRANT_PROTO_I_iS=XXX, -DREENTRANT_PROTO_I_lS=XXX, -DREENTRANT_PROTO_I_uISBWRE=XXX, -DREENTRANT_PROTO_S_CBI=XXX, -DREENTRANT_PROTO_S_CCSBI=XXX, -DREENTRANT_PROTO_S_CIISBIE=XXX, -DREENTRANT_PROTO_S_CSBI=XXX, -DREENTRANT_PROTO_S_CSBIE=XXX, -DREENTRANT_PROTO_S_CWISBIE=XXX, -DREENTRANT_PROTO_S_CWISBWIE=XXX, -DREENTRANT_PROTO_S_ICSBI=XXX, -DREENTRANT_PROTO_S_ISBI=XXX, -DREENTRANT_PROTO_S_LISBI=XXX, -DREENTRANT_PROTO_S_SBI=XXX, -DREENTRANT_PROTO_S_SBIE=XXX, -DREENTRANT_PROTO_S_SBW=XXX, -DREENTRANT_PROTO_S_TISBI=XXX, -DREENTRANT_PROTO_S_TS=XXX, -DREENTRANT_PROTO_S_TSBI=XXX, -DREENTRANT_PROTO_S_TSBIE=XXX, -DREENTRANT_PROTO_S_TWISBIE=XXX, -DREENTRANT_PROTO_V_D=XXX, -DREENTRANT_PROTO_V_H=XXX, -DREENTRANT_PROTO_V_ID=XXX This symbol is set automatically and may not be set explicitly. -DREG_INFTY=XXX This macro defines a limit on various pattern matching operations to limit stack growth and to avoid "infinite" recursions. It may not be changed. This macro has no function in the benchmark version of the source; its use is forbidden. -DDEFSV_set=XXX, -DSAVE_DEFSV=XXX This macro defines the contents of one of Perl's internal functions. Setting it to a non-default value is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. -DSA_NOCLDWAIT=XXX, -DSA_RESTART=XXX, -DSA_SIGINFO=XXX, -DSIG_PENDING_DIE_COUNT=XXX, -DSCOPE_SAVES_SIGNAL_MASK -DSEARCH_EXTS=XXX This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. This macro contains the constants for use with seek calls. It should be supplied by system header files, but in case it is not, you can specify it using this flag. -DSEEK_CUR=0, -DSEEK_END=1, -DSEEK_SET=2 This macro has no function in the benchmark version of the source; its use is forbidden. -DdSAVEDERRNO=XXX, -DSETERRNO=XXX Setting this macro to a value other than its default is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. -DSFIO_VERSION=XXX This macro has no function in the benchmark version of the source; its use is forbidden. -DSIG_SIZE=XXX Setting this macro to a value other than its default is forbidden. -DSIOCATMARK=XXX This macro has no function in the benchmark version of the source; its use is forbidden. -DSIZE16=XXX, -DSIZE32=XXX Setting this macro to a value other than its default is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. Setting this macro to a value other than its default is forbidden. -DSMALLSORT=XXX This flag sets the size for the stack in the sort routines. This flag should be used to indicate that the "time.h" header file should be included. The benchmark MUST be built with an ANSI C compiler which will define this constant by default. This flag can be used to define the text necessary to begin marking a block of C code as C when building with a C++ compiler. -DSTART_EXTERN_C=XXX This flag can be used to define the text necessary to end marking a block of C code as C when building with a C++ compiler. -DEND_EXTERN_C=XXX This flag can be used to define the text necessary to mark a function prototype as "extern C" when building with a C++ compiler. -DEXTERN_C=XXX Setting this macro to a value other than its default is forbidden. Use this flag if the FILE_cnt macro can be used as an lvalue. Use this flag if the FILE_ptr macro can be used as an lvalue. This symbol is defined if using the FILE_ptr macro as an lvalue leaves File_cnt(fp) unchanged. This symbol is defined if using the FILE_ptr macro as an lvalue to increase the pointer by n causes File_cnt(fp) to be decreased by n. Setting this macro to a value other than its default is forbidden. -DSTMT_END=XXX, -DSTMT_START=XXX Setting this macro to a value other than its default is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. This macro defines the contents of one of Perl's internal functions. Setting it to a non-default value is forbidden. -DSV_CWD_ISDOT=XXX, -DSV_CWD_RETURN_UNDEF=XXX -DHEKf=XXX, -DHEKf256=XXX, -DSVf256=XXX, -DSVf32=XXX, -DSVf=XXX, -DUVf=XXX, -DVDf=XXX This macro defines a format string for a Perl internal data type. Setting it to a non-default value is forbidden. This macro defines a Perl internal data flag. Setting it to a non-default value is forbidden. -DSVf_IVisUV=XXX, -DSVf_precision=XXX -DSYS_NMLN=2048 This flag can be used to set the buffer size for some name length fields on Windows. These fields are probably never used. This constant, if defined, must be defined by a system header file. Setting it explicitly is not allowed. -DS_IEXEC=XXX, -DS_IFBLK=XXX, -DS_IFIFO=XXX, -DS_IFLNK=XXX, -DS_IFMT=XXX, -DS_IFSOCK=XXX, -DS_IREAD=XXX, -DS_IRGRP=XXX, -DS_IROTH=XXX, -DS_IRUSR=XXX, -DS_IRWXG=XXX, -DS_IRWXO=XXX, -DS_IRWXU=XXX, -DS_ISBLK=XXX, -DS_ISCHR=XXX, -DS_ISDIR=XXX, -DS_ISFIFO=XXX, -DS_ISGID=XXX, -DS_ISLNK=XXX, -DS_ISREG=XXX, -DS_ISSOCK=XXX, -DS_ISUID=XXX, -DS_ISVTX=XXX, -DS_IWRITE=XXX, -D_S_IFLNK=XXX, -D_S_IFMT=XXX, -D_S_IFSOCK=XXX, -D_S_ISLNK=XXX, -D_S_ISSOCK=XXX, -DO_ACCMODE=XXX, -DO_APPEND=XXX, -DO_BINARY=XXX, -DO_EXCL=XXX, -DO_LARGEFILE=XXX, -DO_NDELAY=XXX, -DO_NOCTTY=XXX, -DO_NONBLOCK=XXX, -DO_RDONLY=XXX, -DO_WRONLY=XXX, -DO_TEXT=XXX, -DO_TRUNC=XXX, -DSIGARRAYSIZE=XXX, -D_SIG_MAX=XXX, -DSIGABRT=XXX, -DSIGALRM=XXX, -DSIGBUS=XXX, -DSIGCHLD=XXX, -DSIGCLD=XXX, -DSIGCONT=XXX, -DSIGDANGER=XXX, -DSIGEMT=XXX, -DSIGFPE=XXX, -DSIGGRANT=XXX, -DSIGHUP=XXX, -DSIGILL=XXX, -DSIGINT=XXX, -DSIGIO=XXX, -DSIGIOT=XXX, -DSIGKILL=XXX, -DSIGLOST=XXX, -DSIGLWP=XXX, -DSIGMAX=XXX, -DSIGMSG=XXX, -DSIGPHONE=XXX, -DSIGPIPE=XXX, -DSIGPOLL=XXX, -DSIGPROF=XXX, -DSIGPWR=XXX, -DSIGQUIT=XXX, -DSIGRETRACT=XXX, -DSIGSAK=XXX, -DSIGSEGV=XXX, -DSIGSOUND=XXX, -DSIGSTOP=XXX, -DSIGSYS=XXX, -DSIGTERM=XXX, -DSIGTRAP=XXX, -DSIGTSTP=XXX, -DSIGTTIN=XXX, -DSIGTTOU=XXX, -DSIGURG=XXX, -DSIGUSR1=XXX, -DSIGUSR2=XXX, -DSIGVTALRM=XXX, -DSIGWAITING=XXX, -DSIGWINCH=XXX, -DSIGWIND=XXX, -DSIGXCPU=XXX, -DSIGXFSZ=XXX, -DSIG_ERR=XXX, -DSIG_IGN=XXX, -DSIG_MAX=XXX -DSemctl=XXX This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. -DTLS_OUT_OF_INDEXES=XXX Setting this macro to a value other than its default is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. If your system has no integral type of exactly 32 bits, this flag MAY help mitigate the problem. (The benchmark will probably still not work, though.) -DINT64_C=XXX, -DUINT64_C=XXX These are macros that define how constants of various types can be constructed. They may not be set to anything other than their default values. -DUNDERBAR=XXX Setting this macro to a value other than its default is forbidden. Setting this macro to a value other than its default is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. This symbol is set automatically and may not be set explicitly. -DUNION_ANY_DEFINITION=XXX This symbol is set automatically and may not be set explicitly. This macro has no function in the benchmark version of the source; its use is forbidden. -DUV=XXX This symbol is set automatically and may not be set explicitly. This symbol holds the number of bytes used by the type specified by Uid_t. -DUid_t_size=XXX It is forbidden to set this macro to a value other than its default. -DVAL_EAGAIN=XXX, -DVAL_O_NONBLOCK=XXX These macros are for use on VMS systems. CPU2017 is not ported to VMS. -DVMS, -DVMSISH_STATUS, -DVMSISH_TIME, -DVMS_SHORTEN_LONG_SYMBOLS, -DVMS_WE_ARE_CASE_SENSITIVE, -DKILL_BY_SIGPRC This macro has no function in the benchmark version of the source; its use is forbidden. It is forbidden to set this macro to a value other than its default. This macro has no function in the benchmark version of the source; its use is forbidden. It is forbidden to set this macro to a value other than its default. -DWNOHANG=1 This macro contains the value of the WNOHANG constant for use with wait calls. It should be supplied by system header files, but in case it is not, you can specify it using this flag. This macro has no function in the benchmark version of the source; its use is forbidden. -DMSG_WAITALL=XXX, -DSIO_GET_INTERFACE_LIST_EX=XXX, -DWSAEAFNOSUPPORT=XXX, -DWSAECANCELLED=XXX, -DWSAECONNABORTED=XXX, -DWSAECONNRESET=XXX Setting this macro to a value other than its default is forbidden. -DR_OK=X, -DW_OK=X, -DX_OK=X, -DF_OK=X This symbol is set automatically and may not be set explicitly. -Dyyparse=XXX, -DYYDEBUG=XXX, -DYYMAXDEPTH=XXX, -DYYMAXLEVEL=XXX, -DYYNULL=XXX, -DYYSTACKSIZE=XXX, -DYYERROR_VERBOSE=XXX, -DYYPRINT=XXX, -DYYSTYPE=XXX, -DYYSTYPE_IS_DECLARED=XXX, -DYYTOKENTYPE=XXX, -DYYTOKEN_TABLE=XXX -DZeroD=XXX This macro defines the contents of one of Perl's internal functions. Setting it to a non-default value is forbidden. Setting this macro to a value other than its default is forbidden. -D_DEBUG, -D_DEBUG_MEM, -D_WRITE_ABORT_MSG This flag enables some debugging output on Windows platforms. Its use is prohibited. Setting this macro to a value other than its default is forbidden. Your compiler SHOULD define this symbol if the intptr_t type is available. If the type is available but the symbol is not set, you may avoid a redefinition error by using this flag. This constant should be supplied by your system header files. They may not be set directly. -D_IOSTRG=XXX This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. -D_NO_OLDNAMES, -D_O_NOINHERIT=XXX, This macro has no function in the benchmark version of the source; its use is forbidden. -D_SC_CLK_TCK=XXX, -D_SC_OPEN_MAX=XXX, -D_SC_PAGESIZE=XXX, -D_SC_PAGE_SIZE=XXX _SC_GETGR_R_SIZE_MAX _SC_GETPW_R_SIZE_MAX _SC_MMAP_PAGE_SIZE This constant should be supplied by your system header files. They may not be set directly. This macro has no function in the benchmark version of the source; its use is forbidden. This flag may be used to indicate that there is a type definition for uintptr_t. This symbol is set automatically and may not be set explicitly. -D_USE_LINKED_LIST, -D_USE_MSVCRT_MEM_ALLOC This constant should be supplied by your system header files. They may not be set directly. -D_WIN32_WINNT=XXX This macro has no function in the benchmark version of the source; its use is forbidden. This macro defines the contents of one of Perl's internal functions. Setting it to a non-default value is forbidden. -Dsv_2pv_nolen=XXX, -Dsv_2pvbyte=XXX, -Dsv_2pvbyte_nolen=XXX, -Dsv_2uv=XXX, -Dsv_catpv_mg=XXX, -Dsv_catpvf_mg=XXX, -Dsv_catpvn_mg=XXX, -Dsv_catpvn_nomg=XXX, -Dsv_catsv_mg=XXX, -Dsv_catsv_nomg=XXX, -Dsv_dup=XXX, -Dsv_flags=XXX, -Dsv_magicext=XXX, -Dsv_pvn=XXX, -Dsv_pvn_force=XXX, -Dsv_pvn_nomg=XXX, -Dsv_setiv_mg=XXX, -Dsv_setnv_mg=XXX, -Dsv_setpv_mg=XXX, -Dsv_setpvf_mg=XXX, -Dsv_setpvn_mg=XXX, -Dsv_setsv_mg=XXX, -Dsv_setsv_nomg=XXX, -Dsv_setuv=XXX, -Dsv_setuv_mg=XXX, -Dsv_usepvn_mg=XXX, -Dsv_uv=XXX, -DSvGETMAGIC=XXX, -DSvIV_nomg=XXX, -DSvPV_force_nomg=XXX, -DSvPV_nolen=XXX, -DSvPVx_nolen_const=XXX, -DSvPV_nomg=XXX, -DSvPV_nomg_nolen=XXX, -DSvPV_renew=XXX, -DSvPVbyte=XXX, -DSvUTF8_on=XXX, -DSvUV=XXX, -DSvUVX=XXX, -DSvUVXx=XXX, -DSvUV_nomg=XXX, -DSvUVx=XXX, -DnewCONSTSUB=XXX, -DnewRV_inc=XXX, -DnewRV_noinc=XXX, -DnewSVpvn=XXX, -DnewSVpvs=XXX, -DnewSVuv=XXX, -Dsv_setpvs=XXX, -Dsv_vcatpvf=XXX, -Dsv_vcatpvf_mg=XXX, -Dsv_vsetpvf=XXX, -Dsv_vsetpvf_mg=XXX, -Dsv_catpvf_mg_nocontext=XXX, -Dsv_catpvs=XXX, -Dsv_setpvf_mg_nocontext=XXX, SPEC_NO_STAT64 may be set for Windows64 systems where there is no _stat64 structure. These flags are set implicitly by the compilation system and may not be set explicitly. -DERRNO_HAS_POSIX_SUPPLEMENT=XXX, -DHAS_C99, -DNETWARE=XXX, -DNeXT=XXX, -DOEMVS=XXX, -DOS2=XXX, -DPLAN9=XXX, -DPOSIX_BC, -DS_SPLINT_S=XXX, -DSTAP_PROBE_ADDR=XXX, -DUTS=XXX, -DWINVER=XXX -D_ALL_SOURCE=XXX, -D_AIX43=XXX, -D_AIX=XXX, -D_ALPHA_=XXX, -D_CRAYMPP=XXX, -D_CRTIMP=XXX, -D_GNU_SOURCE=XXX, -D_IEEE_FP=XXX, -D_MSC_EXTENSIONS=XXX, -D_MSC_VER=XXX, -D_SVID3=XXX, -D_SAFECRT_IMPL=XXX, -D_UNICOS=XXX, -D__ALPHA=XXX, -D__ANDROID__=XXX, -D__ARMCC_VERSION=XXX, -D__BEOS__=XXX, -D__BIG_ENDIAN__=XXX, -D__BORLANDC__=XXX, -D__BORLAND__=XXX, -D__CRTL_VER=XXX, -D__CYGWIN__=XXX, -D__DECC=XXX, -D__DECC_VER=XXX, -D__DGUX=XXX, -D__DYNAMIC__=XXX, -D__EMX__=XXX, -D__FreeBSD__=XXX, -D__FreeBSD_version=XXX, -D__GLIBC_MINOR__=XXX, -D__GLIBC__=XXX, -D__GNUC_MINOR__=XXX, -D__GNUC__=XXX, -D__GNUG__=XXX, -D__GNU_LIBRARY__=XXX, -D__HAIKU__=XXX, -D__IEEE_FP=XXX, -D__INTEL_COMPILER=XXX, -D__LITTLE_ENDIAN__=XXX, -D__Lynx__=XXX, -D__MINGW32_MAJOR_VERSION=XXX, -D__MINGW32__=XXX, -D__MINGW64__=XXX, -D__MINGW_EXTENSION=XXX, -D__MINT__=XXX, -D__NeXT=XXX, -D__NeXT__=XXX, -D__NetBSD__=XXX, -D__OPEN_VM=XXX, -D__OpenBSD__=XXX, -D__PGI=XXX, -D__POSIX_SOURCE=XXX, -D__QNXNTO__=XXX, -D__QNX__=XXX, -D__SCO_VERSION__=XXX, -D__SC__=XXX, -D__STDC__=XXX, -D__STRICT_ANSI__=XXX, -D__SUNPRO_C=XXX, -D__SUNPRO_CC=XXX, -D__SVR4=XXX, -D__SYMBIAN32__=XXX, -D__TURBOC__=XXX, -D__UCLIBC__=XXX, -D__VAX=XXX, -D__VMS=XXX, -D__VMS_VER=XXX, -D__VOS__=XXX, -D__WATCOMC__=XXX, -D_WINSOCKAPI_=XXX, -D__alpha=XXX, -D__attribute__=XXX, -D__attribute__deprecated__=XXX, -D__attribute__format__=XXX, -D__attribute__malloc__=XXX, -D__attribute__nonnull__=XXX, -D__attribute__noreturn__=XXX, -D__attribute__pure__=XXX, -D__attribute__unused__=XXX, -D__attribute__warn_unused_result__=XXX, -D__bsdi__=XXX, -D__clang=XXX, -D__clang__=XXX, -D__cplusplus=XXX, -D__hpux=XXX, -D__hpux__=XXX, -D__i386__=XXX, -D__ia64=XXX, -D__int64=XXX, -D__osf__=XXX, -D__sgi=XXX, -D__sparc64__=XXX, -D__stdc__=XXX, -D__sun=XXX, -D__sun__=XXX, -D__svr4__=XXX, -D__ux_version=XXX, -D_cplusplus=XXX, -Dapollo=XXX, -Datarist=XXX, -Dconvex=XXX, -Dcray=XXX, -Dgould=XXX, -Dhcx=XXX, -Dhp9000s500=XXX, -Di860=XXX, -Dlint=XXX, -Dm88k=XXX, -Dmc300=XXX, -Dmc500=XXX, -Dmc6000=XXX, -Dmc700=XXX, -Dmips=XXX, -Dpyr=XXX, -Dsun=XXX, -Dultrix=XXX, -Duts=XXX, -Dvax11c=XXX, This macro defines the contents of one of Perl's internal functions. Setting it to a non-default value is forbidden. -DpTHX=XXX, -DpTHX_=XXX, -DpTHXo=XXX, -DpTHXx=XXX, -DdAX=XXX, -DdAXMARK=XXX, -DdITEMS=XXX, -DdJMPENV=XXX, -DdNOOP=XXX, -DdTHR=XXX, -DdTHX=XXX, -DdTHXa=XXX, -DdTHXoa=XXX, -DdUNDERBAR=XXX, -DdXSTARG=XXX, -DaTHX=XXX, -DaTHX_=XXX, -DdVAR=XXX Setting this macro to a value other than its default is forbidden. -DXS=XXX, -DXSPROTO=XXX, -DXS_APIVERSION=XXX, -DXS_APIVERSION_BOOTCHECK=XXX, -DXS_EXTERNAL=XXX, -DXS_INTERNAL=XXX, -DXPUSHmortal=XXX, -DXSRETURN_UV=XXX, -DXST_mUV=XXX, -DXS_VERSION=XXX, -DXSprePUSH=XXX, -DXSubPPtmpAAAA=XXX, ... -DXSubPPtmpAAAZ=XXX, This macro is used to hold the name of a Perl internal function. It may not be set explicitly. -Dcall_argv=XXX, -Dcall_method=XXX, -Dcall_pv=XXX, -Dcall_sv=XXX, -Deval_pv=XXX, -Deval_sv=XXX, -Dget_av=XXX, -Dget_cv=XXX, -Dget_cvn_flags=XXX, -Dget_cvs=XXX, -Dget_hv=XXX, -Dget_sv=XXX, -Dgrok_bin=XXX, -Dgrok_hex=XXX, -Dgrok_number=XXX, -Dgrok_numeric_radix=XXX, -Dgrok_oct=XXX, -Dgv_stashpvn=XXX, -DmPUSHi=XXX, -DmPUSHn=XXX, -DmPUSHp=XXX, -DmPUSHs=XXX, -DmPUSHu=XXX, -DmXPUSHi=XXX, -DmXPUSHn=XXX, -DmXPUSHp=XXX, -DmXPUSHs=XXX, -DmXPUSHu=XXX, -DvnewSVpvf=XXX, -DPUSHi=XXX, -DPUSHn=XXX, -DPUSHp=XXX, -DPUSHu=XXX This macro, if defined, may not be defined explicitly. -D__va_copy=XXX, -D_environ=XXX, -Dasctime=XXX, -Dassert=XXX, -Datan2=XXX, -Datof=XXX, -Dbcmp=XXX, -Dcos=XXX, -Dcrypt=XXX, -Dctermid=XXX, -Dctime=XXX, -Ddrand48=XXX, -Dendgrent=XXX, -Dendhostent=XXX, -Dendnetent=XXX, -Dendprotoent=XXX, -Dendpwent=XXX, -Dendservent=XXX, -Derrno=XXX, -Dexp=XXX, -Dff_next=XXX, -Dfputc=XXX, -Dfputs=XXX, -Dfwrite1=XXX, -Dgetcwd_sv=XXX, -Dgetenv=XXX, -DGetEnvironmentStringsA=XXX, -Dgetgrent=XXX, -Dgetgrgid=XXX, -Dgetgrnam=XXX, -Dgethostbyaddr=XXX, -Dgethostbyname=XXX, -Dgethostent=XXX, -Dgetlogin=XXX, -Dgetnetbyaddr=XXX, -Dgetnetbyname=XXX, -Dgetnetent=XXX, -Dgetprotobyname=XXX, -Dgetprotobynumber=XXX, -Dgetprotoent=XXX, -Dgetpwent=XXX, -Dgetpwnam=XXX, -Dgetpwuid=XXX, -Dgetservbyname=XXX, -Dgetservbyport=XXX, -Dgetservent=XXX, -Dgetspnam=XXX, -Dghs=XXX, -Dgmtime=XXX, -Dh_addr=XXX, -Dh_errno=XXX, -Dhtonl=XXX, -Dhtons=XXX, -Dhtovl=XXX, -Dhtovs=XXX, -DisXDIGIT=XXX, -Disascii=XXX, -Djmp_buf=XXX, -Dlocaltime=XXX, -Dlog=XXX, -Dmajor=XXX, -DmemEQ=XXX, -DmemEQs=XXX, -DmemNE=XXX, -DmemNEs=XXX, -Dmemchr=XXX, -Dmemcmp=XXX, -Dmemcpy=XXX, -Dmemmove=XXX, -Dmemset=XXX, -Dmemzero=XXX, -Dmy_betohn=XXX, -Dmy_chsize=XXX, -Dmy_getpwent=XXX, -Dmy_htoben=XXX, -Dmy_htolen=XXX, -Dmy_letohn=XXX, -Dntohl=XXX, -Dntohs=XXX, -Dpoll=XXX, -Dpow=XXX, -Drandom=XXX, -Dreaddir=XXX, -Dreaddir64=XXX, -Dregister=XXX, -Drewinddir=XXX, -Dseekdir=XXX, -Dsetgrent=XXX, -Dsethostent=XXX, -Dsetlocale=XXX, -Dsetnetent=XXX, -Dsetprotoent=XXX, -Dsetpwent=XXX, -Dsetservent=XXX, -Dsin=XXX, -Dsqrt=XXX, -Dsrand48=XXX, -Dsrandom=XXX, -Dstrchr=XXX, -Dstrerror=XXX, -Dtelldir=XXX, -Dtmpnam=XXX, -Dttyname=XXX, -Dva_copy=XXX, -Dvtohl=XXX, -Dvtohs=XXX, -DisALNUMC=XXX, -DisASCII=XXX, -DisBLANK=XXX, -DisCNTRL=XXX, -DisGRAPH=XXX, -DisGV_with_GP=XXX, -DisPRINT=XXX, -DisPSXSPC=XXX, -DisPUNCT=XXX, -DisWORDCHAR=XXX, -Dis_LAX_VERSION=XXX, -Dis_STRICT_VERSION=XXX, -Dis_utf8_string=XXX, -Disnan=XXX This symbol is set automatically and may not be set explicitly. -DIV_MAX=XXX, -DIV_MIN=XXX, -DNV_INF=XXX, -DNV_MAX_10_EXP=XXX, -DNV_NAN=XXX, -DUV_MAX=XXX, -DUV_MIN=XXX -DStat_t=XXX This macro contains the type that should be used when a 'struct stat' would be called for. -DUid_t=uid_t, -DTime_t=time_t, -DSize_t=size_t, -DMode_t=mode_t This flag can be used to define what type should be used in place of the standard $1 (this should be in lower case). uid_t (or time_t, size_t, or mode_t) -DSighandler_t=XXX It is forbidden to set this macro to a value other than its default. This macro holds the return type of a signal handler. -DSignal_t=XXX This macro holds the return type of malloc() and the type of the argument to free(). -DMalloc_t=XXX This flag either has no function in the benchmark version of the source, or must not be changed from its default value. -DUSE_5005THREADS, -DUSE_56_INTERWORK_KLUDGE, -DUSE_64_BIT_ALL, -DUSE_64_BIT_RAWIO, -DUSE_ATTRIBUTES_FOR_PERLIO, -DUSE_BIGBLOCK_ALLOC, -DUSE_BROKEN_PAD_RESET, -DUSE_BSDPGRP, -DUSE_BSD_GETPGRP, -DUSE_BSD_SETPGRP, -DUSE_CHAR_VSPRINTF, -DUSE_CROSS_COMPILE, -DUSE_DECLSPEC_THREAD, -DUSE_ENVIRON_ARRAY, -DUSE_FIXED_OSFHANDLE, -DUSE_GETHOSTENT_ERRNO, -DUSE_GETNETENT_ERRNO, -DUSE_GRENT_FPTR, -DUSE_GRENT_PTR, -DUSE_HASH_SEED, -DUSE_HASH_SEED_EXPLICIT, -DUSE_HOSTENT_ERRNO, -DUSE_HOSTENT_PTR, -DUSE_ITHREADS, -DUSE_LOCKF64, -DUSEHEAPINSTEADOFSTACK, -DUSEIMPORTLIB, -DUSEMYBINMODE, -DUSE_NETENT_ERRNO, -DUSE_NETENT_PTR, -DUSE_NEXT_CTYPE, -DUSE_PERLIO, -DUSE_PERL_ATOF, -DUSE_PERL_SBRK, -DUSE_PFUNC, -DUSE_PROTOENT_ERRNO, -DUSE_PROTOENT_PTR, -DUSE_PURE_BISON, -DUSE_PWENT_FPTR, -DUSE_PWENT_PTR, -DPERL_REENTR_API=XXX, -DUSE_REENTRANT, -DUSE_REENTRANT_API, -DUSE_RTL_POPEN, -DUSE_RTL_SPAWNVP, -DUSE_RTL_THREAD_API, -DUSE_SEMCTL_SEMID_DS, -DUSE_SEMCTL_SEMUN, -DUSE_SERVENT_ERRNO, -DUSE_SERVENT_PTR, -DUSE_SFIO, -DUSE_SPENT_FPTR, -DUSE_SPENT_PTR, -DUSE_STAT_BLOCKS, -DUSE_STDIO, -DUSE_THREADS, -DUSE_UTF8_SCRIPTS This indicates that the invocation of main() on the target system does not include a pointer to the environment array. The benchmark does not use large files or highly precise floating point numbers, but you may use these flags to try it out anyway. -DUSE_64_BIT_STDIO, -DUSE_FCNTL64, -DUSE_FGETPOS64, -DUSE_FLOCK64, -DUSE_FOPEN64, -DUSE_FREOPEN64, -DUSE_FSEEK64, -DUSE_FSETPOS64, -DUSE_FSTAT64, -DUSE_FTELL64, -DUSE_FTRUNCATE64, -DUSE_LARGE_FILES, -DUSE_LLSEEK, -DUSE_LSEEK64, -DUSE_LSTAT64, -DUSE_OPEN64, -DUSE_STAT64, -DUSE_TMPFILE64, -DUSE_TRUNCATE64, -DUSE_MORE_BITS, -DUSE_LONG_DOUBLE Using a locale other than "C" will most likely cause the benchmark to miscompare, but you're still welcome to try. -DUSE_LOCALE, -DUSE_LOCALE_COLLATE, -DUSE_LOCALE_CTYPE, -DUSE_LOCALE_NUMERIC If your compiler requires 64-bit integer constants to be noted with an "LL" suffix instead of "i64", use this flag. If your compiler does not define _MSC_VER on Windows, you can use this flag to get typedefs for the POSIX ID types uid_t, gid_t, and mode_t. This flag enables experimental optimizations in the Perl regular expression parser and may not be set manually. This macro defines the number of bits in a byte on the target system. This macro is used internally by code in Time::HiRes. It is not used in the benchmark and may not be set manually. This macro is used internally by code in Time::HiRes. It is not used in the benchmark and may not be set manually. This macro is used internally by code in Time::HiRes. It is not used in the benchmark and may not be set manually. This macro is used internally by code in Time::HiRes. It is not used in the benchmark and may not be set manually. This macro is used internally by code in Time::HiRes. It is not used in the benchmark and may not be set manually. This macro is used internally by code in Time::HiRes. It is not used in the benchmark and may not be set manually. This macro is used internally by code in Time::HiRes. It is not used in the benchmark and may not be set manually. This macro is used internally by code in Time::HiRes. It is not used in the benchmark and may not be set manually. This macro defines a concatenation that can be used to create a 64-bit constant. This macro is used internally by Data::Dumper and may not be set explicitly. Enable debugging output from the regexp parser. Use of this flag is forbidden for reportable runs. -DDEBUG_LEAKING_SCALARS_FORK_DUMP, -DDEBUG_LEAKING_SCALARS_ABORT Enables debugging output for SVs that are potentially being leaked. Use of this flag is forbidden for reportable runs. This flag enables an experimental optimization in the Perl regular expression parser and may not be set. This macro enables a workaround that allows -e to work when /dev/null is not present. It is not used in the benchmark and may not be set explicitly. This macro enables experimental regular expression engine optimization relating to allowing study for fixed-length positive lookahead and lookbehind, and may not be used for reportable runs. This macro enables some experimental regular expression engine optimizations, and may not be used for reportable runs. This macro enables some experimental regular expression engine optimizations, and may not be used for reportable runs. This macro enables some experimental regular expression engine optimizations, and may not be used for reportable runs. This macro enables some experimental regular expression engine optimizations, and may not be used for reportable runs. This macro disables a regular expression engine optimization, and may not be used for reportable runs. -DHASATTRIBUTE_FORMAT, -DHASATTRIBUTE_MALLOC, -DHASATTRIBUTE_NONNULL, -DHASATTRIBUTE_NORETURN, -DHASATTRIBUTE_PURE, -DHASATTRIBUTE_UNUSED, -DHASATTRIBUTE_WARN_UNUSED_RESULT These macros indicate the presence of attribute flags that the compiler supports. They may not be set for a reportable run. This macro sets the text to be inserted into functions from which no return is possible. It may not be set on the compilation command line. This flag indicates that the benchmark is being built on a system that has long double support and has a powl() function that wrongly returns NaNQ for any negative base. This macro has no function and may not be set for reportable runs. This macro indicates the presence of the _builtin_expect compiler intrinsic and may not be set for reportable runs. This macro indicates that the compiler supports C99-style variadic macros. This macro indicates that a clearenv() function is available to clear out all environment variables. This macro indicates that a dirfd() function is available for getting the file descriptor of an open directory handle. This macro indicates that a direct access to the dd_fd member of a directory structure can be used to get the file descriptor of an open directory handle. This macro indicates that the drand48() function returns a quad value. 600.perlbench_s supplies its own PRNG, and this macro may not be set for reportable runs. This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. -DI_MALLOCMALLOC, -DHAS_MALLOC_SIZE, -DHAS_MALLOC_GOOD_SIZE, -DPerl_safesysmalloc_size=XXX This macro has no function in the benchmark version of the source; its use is forbidden. This macro indicates the presence of an snprintf() function. This macro indicates the presence of an unsetenv() function. This macro indicates the presence of a vsnprintf() function. This macro indicates that HWND_MESSAGE windows are available. It has no effect on non-Win32 platforms. -DHvEITER_get=XXX, -DHvEITER_set=XXX, -DHvNAME_get=XXX, -DHvNAME_set=XXX, -DHvRITER_get=XXX, -DHvRITER_set=XXX These macros are set and used internally by Perl and may not be set explicitliy. This macro indicates the presence of a compiler attribute that indicates that printf() can take a null argument. This macro may not be set for reporable runs. This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. These macros define a representation for infinity in whatever type NV is on the target system. They should be set by the compilation environment, but may be set explicitly. This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. These macros have no function in the benchmark version of the source; their use is forbidden. -DMAX_SIG=NNN, -DMAXSIG=NNN, -DNSIG=NNN, -D_NSIG=NNN, -D_sys_nsig=NNN These macros have no function in the benchmark version of the source; their use is forbidden. This macro is used internally by Perl. Setting it explicitly is not allowed. -DPERL_MEM_LOG, -DPERL_MEM_LOG_ENV, -DPERL_MEM_LOG_ENV_FD=XXX, -DPERL_MEM_LOG_FD=XXX, -DPERL_MEM_LOG_NOIMPL, -DPERL_MEM_LOG_STDERR, -DPERL_MEM_LOG_TIMESTAMP, -DMEM_LOG_ALLOC=XXX, -DMEM_LOG_FREE=XXX, -DMEM_LOG_REALLOC=XXX These flags enable and specify behavior of debug logging of Perl's memory allocation activities. They may not be set for a reportable run. This macro indicates that direct comparison of NaN values doesn't return correct answers. -DARGSproto=XXX, -DNEED_PL_parser, -DNEED_PL_parser_GLOBAL, -DNEED_PL_signals, -DNEED_PL_signals_GLOBAL, -DNEED_load_module, -DNEED_load_module_GLOBAL, -DNEED_my_snprintf, -DNEED_my_snprintf_GLOBAL, -DNEED_my_sprintf, -DNEED_my_sprintf_GLOBAL, -DNEED_my_strlcat, -DNEED_my_strlcat_GLOBAL, -DNEED_my_strlcpy, -DNEED_my_strlcpy_GLOBAL, -DNEED_newSV_type, -DNEED_newSV_type_GLOBAL, -DNEED_newSVpvn_flags, -DNEED_newSVpvn_flags_GLOBAL, -DNEED_newSVpvn_share, -DNEED_newSVpvn_share_GLOBAL, -DNEED_pv_display, -DNEED_pv_display_GLOBAL, -DNEED_pv_escape, -DNEED_pv_escape_GLOBAL, -DNEED_pv_pretty, -DNEED_pv_pretty_GLOBAL, -DNEED_sv_2pv_flags, -DNEED_sv_2pv_flags_GLOBAL, -DNEED_sv_pvn_force_flags, -DNEED_sv_pvn_force_flags_GLOBAL, -DNEED_vload_module, -DNEED_vload_module_GLOBAL, -DNEED_warner, -DNEED_warner_GLOBAL, -DPPP_PL_parser_NO_DUMMY, -DPPP_PL_parser_NO_DUMMY_WARNING, -Dload_module, -Dmy_snprintf, -Dmy_sprintf, -Dmy_strlcat, -Dmy_strlcpy, -DnewSVpvn_flags, -DnewSVpvn_share, -DnewSVpvn_utf8, -DnewSVpvs_flags, -DnewSVpvs_share, -DnewXS_flags, -Dpv_display=XXX, -Dpv_escape=XXX, -Dpv_pretty=XXX, -Dsv_2pv_flags, -Dsv_pvn_force_flags, -Dvload_module, -Dvwarner, -Dwarner These macros have no function in the benchmark version of the source; their use is forbidden. -DNO_SHA_384_512, -DSHA32_MAX, -DSHA32_SCHED, -DSHA64, -DSHA64_SCHED, -DSHA_384_512, -DSHA_PERL_MODULE, -DSHA_STO_CLASS, -DSHA_THREAD_SAFE, -DSHA_ULL_EXISTS These macros have no function in the benchmark version of the source; their use is forbidden. This macro indicates that the in-memory representation of 0 for whatever type is the native NV type is 0 in memory. -DNewx=XXX, -DNewxc=XXX, -DNewxz=XXX These macros are used internally by Perl. Setting them explicitly is not allowed. -DPERL_STATIC_INLINE="static inline" -DHAS_STATIC_INLINE, The PERL_STATIC_INLINE symbol may be defined to the text to use to mark a function as inlinable but with only static linkage. Its default value depends on whether the HAS_STATIC_INLINE symbol is defined; if it is defined, the default value for PERL_STATIC_INLINE is the C99-style "static inline". Otherwise it's just "static".

If PERL_STATIC_INLINE is defined, the definition (or not) of HAS_STATIC_INLINE is ignored.

]]> -DSTATIC=static, -DPERL_STATIC_NO_RET=STATIC, -DPERL_STATIC_INLINE_NO_RET=PERL_STATIC_INLINE, This macro cannot be set to a value other than its default of "static". These macros, which are normally set by the compilation environment, can be used to request certain levels of X/Open support from the system header files. -D_XOPEN_SOURCE=XXX, -D_XOPEN_SOURCE_EXTENDED=XXX -DWARN_ALL=NNN, -DWARN_AMBIGUOUS=NNN, -DWARN_ASSERTIONS=NNN, -DWARN_BAREWORD=NNN, -DWARN_CLOSED=NNN, -DWARN_CLOSURE=NNN, -DWARN_DEBUGGING=NNN, -DWARN_DEPRECATED=NNN, -DWARN_DIGIT=NNN, -DWARN_EXEC=NNN, -DWARN_EXITING=NNN, -DWARN_GLOB=NNN, -DWARN_INPLACE=NNN, -DWARN_INTERNAL=NNN, -DWARN_IO=NNN, -DWARN_LAYER=NNN, -DWARN_MALLOC=NNN, -DWARN_MISC=NNN, -DWARN_NEWLINE=NNN, -DWARN_NUMERIC=NNN, -DWARN_ONCE=NNN, -DWARN_OVERFLOW=NNN, -DWARN_PACK=NNN, -DWARN_PARENTHESIS=NNN, -DWARN_PIPE=NNN, -DWARN_PORTABLE=NNN, -DWARN_PRECEDENCE=NNN, -DWARN_PRINTF=NNN, -DWARN_PROTOTYPE=NNN, -DWARN_QW=NNN, -DWARN_RECURSION=NNN, -DWARN_REDEFINE=NNN, -DWARN_REGEXP=NNN, -DWARN_RESERVED=NNN, -DWARN_SEMICOLON=NNN, -DWARN_SEVERE=NNN, -DWARN_SIGNAL=NNN, -DWARN_SUBSTR=NNN, -DWARN_SYNTAX=NNN, -DWARN_TAINT=NNN, -DWARN_THREADS=NNN, -DWARN_UNINITIALIZED=NNN, -DWARN_UNOPENED=NNN, -DWARN_UNPACK=NNN, -DWARN_UNTIE=NNN, -DWARN_UTF8=NNN, -DWARN_VOID=NNN These macros are used to define the internal values for some Perl flags, and may not be set explicitly. -DTIMER_ABSTIME=XXX, -DTIME_HIRES_CLOCK=XXX, -DTIME_HIRES_CLOCK_GETRES=XXX, -DTIME_HIRES_CLOCK_GETRES_SYSCALL=XXX, -DTIME_HIRES_CLOCK_GETTIME=XXX, -DTIME_HIRES_CLOCK_GETTIME_SYSCALL=XXX, -DTIME_HIRES_CLOCK_NANOSLEEP=XXX, -DTIME_HIRES_STAT=XXX, -D_STRUCT_ITIMERSPEC=XXX These macros have no function in the benchmark version of the source; their use is forbidden. Defining this macro causes the binary compatibility stubs to be omitted from compilation. It may not be used for a reportable run. This macro controls whether or not the Data::Dumper extension will attempt to include ppport.h. It may not be set for a reportable run. This macro controls how PerlIO functions are declared. It may not be set for a reportable run. This macro controls whether or not functions in the PerlIO layer are declared const. It may not be set for a reportable run. Setting this macro will cause the PERLIO_STD_IN and PERLIO_STD_OUT macros to be used for file descriptors 0, 1, and 2 respectively. These are not defined by default and may not be defined, so setting this macro will only have the effect of breaking the compilation. This macro defines a function or expansion to return the absolute value of its argument. It is set by default and may not be changed for a reportable run. This macro encodes the version of Perl in BCD. Changing its value is not allowed for reportable runs. This macro controls whether assertions are enabled for copy-on-write optimizations for scalars in the core Perl code. It may not be set for reportable runs. This macro controls debugging checks and output for read-only conversions in the slab allocator. It may not be set for reportable runs. Setting this macro will cause Perl to allocate a new SV when a GvSV is created. This may not be used in a reportable run. This is the default setting for Perl and so doesn't need to be set explicitly. This macro controls whether do_exec3() is used for do_exec() internally. It is the default on most systems and may not be unset for reportable runs. -DPERL_EXPORT_C=export, -DPERL_XS_EXPORT_C=export This macro controls what text is prepended to C functions which must use C-style calling conventions. It may not be changed for a reportable run. -DPERL_GET_VARS=XXX, -DPERL_SET_VARS=XXX, -DPERL_UNSET_VARS=XXX These macros set the names of functions used to get, set, and unset internal Perl variables. They are set internally and may not be changed. -DPERL_LOADMOD_DENY=0x1, -DPERL_LOADMOD_IMPORT_OPS=0x2, -DPERL_LOADMOD_NOIMPORT=0x4 Setting these macros to a value other than default is forbidden. -Dhv_fetch=XXX, -Dhv_fetchs=XXX, -Dhv_store=XXX, -Dhv_stores=XXX This macro defines the contents of one of Perl's internal functions. Setting it to a non-default value is forbidden. -Dgv_fetchpvn_flags=XXX, -Dgv_fetchpvs=XXX, -Dgv_fetchsv=XXX, -Dgv_stashpvs=XXX This macro defines the contents of one of Perl's internal functions. Setting it to a non-default value is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. This macro has no function in the benchmark version of the source; its use is forbidden. Setting this macro enables the internal copy-on-write semantics that existed before copy-on-write shared hash keys were implemented. It may not be set for a reportable run. This is the default, and setting it wouldn't change that. This macro enables some memory-allocation checking. It may not be set for a reportable run. Setting this macro to a value other than its default is forbidden. If re-entrant functions have a maximum buffer size, this macro can be used to constrain the buffers that Perl uses to that size. It has no function in the benchmark version of the source and may not be set for reportable runs. This macro has no function in the benchmark and may not be set for reportable runs. Setting this macro to a value other than its default is forbidden. Round all values passed to malloc up to a multiple of the value of this macro. The default value is sizeof(size_t) and this may not be changed for reportable runs. -DPERL_SYS_INIT3_BODY=XXX, -DPERL_SYS_INIT_BODY=XXX, -DPERL_SYS_TERM_BODY=XXX These macros contain the functions used for startup and shutdown of the Perl interpreter. They may not be changed from their default values. This macro enables internal debugging information for memory allocations. It may not be set for reportable runs. This macro contains in-line text used to inform the compiler that a particular argument is unused. It may not be set to other than its default value for reportable runs. This macro has no function in the benchmark source, and may not be explicitly set for reportable runs. This macro contains in-line text used to inform the compiler that a particular variable is unused. It may not be set to other than its default value for reportable runs. This macro contains text used to quiet compiler warnings about a particular variable not being used in a function. It may not be set to other than its default value for reportable runs. This macro controls whether or not Perl keeps track of child processes with using a hash keyed to raw PID values. It has no effect in the benchmark code and may not be set for a reportable run. This macro causes Perl to assume that malloc() can not efficiently handle allocations that are sized as an even power of two. It may not be set for a reportable run. This macro indicates that pluggable regular expression extensions are to be accomodated. Defining it will cause the benchmark build to break. These parameterized macros define the method to cast a pointer type to various other Perl internal and natural types. This macro is the function used to push a mortal SV onto the stack. Its default value may not be changed. This macro enables extra debug state storage and output in the regular expression engine. It may not be used for reportable runs. On Windows, when _DEBUG is also set, enables warnings about invalid parameters to certain functions. It is set automatically and may not be set explictly. This macro can be used to set the size of buffers for reentrant functions on OSF1/Alpha. Since this benchmark has not been ported to OSF/1, it is unlikely to have any effect. These lock constants should be supplied by your system header files. They may not be set directly. -DF_DUPFD=XXX, -DF_FREESP=XXX, -DF_LOCK=XXX, -DF_TLOCK=XXX, -DF_ULOCK=XXX, -DF_SETFD=XXX, -DF_TEST=XXX This macro indicates the presence of a mkdir() system call or library function. In cases where this is automatically defined, it can be disabled by also defining SPEC_NO_HAS_MKDIR. This macro prevents HAS_MKDIR from being defined. Definition of this macro indicates that sprintf() follows the ANSI C standard and returns the length of the string. This is the default, but may be disabled by setting SPEC_NO_SPRINTF_RETURNS_STRLEN. This macro prevents SPRINTF_RETURNS_STRLEN from being defined. These macros define properties and functions for use with Perl's internal scalar representation. They may not be changed from the default. -DSV_CHECK_THINKFIRST=XXX, -DSV_CONST_RETURN=XXX, -DSV_COWBUF_THRESHOLD=XXX, -DSV_COWBUF_WASTE_FACTOR_THRESHOLD=XXX, -DSV_COWBUF_WASTE_THRESHOLD=XXX, -DSV_COW_MAX_WASTE_FACTOR_THRESHOLD=XXX, -DSV_COW_MAX_WASTE_THRESHOLD=XXX, -DSV_COW_THRESHOLD=XXX, -DSV_COW_DROP_PV=XXX, -DSV_COW_SHARED_HASH_KEYS=XXX, -DSV_DO_COW_SVSETSV=XXX, -DSV_GMAGIC=XXX, -DSV_HAS_TRAILING_NUL=XXX, -DSV_IMMEDIATE_UNREF=XXX, -DSV_MUTABLE_RETURN=XXX, -DSV_NOSTEAL=XXX, -DSV_SMAGIC=XXX, -DSV_UTF8_NO_ENCODING=XXX, -DSVf_IsCOW=XXX, -DSVf_UTF8=XXX, -DSVf_=XXX, -DSvIOK_UV=XXX, -DSvIsCOW=XXX, -DSvMAGIC_set=XXX, -DSvPVX_const=XXX, -DSvPVX_mutable=XXX, -DSvPV_const=XXX, -DSvPV_flags=XXX, -DSvPV_flags_const=XXX, -DSvPV_flags_const_nolen=XXX, -DSvPV_flags_mutable=XXX, -DSvPV_force=XXX, -DSvPV_force_flags=XXX, -DSvPV_force_flags_mutable=XXX, -DSvPV_force_flags_nolen=XXX, -DSvPV_force_mutable=XXX, -DSvPV_force_nolen=XXX, -DSvPV_force_nomg_nolen=XXX, -DSvPV_mutable=XXX, -DSvPV_nolen_const=XXX, -DSvPV_nomg_const=XXX, -DSvPV_nomg_const_nolen=XXX, -DSvREFCNT_inc=XXX, -DSvREFCNT_inc_NN=XXX, -DSvREFCNT_inc_simple=XXX, -DSvREFCNT_inc_simple_NN=XXX, -DSvREFCNT_inc_simple_void=XXX, -DSvREFCNT_inc_simple_void_NN=XXX, -DSvREFCNT_inc_void=XXX, -DSvREFCNT_inc_void_NN=XXX, -DSvRV_set=XXX, -DSvSHARED_HASH=XXX, -DSvSTASH_set=XXX, -DSvUOK=XXX, -DSvUTF8=XXX, -DSvUV_set=XXX, -DSvVOK=XXX, -DSvVSTRING_mg=XXX, -DSvWEAKREF=XXX -DSTR_WITH_LEN=XXX This macro defines the contents of one of Perl's internal functions. Setting it to a non-default value is forbidden. This macro is used and set internally by Perl and may not be set explicitly. This macro causes Perl to use variables allocated on the heap instead of the stack in some limited cases. It may not be used for a reportable run. This macro has no function in the benchmark version of the source and may not be set for reportable runs. This macro causes USE_PTR_TABLE to be defined in the Storable extension. It may not be used for a reportable run. This macro causes the Storable extension to use Perl's low-level ptr_table functions directly instead of the higher-level HV functions. It may not be used for a reportable run. -DWCOREDUMP(x)=((x)&0200) This macro contains the value of the WCOREDUMP test for use with wait return values. It should be supplied by system header files, but in case it is not, you can specify it using this flag. -DWIFEXITED(x)=(((x)&0177)==0) This macro contains the value of the WIFEXITED test for use with wait return values. It should be supplied by system header files, but in case it is not, you can specify it using this flag. This macro has no function in the benchmark version of the source, and may not be set for a reportable run. This macro can not be overridden for all source files, so attempting to set it to a non-default value is not allowed in a reportable run. -D_IOC_SIZE=256 This macro contains the value of the maximum size of an ioctl() argument. It should be supplied by system header files, but in case it is not, you can specify it using this flag. This macro has no function in the benchmark version of the source; its use is forbidden. -DIPV6_ADD_MEMBERSHIP=XXX, -DIPV6_DROP_MEMBERSHIP=XXX, -DIPV6_HDRINCL=XXX, -DIPV6_HOPLIMIT=XXX, -DIPV6_JOIN_GROUP=XXX, -DIPV6_LEAVE_GROUP=XXX, -DIPV6_MULTICAST_HOPS=XXX, -DIPV6_MULTICAST_IF=XXX, -DIPV6_MULTICAST_LOOP=XXX, -DIPV6_PKTINFO=XXX, -DIPV6_PROTECTION_LEVEL=XXX, -DIPV6_UNICAST_HOPS=XXX These IPv6 constants are not used in the benchmark and may not be set explicitly. -DNI_DGRAM=XXX, -DNI_NAMEREQD=XXX, -DNI_NOFQDN=XXX, -DNI_NUMERICHOST=XXX, -DNI_NUMERICSERV=XXX These constants are not used in the benchmark and may not be set explicitly. -DPERL_PV_ESCAPE_ALL=XXX, -DPERL_PV_ESCAPE_FIRSTCHAR=XXX, -DPERL_PV_ESCAPE_NOBACKSLASH=XXX, -DPERL_PV_ESCAPE_NOCLEAR=XXX, -DPERL_PV_ESCAPE_QUOTE=XXX, -DPERL_PV_ESCAPE_RE=XXX, -DPERL_PV_ESCAPE_UNI=XXX, -DPERL_PV_ESCAPE_UNI_DETECT=XXX, -DPERL_PV_PRETTY_DUMP=XXX, -DPERL_PV_PRETTY_ELLIPSES=XXX, -DPERL_PV_PRETTY_LTGT=XXX, -DPERL_PV_PRETTY_NOCLEAR=XXX, -DPERL_PV_PRETTY_QUOTE=XXX, -DPERL_PV_PRETTY_REGPROP=XXX, These macros are used and set internally by Perl and may not be set explicitly. -DPMf_BASE_SHIFT=XXX, -DPMf_CHARSET=XXX, -DPMf_EXTENDED=XXX, -DPMf_FOLD=XXX, -DPMf_KEEPCOPY=XXX, -DPMf_MULTILINE=XXX, -DPMf_SINGLELINE=XXX, -DPMf_SPLIT=XXX, -DRXf_BASE_SHIFT=XXX, -DRXf_PMf_CHARSET=XXX, -DRXf_PMf_COMPILETIME=XXX, -DRXf_PMf_EXTENDED=XXX, -DRXf_PMf_FOLD=XXX, -DRXf_PMf_KEEPCOPY=XXX, -DRXf_PMf_MULTILINE=XXX, -D_RXf_PMf_SHIFT_COMPILETIME=XXX, -DRXf_PMf_SINGLELINE=XXX, -DRXf_PMf_SPLIT=XXX, -DRXf_PMf_STD_PMMOD_SHIFT=XXX, -DRXf_SPLIT=XXX These macros define values used internally by the regular expression engine, and may not be changed. These macros define the contents of some of Perl's internal constants. Setting any of them to a non-default value is forbidden. -D_HIGHEST_REGCOMP_DOT_H_SYNC=XXX, -D_CC_ALPHANUMERIC=XXX, -D_CC_ASCII=XXX, -D_CC_BLANK=XXX, -D_CC_CASED=XXX, -D_CC_CNTRL=XXX, -D_CC_GRAPH=XXX, -D_CC_PRINT=XXX, -D_CC_PSXSPC=XXX, -D_CC_PUNCT=XXX, -D_CC_SPACE=XXX, -D_CC_UPPER=XXX, -D_CC_VERTSPACE=XXX, -D_CC_WORDCHAR=XXX, -D_CC_XDIGIT=XXX, -DANYOF_INVERT=XXX, -DANYOF_POSIXL_MAX=XXX -DNO_TAINT_SUPPORT, -DSILENT_NO_TAINT_SUPPORT These macros disable security-related tainting operations. Perls built without taint support are not supported, and these macros may not be used for reportable runs. This macro defines a Perl-internal function and may not be explicitly set. -DGvNAMEUTF8=XXX, -DGvSVn=XXX This macro defines the type used for bitfields in Perl internal structures. It may not be changed from the default. -DPERL_BITFIELD16=XXX, -DPERL_BITFIELD32=XXX, -DPERL_BITFIELD8=XXX When defined, this macro will cause the benchmark binary to be built with DTrace or SystemTap probes enabled. It may not be used for a reportable run. -DNATIVE_IS_INVARIANT=XXX, -DU8TO16_LE=XXX, -DUNICODE=XXX -DUTF8_QUAD_MAX=XXX, -DUTF8f=XXX, -DUVCHR_IS_INVARIANT=XXX, -Dutf8_to_uvchr=XXX, -Dutf8_to_uvchr_buf=XXX, These macros define internal functions and values having to do with Perl's internal Unicode support. They may not be changed from their default values for a reportable run. -DPERL_SUB_DEPTH_WARN=10 This macro defines the maximum recursion level allowable. The default value of 100 may not be changed for a reportable run. -DPERL_PERTURB_KEYS_DETERMINISTIC, -DPERL_PERTURB_KEYS_DISABLED, -DPERL_PERTURB_KEYS_RANDOM, -DUSE_PERL_PERTURB_KEYS These macros affect whether and how hash key traversal randomization happens. They have no effect in the benchmark sources and may not be set for a reportable run. Defining this macro will cause the benchmark's version output to be slightly altered, which will cause validation to fail. It may not be set for a reportable run. This macro generally (but not always) will cause a native-code extension to mark functions that might have been internal-only as external. It has no function in the benchmark and may not be set for a reportable run. This macro is defined during the Perl build process to build the "mini" version of Perl used to process XS into C and generate other files used later in the build process. Setting it will cause the benchmark to fail to build. -DPERL_SAWAMPERSAND, -DPL_sawampersand=0 These macros control whether or not Perl supports the $`, $&, and $' special variables. They are set automatically and may not be changed for a reportable run.

]]> Various versions of Microsoft Visual C++ have featured an ioinfo struct definition that differs from previous and future versions. This macro controls whether or not the known definition in VC2008-2012 is used or not. It is set automatically, but if needed may be set manually. This macro is set when it is detected that Microsoft Visual C++ 6 is in use. That version has special needs that require workarounds in various places in the code. It is set automatically and may not be explicitly set. -DST_INO_SIZE=4, -DST_INO_SIGN=-1 These macros determine what sort of internal Perl type the value of stat.st_ino is stored in. They are not used in the benchmark, and may not be set explicitly for reportable runs. This macro indicates that the architecture supports unaligned word accesses. It is used only in some of the hash functions that are not used with the benchmark, and so it has no effect. It may not be set explicitly. This is a Perl internal macro with a set value that cannot be changed. This macro, if set, is set automatically by the compilation system to the maximum number of bytes needed to represent the maximum Unicode code point. Since the benchmark does not make use of the Unicode support, this macro has no function and thus may not be set explicitly. This parameterized macro defines a way to cast a pointer such that the compiler will still warn if the const-ness of a variable is being discarded. It is not possible to change its value without modifying the source code. The value of this macro defines the maximum size of a slab in the optree. Its value may not be changed from the default. These macros define tests for various compiler built-in features. They are not used in the benchmark source and may not be set explicitly. Setting this macro will cause Perl's internal tm struct to have space for a 64-bit year. It is set by default and may not be un-set. This macro is not used in the benchmark sources and may not be set. This macro defines the steps necessary to change the current interpreter phase. It may not be set to a value other than its default. The value of this macro determines how much sv_grow() will increase the length of a string that has run out of space. The default value is 2 (25% of the used length) and may not be changed for a reportable run. This macro is not used in the benchmark sources and may not be set. This macro is not used in the benchmark sources and may not be set. This macro is used internally by the "version" module, and it may not be set explicitly.