557.xz_r Flags

This macro should be set on systems which have "big endian" (most significant byte first) byte order, if the byte order is not correctly automatically supplied by the tools.

This macro may be defined when the compilation environment lacks the stdbool.h header file.

This macro may be defined on Windows systems when the compilation system does not supply the inttypes.h header file, in which case a local version is supplied instead.

This macro may be defined to indicate that the compilation system natively provides a type of "_Bool". This macro has no effect unless -DSPEC_NO_STDBOOL_H is set.

This macro may be defined to cause instances of ssize_t to be replaced with SSIZE_T.

This macro can be defined to indicate that the snprintf() function is not available, but that _snprintf() is.

This macro can be defined to prevent the preprocessor from replacing instances of snprintf() with _snprintf(). This substitution happens automatically on Windows.

This flag indicates that the source is being built on Windows.

This macro defines a cast which is used when comparing a file handle value (from the I/O abstraction layer) to NULL. It must match the type used for the file handle, which is int.

This macro is used to change the syntax use to cast initialization values from proper C99-style to GCC-style. The primary difference is that C99 defines it as a cast expression while GCC has it as a postfix expression. The syntax difference is one set of parentheses.

This macro can be used to indicate that the compilation environment doesn't support using the static modifier to array size specifications in function declarators.

These macros enable some source extensions on certain platforms. They are set to 1 by default but may be set to other values if necessary for portability.

This macro indicates that "universal" binaries are being built on MacOS X. The practical effect is to set WORDS_BIGENDIAN if __BIG_ENDIAN__ is set.

This macro contains the string value of the printf() format string that can be used to print a 32-bit integer as hexadecimal with upper-case characters. The default value is "X".

This macro contains the string value of the printf() format string that can be used to print a 64-bit integer as hexadecimal with upper-case characters. The default value is "llX" on 32-bit systems and "lX" on 64-bit systems.

This macro contains the string value of the printf() format string that can be used to print a 32-bit unsigned integer. The default value is "u".

This macro contains the string value of the printf() format string that can be used to print a 64-bit unsigned integer. The default value is "llu" on 32-bit systems and "lu" on 64-bit systems.

This macro contains the string value of the printf() format string that can be used to print a 32-bit integer as hexadecimal with lower-case characters. The default value is "x".

This macro contains the string value of the printf() format string that can be used to print a 64-bit integer as hexadecimal with lower-case characters. The default value is "llx" on 32-bit systems and "lx" on 64-bit systems.

When this macro is defined, XZ will not attempt to load system headers to get definitions for standard integer types.

This macro indicates that XZ is being built on a "DOS-like" system. It's set automatically when necessary, but may also be set explicitly if necessary.

These C99-standard macros ensure that the correct suffix is attached to their arguments. They should be defined by system header files, but in cases where they aren't, or are defined incorrectly, it's allowed to set them explicitly.

These macros define maximum values for their respective data types. They should be defined by system header files, but in cases where they aren't, or are defined incorrectly, it's allowed to set them explicitly.

This macro may be set if the compilation environment requires inclusion of memory.h to get memcmp(), memset() and others.

This macro may be set if the compilation environment requires inclusion of strings.h to get memcmp(), memset() and others.

This will cause the imaxdiv() function defined in the supplied inttypes.h (used only on Windows) to be declared static. The benchmark does not use imaxdiv(), but conceivably use of this flag could eliminate a linkage error if there's a conflict with a library function of the same name.

This flag indicates that the benchmark should be built to run in the CPU2017 harness. Without the flag, there is no hope that the benchmark will work.

This flag indicates to the benchmark code that the config.h file should be included.

These flags specify locations for the compiler to search for header files.

This macro indicates that the system being built can tolerate unaligned memory access, and is only used in the MD5 code.

This macro indicates that the system being built can tolerate unaligned memory access for 16- and 32-bit integers.

This macro indicates that the byteswap.h header file is available and contains definitions or prototypes for bswap_16(), bswap_32(), and bswap_64() functions.

This macro indicates that the sys/byteorder.h header file is available and contains definitions or prototypes for any or all of BSWAP_16(), BSWAP_32(), BSWAP_64(), BE_16(), BE_32(), BE_64(), LE_16(), LE_32(), and LE_64() functions.

This macro indicates that the sys/endian.h header file is available and contains definitions or prototypes for any or all of bswap16(), bswap32(), bswap64(), conv16be(), conv32be(), conv64be(), conv16le(), conv32le(), and conv64le() functions.

Defining this macro will cause the benchmark binary to pause before and after memory allocation and release operations that happen within the benchmark driver code.

This macro is defined and used internally and may not be set explicitly.

This flag indicates that the source is being built under Windows using the Cygwin toolset. It may not be set by hand.

This flag indicates that the source is being built under MS-DOS using the DJGPP compiler. It may not be set by hand.

This flag indicates that the source is being built with the GNU Compiler Collection. It has no effect in the CPU2017 version of the code, and thus may not be set by hand.

This macro indicates that the benchmark is being built with a C++ compiler. It may not be set by hand.

This macro defines the debug level for the benchmark driver code. 3 is the default and it may not be set lower. Setting it higher will enable output that will cause the benchmark to miscompare. Its use in reportable runs is forbidden.

This flag enables copious debug output which is guaranteed to cause the benchmark to miscompare. Its use in reportable runs is forbidden.

This flag causes buffers generated during the benchmark run to be dumped to files. Because this causes actual file I/O, its use in reportable runs is forbidden.

NULL should be defined by your system headers. Setting it explicitly is forbidden.

Use of this flag causes some internal timing to be done and output via the debug output facility. Its use is forbidden for reportable runs.

This flag is used to set the file number for stdin used by the benchmark's file I/O abstraction layer. Its default value must not be changed.

This flag is used to set the file number for stdout used by the benchmark's file I/O abstraction layer. Its default value must not be changed.

This flag is used to set the file number for stderr used by the benchmark's file I/O abstraction layer. Its default value must not be changed.

This macro defines a value for the open mode which will cause file I/O to be done without text translation. It is either defined by the compilation environment (if necessary), or it is defined to 0 otherwise. It may not be set by hand.

This macro defines a value for the open mode which will cause an open of a terminal device to not cause the controlling terminal to change. It has no effect in the benchmark version of the sources, and may not be set by hand.

This macro defines a value for the open mode which will cause an open of a file to not follow symlinks. It has no effect in the benchmark version of the sources, and may not be set by hand.

This macro is set automatically by the compilation system and indicates that the benchmark is being built on an x86 system that can tolerate unaligned access. It may not be set by hand.

This macro is set automatically by the compilation system and indicates that the benchmark is being built on a VAX system that can tolerate unaligned access. It may not be set by hand.

This macro is set automatically by the compilation system and indicates that the benchmark is being built on an AMD64-compatible system that can tolerate unaligned access. It may not be set by hand.

This flag indicates that the SPEC in-memory I/O shim should be built to work with bzip2. It will break the build and may not be used.

These macros define functions used for byte-swapping and endian conversion. They are set automatically and may not be changed for a reportable run.

These macros indicate the availablity of, or are themselves, byte-swapping or endian conversion functions. They are set automatically by the compilation system and may not be set explicitly for reportable runs.

These macros indicate the availability of certain internal XZ checksum functions. They may not be set or unset for reportable runs.

These macros indicate the availability of internal XZ decoder functions. They may not be set or unset for reportable runs.

These macros indicate the availability of internal XZ encoder functions. They may not be set or unset for reportable runs.

These macros indicate the availability of internal XZ match finder functions. They may not be set or unset for reportable runs.

These macros are guards against multiple inclusion of header files. Setting them explicitly is forbidden.

These macros define compiler-specific attributes and may not be set for a reportable run.

These macros control how certain hardware-specific information is obtained. They are not used in the benchmark code and may not be set for reportable runs.

This macro sets the prefix that should be used for the bundled getopt() function. Since the included getopt() is always used, it is not possible to set this to anything other than its default value.

These macros all indicate the presence of functions or structure members that are not used in the benchmark version of the source code. They have no effect on the compiled code and may not be set for a reportable run.

These macros are used to control the version strings output by XZ. They may not be changed from their default values.

These macros are used internally by XZ and may not be set manually.

These macros control XZ's use of localization functions. They have no function in the benchmark version of the sources and may not be set explicitly.

This macro indicates the value of sizeof(size_t). It is set automatically based on the data model flag (SPEC_P64, SPEC_LP64, SPEC_ILP64) and may not be set manually. The default value is 4 for 32-bit systems and 8 for 64-bit systems.

This macro contains the size in bytes of some internal buffers used in the XZ code. It is set by the system header files and may not be set manually.

This macro contains the size in bytes of some internal buffers used in the XZ code. It is set automatically based on the value of BUF_SIZE supplied by the system and may not be set manually.

These macros indicate the presence of several C99-standard header files. They are set automatically and may not be set or unset manually.

Setting these macros will cause the benchmark to fail to validate.

Setting these macros will cause the benchmark to fail to build.

Setting these macros will have no effect on the compiled code. They may not be set for reportable runs.

If set, these macros must be set by the compilation system. They may not be set manually for reportable runs.

This constant, if defined, must be defined by a system header file. Setting it explicitly is not allowed.

This macro contains the name of the XZ binary used by pxz. It is not used in the benchmark version of the source and may not be set explicitly.

This macro must be set by the compilation system when building the benchmark with OpenMP parallelization. It may not be set explicitly.

This macro, if set, must be set by the stdbool.h header file included with the compilation system. It may not be set explicitly.