summaryrefslogtreecommitdiffstats
path: root/config/cmake
diff options
context:
space:
mode:
authorDana Robinson <43805+derobins@users.noreply.github.com>2023-06-15 16:13:22 (GMT)
committerGitHub <noreply@github.com>2023-06-15 16:13:22 (GMT)
commitfcdd0ab9dc93871fa600aface194b294947fad1b (patch)
tree305a955e98f15290a2953021f5565e45b29657be /config/cmake
parent9a8c5810ed37d353522cbb26014698881cd52ce4 (diff)
downloadhdf5-fcdd0ab9dc93871fa600aface194b294947fad1b.zip
hdf5-fcdd0ab9dc93871fa600aface194b294947fad1b.tar.gz
hdf5-fcdd0ab9dc93871fa600aface194b294947fad1b.tar.bz2
Revert long double checks (#3133)
* Revert "Remove long double conversion work-arounds (#3097)" This reverts commit 1e1dac1dac58fa18f6b7788346d1ba7d3315b0f9. * Update comments to reflect newer systems
Diffstat (limited to 'config/cmake')
-rw-r--r--config/cmake/ConfigureChecks.cmake93
-rw-r--r--config/cmake/ConversionTests.c287
-rw-r--r--config/cmake/H5pubconf.h.in23
3 files changed, 403 insertions, 0 deletions
diff --git a/config/cmake/ConfigureChecks.cmake b/config/cmake/ConfigureChecks.cmake
index 32faed4..8c401d9 100644
--- a/config/cmake/ConfigureChecks.cmake
+++ b/config/cmake/ConfigureChecks.cmake
@@ -560,6 +560,19 @@ endif ()
MARK_AS_ADVANCED (HDF5_STRICT_FORMAT_CHECKS)
# ----------------------------------------------------------------------
+# Decide whether the data accuracy has higher priority during data
+# conversions. If not, some hard conversions will still be preferred even
+# though the data may be wrong (for example, some compilers don't
+# support denormalized floating values) to maximize speed.
+#-----------------------------------------------------------------------------
+option (HDF5_WANT_DATA_ACCURACY "IF data accuracy is guaranteed during data conversions" ON)
+mark_as_advanced (HDF5_WANT_DATA_ACCURACY)
+if (HDF5_WANT_DATA_ACCURACY)
+ set (${HDF_PREFIX}_WANT_DATA_ACCURACY 1)
+endif ()
+MARK_AS_ADVANCED (HDF5_WANT_DATA_ACCURACY)
+
+# ----------------------------------------------------------------------
# Decide whether the presence of user's exception handling functions is
# checked and data conversion exceptions are returned. This is mainly
# for the speed optimization of hard conversions. Soft conversions can
@@ -847,3 +860,83 @@ if (HDF5_BUILD_FORTRAN)
message (STATUS "maximum decimal precision for C var - ${${HDF_PREFIX}_PAC_C_MAX_REAL_PRECISION}")
endif()
+
+#-----------------------------------------------------------------------------
+# Macro to determine the various conversion capabilities
+#-----------------------------------------------------------------------------
+macro (H5ConversionTests TEST msg)
+ if (NOT DEFINED ${TEST})
+ TRY_RUN (${TEST}_RUN ${TEST}_COMPILE
+ ${CMAKE_BINARY_DIR}
+ ${HDF_RESOURCES_DIR}/ConversionTests.c
+ CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=-D${TEST}_TEST
+ OUTPUT_VARIABLE OUTPUT
+ )
+ if (${TEST}_COMPILE)
+ if (${TEST}_RUN EQUAL "0")
+ set (${TEST} 1 CACHE INTERNAL ${msg})
+ message (VERBOSE "${msg}... yes")
+ else ()
+ set (${TEST} "" CACHE INTERNAL ${msg})
+ message (VERBOSE "${msg}... no")
+ file (APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
+ "Test ${TEST} Run failed with the following output and exit code:\n ${OUTPUT}\n"
+ )
+ endif ()
+ else ()
+ set (${TEST} "" CACHE INTERNAL ${msg})
+ message (VERBOSE "${msg}... no")
+ file (APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
+ "Test ${TEST} Compile failed with the following output:\n ${OUTPUT}\n"
+ )
+ endif ()
+
+ endif ()
+endmacro ()
+
+#-----------------------------------------------------------------------------
+# Check various conversion capabilities
+#-----------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------
+# Set the flag to indicate that the machine is using a special algorithm toconvert
+# 'long double' to '(unsigned) long' values. (This flag should only be set for
+# the IBM Power Linux. When the bit sequence of long double is
+# 0x4351ccf385ebc8a0bfcc2a3c3d855620, the converted value of (unsigned)long
+# is 0x004733ce17af227f, not the same as the library's conversion to 0x004733ce17af2282.
+# The machine's conversion gets the correct value. We define the macro and disable
+# this kind of test until we figure out what algorithm they use.
+#-----------------------------------------------------------------------------
+H5ConversionTests (${HDF_PREFIX}_LDOUBLE_TO_LONG_SPECIAL "Checking IF your system converts long double to (unsigned) long values with special algorithm")
+# ----------------------------------------------------------------------
+# Set the flag to indicate that the machine is using a special algorithm
+# to convert some values of '(unsigned) long' to 'long double' values.
+# (This flag should be off for all machines, except for IBM Power Linux,
+# when the bit sequences are 003fff..., 007fff..., 00ffff..., 01ffff...,
+# ..., 7fffff..., the compiler uses a unknown algorithm. We define a
+# macro and skip the test for now until we know about the algorithm.
+#-----------------------------------------------------------------------------
+H5ConversionTests (${HDF_PREFIX}_LONG_TO_LDOUBLE_SPECIAL "Checking IF your system can convert (unsigned) long to long double values with special algorithm")
+# ----------------------------------------------------------------------
+# Set the flag to indicate that the machine can accurately convert
+# 'long double' to '(unsigned) long long' values. (This flag should be set for
+# all machines, except for Mac OS 10.4 and SGI IRIX64 6.5. When the bit sequence
+# of long double is 0x4351ccf385ebc8a0bfcc2a3c..., the values of (unsigned)long long
+# start to go wrong on these two machines. Adjusting it higher to
+# 0x4351ccf385ebc8a0dfcc... or 0x4351ccf385ebc8a0ffcc... will make the converted
+# values wildly wrong. This test detects this wrong behavior and disable the test.
+#-----------------------------------------------------------------------------
+H5ConversionTests (${HDF_PREFIX}_LDOUBLE_TO_LLONG_ACCURATE "Checking IF correctly converting long double to (unsigned) long long values")
+# ----------------------------------------------------------------------
+# Set the flag to indicate that the machine can accurately convert
+# '(unsigned) long long' to 'long double' values. (This flag should be set for
+# all machines, except for Mac OS 10.4, when the bit sequences are 003fff...,
+# 007fff..., 00ffff..., 01ffff..., ..., 7fffff..., the converted values are twice
+# as big as they should be.
+#-----------------------------------------------------------------------------
+H5ConversionTests (${HDF_PREFIX}_LLONG_TO_LDOUBLE_CORRECT "Checking IF correctly converting (unsigned) long long to long double values")
+# ----------------------------------------------------------------------
+# Set the flag to indicate that the machine can accurately convert
+# some long double values
+#-----------------------------------------------------------------------------
+H5ConversionTests (${HDF_PREFIX}_DISABLE_SOME_LDOUBLE_CONV "Checking IF the cpu is power9 and cannot correctly converting long double values")
diff --git a/config/cmake/ConversionTests.c b/config/cmake/ConversionTests.c
new file mode 100644
index 0000000..725f049
--- /dev/null
+++ b/config/cmake/ConversionTests.c
@@ -0,0 +1,287 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by The HDF Group. *
+ * All rights reserved. *
+ * *
+ * This file is part of HDF5. The full HDF5 copyright notice, including *
+ * terms governing use, modification, and redistribution, is contained in *
+ * the COPYING file, which can be found at the root of the source code *
+ * distribution tree, or in https://www.hdfgroup.org/licenses. *
+ * If you do not have access to either file, you may request a copy from *
+ * help@hdfgroup.org. *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#if defined(__has_attribute)
+# if __has_attribute(no_sanitize)
+# define HDF_NO_UBSAN __attribute__((no_sanitize("undefined")))
+# else
+# define HDF_NO_UBSAN
+# endif
+#else
+# define HDF_NO_UBSAN
+#endif
+
+#ifdef H5_LDOUBLE_TO_LONG_SPECIAL_TEST
+
+#include <string.h>
+#include <stdlib.h>
+
+int HDF_NO_UBSAN main(void)
+{
+ long double ld = 20041683600089727.779961L;
+ long ll;
+ unsigned long ull;
+ unsigned char s[16];
+ unsigned char s2[8];
+ int ret = 1;
+
+ if (sizeof(long double) == 16 && sizeof(long) == 8) {
+ /* Make sure the long double type has 16 bytes in size and
+ * 11 bits of exponent. If it is, the bit sequence should be
+ * like below. It's not a decent way to check but this info
+ * isn't available.
+ */
+ memcpy(s, &ld, 16);
+ if (s[0]==0x43 && s[1]==0x51 && s[2]==0xcc && s[3]==0xf3 &&
+ s[4]==0x85 && s[5]==0xeb && s[6]==0xc8 && s[7]==0xa0 &&
+ s[8]==0xbf && s[9]==0xcc && s[10]==0x2a && s[11]==0x3c) {
+
+ /* Assign the hexadecimal value of long double type. */
+ s[0]=0x43; s[1]=0x51; s[2]=0xcc; s[3]=0xf3;
+ s[4]=0x85; s[5]=0xeb; s[6]=0xc8; s[7]=0xa0;
+ s[8]=0xbf; s[9]=0xcc; s[10]=0x2a; s[11]=0x3c;
+ s[12]=0x3d; s[13]=0x85; s[14]=0x56; s[15]=0x20;
+
+ memcpy(&ld, s, 16);
+
+ ll = (long)ld;
+ memcpy(s2, &ll, 8);
+
+ /* The library's algorithm converts it to 0x00 47 33 ce 17 af 22 82
+ * and gets wrong value 20041683600089730 on Linux on IBM Power
+ * architecture.
+ *
+ * But Linux on IBM Power converts it to 0x00 47 33 ce 17 af 22 7f
+ * and gets the correct value 20041683600089727. It uses some special
+ * algorithm. We're going to define the macro and skip the test until
+ * we can figure out how they do it.
+ */
+ if (s2[0]==0x00 && s2[1]==0x47 && s2[2]==0x33 && s2[3]==0xce &&
+ s2[4]==0x17 && s2[5]==0xaf && s2[6]==0x22 && s2[7]==0x7f)
+
+ ret = 0;
+
+ ull = (unsigned long)ld;
+ memcpy(s2, &ull, 8);
+
+ /* The unsigned long is the same as signed long */
+ if(s2[0]==0x00 && s2[1]==0x47 && s2[2]==0x33 && s2[3]==0xce &&
+ s2[4]==0x17 && s2[5]==0xaf && s2[6]==0x22 && s2[7]==0x7f)
+
+ ret = 0;
+ }
+ }
+
+done:
+ exit(ret);
+}
+
+#endif
+
+#ifdef H5_LONG_TO_LDOUBLE_SPECIAL_TEST
+
+#include <string.h>
+#include <stdlib.h>
+
+int HDF_NO_UBSAN main(void)
+{
+ long double ld;
+ long ll;
+ unsigned long ull;
+ unsigned char s[16];
+ int flag=0, ret=1;
+
+ /* Determine if long double has 16 byte in size, 11 bit exponent, and
+ * the bias is 0x3ff
+ */
+ if (sizeof(long double) == 16) {
+ ld = 1.0L;
+ memcpy(s, &ld, 16);
+
+ if (s[0]==0x3f && s[1]==0xf0 && s[2]==0x00 && s[3]==0x00 &&
+ s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00)
+
+ flag = 1;
+ }
+
+ if (flag==1 && sizeof(long)==8) {
+ ll = 0x003fffffffffffffL;
+ ld = (long double)ll;
+ memcpy(s, &ld, 16);
+
+ /* The library converts the value to 0x434fffffffffffff8000000000000000.
+ * In decimal it is 18014398509481982.000000, one value short of the original.
+ *
+ * Linux on IBM Power architecture converts it to
+ * 0x4350000000000000bff0000000000000. The value is correct in decimal.
+ * It uses some special algorithm. We're going to define the macro and
+ * skip the test until we can figure out how they do it.
+ */
+ if (s[0]==0x43 && s[1]==0x50 && s[2]==0x00 && s[3]==0x00 &&
+ s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00 &&
+ s[8]==0xbf && s[9]==0xf0 && s[10]==0x00 && s[11]==0x00 &&
+ s[12]==0x00 && s[13]==0x00 && s[14]==0x00 && s[15]==0x00)
+
+ ret = 0;
+ }
+
+ if (flag==1 && sizeof(unsigned long)==8) {
+ ull = 0xffffffffffffffffUL;
+ ld = (long double)ull;
+ memcpy(s, &ld, 16);
+
+ /* Use a different value from signed long to test. The problem is the
+ * same for both long and unsigned long. The value is 18446744073709551615.
+ * The library converts the value to 0x43effffffffffffffe000000000000000.
+ * In decimal it's 18446744073709548544.000000, very different from the
+ * original. Linux on IBM Power architecture converts it to
+ * 0x43f0000000000000bff0000000000000. The value is correct in decimal.
+ * It uses some special algorithm. We're going to define the macro and
+ * skip the test until we can figure out how they do it.
+ */
+ if (s[0]==0x43 && s[1]==0xf0 && s[2]==0x00 && s[3]==0x00 &&
+ s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00 &&
+ s[8]==0xbf && s[9]==0xf0 && s[10]==0x00 && s[11]==0x00 &&
+ s[12]==0x00 && s[13]==0x00 && s[14]==0x00 && s[15]==0x00)
+
+ ret = 0;
+ }
+done:
+ exit(ret);
+}
+
+#endif
+
+#ifdef H5_LDOUBLE_TO_LLONG_ACCURATE_TEST
+
+#include <string.h>
+#include <stdlib.h>
+
+int HDF_NO_UBSAN main(void)
+{
+ long double ld = 20041683600089727.779961L;
+ long long ll;
+ unsigned long long ull;
+ unsigned char s[16];
+ int ret = 0;
+
+ if (sizeof(long double) == 16) {
+ /* Make sure the long double type is the same as the failing type
+ * which has 16 bytes in size and 11 bits of exponent. If it is,
+ * the bit sequence should be like below. It's not
+ * a decent way to check but this info isn't available.
+ */
+ memcpy(s, &ld, 16);
+
+ if (s[0]==0x43 && s[1]==0x51 && s[2]==0xcc && s[3]==0xf3 &&
+ s[4]==0x85 && s[5]==0xeb && s[6]==0xc8 && s[7]==0xa0 &&
+ s[8]==0xbf && s[9]==0xcc && s[10]==0x2a && s[11]==0x3c) {
+
+ /* Slightly adjust the bit sequence (s[8]=0xdf). The converted
+ * values will go wild on Mac OS 10.4 and IRIX64 6.5.
+ */
+ s[0]=0x43; s[1]=0x51; s[2]=0xcc; s[3]=0xf3;
+ s[4]=0x85; s[5]=0xeb; s[6]=0xc8; s[7]=0xa0;
+ s[8]=0xdf; s[9]=0xcc; s[10]=0x2a; s[11]=0x3c;
+ s[12]=0x3d; s[13]=0x85; s[14]=0x56; s[15]=0x20;
+
+ memcpy(&ld, s, 16);
+ ll = (long long)ld;
+ ull = (unsigned long long)ld;
+
+ if (ll != 20041683600089728 || ull != 20041683600089728)
+ ret = 1;
+ }
+ }
+done:
+ exit(ret);
+}
+#endif
+
+#ifdef H5_LLONG_TO_LDOUBLE_CORRECT_TEST
+
+#include <string.h>
+#include <stdlib.h>
+
+int HDF_NO_UBSAN main(void)
+{
+ long double ld;
+ long long ll;
+ unsigned long long ull;
+ unsigned char s[16];
+ int flag=0, ret=0;
+
+ /* Determine if long double has 16 byte in size, 11 bit exponent, and
+ * the bias is 0x3ff
+ */
+ if (sizeof(long double) == 16) {
+ ld = 1.0L;
+ memcpy(s, &ld, 16);
+ if (s[0]==0x3f && s[1]==0xf0 && s[2]==0x00 && s[3]==0x00 &&
+ s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00)
+
+ flag = 1;
+ }
+
+ if (flag==1 && sizeof(long long)==8) {
+ ll = 0x01ffffffffffffffLL;
+ ld = (long double)ll;
+ memcpy(s, &ld, 16);
+
+ /* Check if the bit sequence is as expected*/
+ if (s[0]!=0x43 || s[1]!=0x7f || s[2]!=0xff || s[3]!=0xff ||
+ s[4]!=0xff || s[5]!=0xff || s[6]!=0xff || s[7]!=0xff ||
+ s[8]!=0xf0 || s[9]!=0x00 || s[10]!=0x00 || s[11]!=0x00)
+
+ ret = 1;
+ }
+ if (flag==1 && sizeof(unsigned long long)==8) {
+ ull = 0x01ffffffffffffffULL;
+ ld = (long double)ull;
+ memcpy(s, &ld, 16);
+
+ if (s[0]!=0x43 || s[1]!=0x7f || s[2]!=0xff || s[3]!=0xff ||
+ s[4]!=0xff || s[5]!=0xff || s[6]!=0xff || s[7]!=0xff ||
+ s[8]!=0xf0 || s[9]!=0x00 || s[10]!=0x00 || s[11]!=0x00)
+
+ ret = 1;
+ }
+
+done:
+ exit(ret);
+}
+#endif
+
+#ifdef H5_DISABLE_SOME_LDOUBLE_CONV_TEST
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int HDF_NO_UBSAN main(void)
+{
+ FILE *fp;
+ char cpu[64];
+
+ fp = popen("uname -m", "r");
+
+ fgets(cpu, sizeof(cpu)-1, fp);
+
+ pclose(fp);
+
+ if (strncmp(cpu, "ppc64le", 7) == 0)
+ return 0;
+
+ return 1;
+}
+
+#endif
diff --git a/config/cmake/H5pubconf.h.in b/config/cmake/H5pubconf.h.in
index 444a0e4..d4b0d36 100644
--- a/config/cmake/H5pubconf.h.in
+++ b/config/cmake/H5pubconf.h.in
@@ -32,6 +32,10 @@
/* Define if dev_t is a scalar */
#cmakedefine H5_DEV_T_IS_SCALAR @H5_DEV_T_IS_SCALAR@
+/* Define if your system is IBM ppc64le and cannot convert some long double
+ values correctly. */
+#cmakedefine H5_DISABLE_SOME_LDOUBLE_CONV @H5_DISABLE_SOME_LDOUBLE_CONV@
+
/* Define to dummy `main' function (if any) required to link to the Fortran
libraries. */
#cmakedefine H5_FC_DUMMY_MAIN @H5_FC_DUMMY_MAIN@
@@ -371,6 +375,22 @@
/* Define if new-style references should be used with dimension scales */
#cmakedefine H5_DIMENSION_SCALES_WITH_NEW_REF @H5_DIMENSION_SCALES_WITH_NEW_REF@
+/* Define if your system can convert long double to (unsigned) long long
+ values correctly. */
+#cmakedefine H5_LDOUBLE_TO_LLONG_ACCURATE @H5_LDOUBLE_TO_LLONG_ACCURATE@
+
+/* Define if your system converts long double to (unsigned) long values with
+ special algorithm. */
+#cmakedefine H5_LDOUBLE_TO_LONG_SPECIAL @H5_LDOUBLE_TO_LONG_SPECIAL@
+
+/* Define if your system can convert (unsigned) long long to long double
+ values correctly. */
+#cmakedefine H5_LLONG_TO_LDOUBLE_CORRECT @H5_LLONG_TO_LDOUBLE_CORRECT@
+
+/* Define if your system can convert (unsigned) long to long double values
+ with special algorithm. */
+#cmakedefine H5_LONG_TO_LDOUBLE_SPECIAL @H5_LONG_TO_LDOUBLE_SPECIAL@
+
/* Define to the sub-directory where libtool stores uninstalled libraries. */
#cmakedefine H5_LT_OBJDIR @H5_LT_OBJDIR@
@@ -599,6 +619,9 @@
/* Version number of package */
#define H5_VERSION "@HDF5_PACKAGE_VERSION_STRING@"
+/* Data accuracy is preferred to speed during data conversions */
+#cmakedefine H5_WANT_DATA_ACCURACY @H5_WANT_DATA_ACCURACY@
+
/* Check exception handling functions during data conversions */
#cmakedefine H5_WANT_DCONV_EXCEPTION @H5_WANT_DCONV_EXCEPTION@