mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2024-11-27 02:10:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

Clean up Fortran __float128 configure-time checks (#4649)

Browse Source 
* Always use DECIMAL_DIG instead of LDBL_DIG. This was controlled by
  an ifdef that is always true in C99 or greater

It's confusing to use float.h C constants as variable names in
configure.ac and the PAC_FC_LDBL_DIG macro.

* Directly compare MY_FLT128_DIG and MY_LDBL_DIG

* Make uniform across CMake and Autotools
* Don't export quadmath.h variables to H5pubconf.h
This commit is contained in:
Dana Robinson 2024-07-15 05:38:13 -07:00 committed by GitHub
parent 033f2a8cb5
commit 9b5d9680af
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
7 changed files with 173 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
config/cmake/ConfigureChecks.cmake
View File

@ -132,11 +132,15 @@ endif ()
## Check for non-standard extension quadmath.h ## Check for non-standard extension quadmath.h
CHECK_INCLUDE_FILES(quadmath.h C_HAVE_QUADMATH) # gcc puts symbols like FLT128_DIG in quadmath.h instead of float.h, so
if (C_HAVE_QUADMATH) # check for that. This is only used by the build system and doesn't need
set(${HDF_PREFIX}_HAVE_QUADMATH_H 1) # to be exported to H5pubconf.h.
CHECK_INCLUDE_FILES("quadmath.h" INCLUDE_QUADMATH_H)
# Convert TRUE/FALSE to 0/1 for preprocessor values in test code, below
if (${INCLUDE_QUADMATH_H})
set(C_INCLUDE_QUADMATH_H 1)
else () else ()
set(${HDF_PREFIX}_HAVE_QUADMATH_H 0) set(C_INCLUDE_QUADMATH_H 0)
endif () endif ()
if (CYGWIN) if (CYGWIN)
@ -646,22 +650,38 @@ endif()
#----------------------------------------------------------------------------- #-----------------------------------------------------------------------------
if (HDF5_BUILD_FORTRAN) if (HDF5_BUILD_FORTRAN)
HDF_CHECK_TYPE_SIZE(__float128 _SIZEOF___FLOAT128) # ----------------------------------------------------------------------
if (_SIZEOF___FLOAT128) # __float128 checks
set (${HDF_PREFIX}_HAVE_FLOAT128 1) #
set (${HDF_PREFIX}_SIZEOF___FLOAT128 ${_SIZEOF___FLOAT128}) # If __float128 exists and we can determine its precision, we will use
# it in the Fortran interface. The checks for this require that the
# precision be specified via a symbol named FLT128_DIG, which might be
# found in quadmath.h.
#
# The checks here are based on the GNU __float128 extension type from
# libquadmath, which is now part of gcc. Other compilers (clang, Intel)
# also expose __float128 and/or __float128 may be an alias for some
# other 128-bit floating point type.
#
# 128-bit floating-point math is usually handled in software and is thus
# orders of magnitude slower than hardware-supported floating-point math.
#
#-----------------------------------------------------------------------------
# Is the __float128 type available?
#-----------------------------------------------------------------------------
HDF_FUNCTION_TEST (HAVE___FLOAT128)
# Convert TRUE/FALSE to 0/1 for preprocessor values in test code, below
if (${HAVE___FLOAT128})
set(C_HAVE_FLOAT128 1)
else () else ()
set (${HDF_PREFIX}_HAVE_FLOAT128 0) set(C_HAVE_FLOAT128 0)
set (${HDF_PREFIX}_SIZEOF___FLOAT128 0)
endif ()
HDF_CHECK_TYPE_SIZE(_Quad _SIZEOF__QUAD)
if (NOT _SIZEOF__QUAD)
set (${HDF_PREFIX}_SIZEOF__QUAD 0)
else ()
set (${HDF_PREFIX}_SIZEOF__QUAD ${_SIZEOF__QUAD})
endif () endif ()
#-----------------------------------------------------------------------------
# Get the max decimal precision in C, checking both long double and
# __float128 (if available)
#-----------------------------------------------------------------------------
if (NOT CMAKE_CROSSCOMPILING) if (NOT CMAKE_CROSSCOMPILING)
#----------------------------------------------------------------------------- #-----------------------------------------------------------------------------
# The provided CMake C macros don't provide a general compile/run function # The provided CMake C macros don't provide a general compile/run function
@ -682,7 +702,6 @@ if (HDF5_BUILD_FORTRAN)
TRY_RUN (RUN_RESULT_VAR COMPILE_RESULT_VAR TRY_RUN (RUN_RESULT_VAR COMPILE_RESULT_VAR
${CMAKE_BINARY_DIR} ${CMAKE_BINARY_DIR}
${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testCCompiler1.c ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testCCompiler1.c
COMPILE_DEFINITIONS "-D_SIZEOF___FLOAT128=${H5_SIZEOF___FLOAT128};-D_HAVE_QUADMATH_H=${H5_HAVE_QUADMATH_H}"
COMPILE_OUTPUT_VARIABLE COMPILEOUT COMPILE_OUTPUT_VARIABLE COMPILEOUT
${_RUN_OUTPUT_VARIABLE} OUTPUT_VAR ${_RUN_OUTPUT_VARIABLE} OUTPUT_VAR
) )
@ -719,43 +738,42 @@ if (HDF5_BUILD_FORTRAN)
" "
#include <float.h>\n\ #include <float.h>\n\
#include <stdio.h>\n\ #include <stdio.h>\n\
#define CHECK_FLOAT128 _SIZEOF___FLOAT128\n\ #if ${C_HAVE_FLOAT128}\n\
#if CHECK_FLOAT128!=0\n\ # if ${C_INCLUDE_QUADMATH_H}\n\
#if _HAVE_QUADMATH_H!=0\n\ # include <quadmath.h>\n\
#include <quadmath.h>\n\ # endif\n\
#endif\n\ # ifdef FLT128_DIG\n\
#ifdef FLT128_DIG\n\ # define C_FLT128_DIG FLT128_DIG\n\
#define C_FLT128_DIG FLT128_DIG\n\ # else\n\
# define C_FLT128_DIG 0\n\
# endif\n\
#else\n\ #else\n\
#define C_FLT128_DIG 0\n\ # define C_FLT128_DIG 0\n\
#endif\n\ #endif\n\
#else\n\
#define C_FLT128_DIG 0\n\
#endif\n\
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L\n\
#define C_LDBL_DIG DECIMAL_DIG\n\ #define C_LDBL_DIG DECIMAL_DIG\n\
#else\n\ \n\
#define C_LDBL_DIG LDBL_DIG\n\ int main(void) {\nprintf(\"\\%d\\\;\\%d\\\;\", C_LDBL_DIG, C_FLT128_DIG)\\\;\n\nreturn 0\\\;\n}\n
#endif\n\nint main(void) {\nprintf(\"\\%d\\\;\\%d\\\;\", C_LDBL_DIG, C_FLT128_DIG)\\\;\n\nreturn 0\\\;\n}\n "
"
) )
C_RUN ("maximum decimal precision for C" ${PROG_SRC} PROG_RES PROG_OUTPUT4) C_RUN ("maximum decimal precision for C" ${PROG_SRC} PROG_RES PROG_OUTPUT4)
message (STATUS "Testing maximum decimal precision for C - ${PROG_OUTPUT4}") message (STATUS "Testing maximum decimal precision for C - ${PROG_OUTPUT4}")
# dnl The output from the above program will be: # The output from the above program will be:
# dnl -- long double decimal precision -- __float128 decimal precision # -- long double decimal precision -- __float128 decimal precision
list (GET PROG_OUTPUT4 0 H5_LDBL_DIG) list (GET PROG_OUTPUT4 0 MY_LDBL_DIG)
list (GET PROG_OUTPUT4 1 H5_FLT128_DIG) list (GET PROG_OUTPUT4 1 MY_FLT128_DIG)
if (${HDF_PREFIX}_SIZEOF___FLOAT128 EQUAL "0" OR FLT128_DIG EQUAL "0") # Set configure output and behavior
set (${HDF_PREFIX}_HAVE_FLOAT128 0) if (${HAVE___FLOAT128} AND (${MY_FLT128_DIG} GREATER ${MY_LDBL_DIG}))
set (${HDF_PREFIX}_SIZEOF___FLOAT128 0) set (${HDF_PREFIX}_HAVE_FLOAT128 1)
set (_PAC_C_MAX_REAL_PRECISION ${H5_LDBL_DIG}) set (_PAC_C_MAX_REAL_PRECISION ${MY_FLT128_DIG})
else () else ()
set (_PAC_C_MAX_REAL_PRECISION ${H5_FLT128_DIG}) # No __float128 or the precision of __float128 <= that of long double
set (_PAC_C_MAX_REAL_PRECISION ${MY_LDBL_DIG})
endif () endif ()
if (NOT ${_PAC_C_MAX_REAL_PRECISION}) if (NOT ${_PAC_C_MAX_REAL_PRECISION})
set (${HDF_PREFIX}_PAC_C_MAX_REAL_PRECISION 0) set (${HDF_PREFIX}_PAC_C_MAX_REAL_PRECISION 0)
else () else ()

11
config/cmake/H5pubconf.h.in
View File

@ -146,7 +146,7 @@
/* Determine if _Float16 is available */ /* Determine if _Float16 is available */
#cmakedefine H5_HAVE__FLOAT16 @H5_HAVE__FLOAT16@ #cmakedefine H5_HAVE__FLOAT16 @H5_HAVE__FLOAT16@
/* Determine if __float128 is available */ /* Determine if __float128 will be used in the Fortran wrappers */
#cmakedefine H5_HAVE_FLOAT128 @H5_HAVE_FLOAT128@ #cmakedefine H5_HAVE_FLOAT128 @H5_HAVE_FLOAT128@
/* Define to 1 if you have the `flock' function. */ /* Define to 1 if you have the `flock' function. */
@ -270,9 +270,6 @@
/* Define to 1 if you have the <pwd.h> header file. */ /* Define to 1 if you have the <pwd.h> header file. */
#cmakedefine H5_HAVE_PWD_H @H5_HAVE_PWD_H@ #cmakedefine H5_HAVE_PWD_H @H5_HAVE_PWD_H@
/* Define to 1 if you have the <quadmath.h> header file. */
#cmakedefine H5_HAVE_QUADMATH_H @H5_HAVE_QUADMATH_H@
/* Define whether the Read-Only S3 virtual file driver (VFD) should be /* Define whether the Read-Only S3 virtual file driver (VFD) should be
compiled */ compiled */
#cmakedefine H5_HAVE_ROS3_VFD @H5_HAVE_ROS3_VFD@ #cmakedefine H5_HAVE_ROS3_VFD @H5_HAVE_ROS3_VFD@
@ -586,15 +583,9 @@
/* The size of `unsigned', as computed by sizeof. */ /* The size of `unsigned', as computed by sizeof. */
#cmakedefine H5_SIZEOF_UNSIGNED @H5_SIZEOF_UNSIGNED@ #cmakedefine H5_SIZEOF_UNSIGNED @H5_SIZEOF_UNSIGNED@
/* The size of `_Quad', as computed by sizeof. */
#define H5_SIZEOF__QUAD @H5_SIZEOF__QUAD@
/* The size of `_Float16', as computed by sizeof. */ /* The size of `_Float16', as computed by sizeof. */
#define H5_SIZEOF__FLOAT16 @H5_SIZEOF__FLOAT16@ #define H5_SIZEOF__FLOAT16 @H5_SIZEOF__FLOAT16@
/* The size of `__float128', as computed by sizeof. */
#define H5_SIZEOF___FLOAT128 @H5_SIZEOF___FLOAT128@
/* Define if strict file format checks are enabled */ /* Define if strict file format checks are enabled */
#cmakedefine H5_STRICT_FORMAT_CHECKS @H5_STRICT_FORMAT_CHECKS@ #cmakedefine H5_STRICT_FORMAT_CHECKS @H5_STRICT_FORMAT_CHECKS@

23
config/cmake/HDF5UseFortran.cmake
View File

@ -363,13 +363,13 @@ set (PROG_SRC3
" "
) )
FORTRAN_RUN ("SIZEOF NATIVE KINDs" ${PROG_SRC3} XX YY PAC_SIZEOF_NATIVE_KINDS_RESULT PROG_OUTPUT3) FORTRAN_RUN ("SIZEOF NATIVE KINDs" ${PROG_SRC3} XX YY PAC_SIZEOF_NATIVE_KINDS_RESULT PROG_OUTPUT3)
# dnl The output from the above program will be: # The output from the above program will be:
# dnl -- LINE 1 -- sizeof INTEGER # -- LINE 1 -- sizeof INTEGER
# dnl -- LINE 2 -- kind of INTEGER # -- LINE 2 -- kind of INTEGER
# dnl -- LINE 3 -- sizeof REAL # -- LINE 3 -- sizeof REAL
# dnl -- LINE 4 -- kind of REAL # -- LINE 4 -- kind of REAL
# dnl -- LINE 5 -- sizeof DOUBLE PRECISION # -- LINE 5 -- sizeof DOUBLE PRECISION
# dnl -- LINE 6 -- kind of DOUBLE PRECISION # -- LINE 6 -- kind of DOUBLE PRECISION
# #
# Convert the string to a list of strings by replacing the carriage return with a semicolon # Convert the string to a list of strings by replacing the carriage return with a semicolon
string (REGEX REPLACE "[\r\n]+" ";" PROG_OUTPUT3 "${PROG_OUTPUT3}") string (REGEX REPLACE "[\r\n]+" ";" PROG_OUTPUT3 "${PROG_OUTPUT3}")
@ -402,11 +402,10 @@ endif ()
set (${HDF_PREFIX}_FORTRAN_SIZEOF_LONG_DOUBLE ${${HDF_PREFIX}_SIZEOF_LONG_DOUBLE}) set (${HDF_PREFIX}_FORTRAN_SIZEOF_LONG_DOUBLE ${${HDF_PREFIX}_SIZEOF_LONG_DOUBLE})
# remove the invalid kind from the list # Remove the invalid kind from the list
if (NOT(${${HDF_PREFIX}_SIZEOF___FLOAT128} EQUAL 0)) if (${${HDF_PREFIX}_HAVE_FLOAT128})
if (NOT(${${HDF_PREFIX}_SIZEOF___FLOAT128} EQUAL ${max_real_fortran_sizeof}) if (NOT(16 EQUAL ${max_real_fortran_sizeof}) AND NOT(${${HDF_PREFIX}_FORTRAN_SIZEOF_LONG_DOUBLE} EQUAL ${max_real_fortran_sizeof})
AND NOT(${${HDF_PREFIX}_FORTRAN_SIZEOF_LONG_DOUBLE} EQUAL ${max_real_fortran_sizeof}) # Account for the fact that the C compiler can have 16-byte __float128 and the fortran compiler only has 8-byte doubles,
# account for the fact that the C compiler can have 16-byte __float128 and the fortran compiler only has 8-byte doubles,
# so we don't want to remove the 8-byte fortran doubles. # so we don't want to remove the 8-byte fortran doubles.
AND NOT(${PAC_FORTRAN_NATIVE_DOUBLE_SIZEOF} EQUAL ${max_real_fortran_sizeof})) AND NOT(${PAC_FORTRAN_NATIVE_DOUBLE_SIZEOF} EQUAL ${max_real_fortran_sizeof}))
message (WARNING " message (WARNING "

12
config/cmake/HDFTests.c
View File

@ -14,6 +14,18 @@
/* A simple test program to see if a function "works" */ /* A simple test program to see if a function "works" */
#define SIMPLE_TEST(x) int main(void){ x; return 0; } #define SIMPLE_TEST(x) int main(void){ x; return 0; }
#ifdef HAVE___FLOAT128
/* Check if __float128 works (only used in the Fortran interface) */
int
main ()
{
__float128 x;
return 0;
}
#endif /* HAVE___FLOAT128 */
#ifdef HAVE_BUILTIN_EXPECT #ifdef HAVE_BUILTIN_EXPECT

90
configure.ac
View File

@ -793,30 +793,76 @@ AC_MSG_RESULT([$HDF_FORTRAN])
if test "X$HDF_FORTRAN" = "Xyes"; then if test "X$HDF_FORTRAN" = "Xyes"; then
## ---------------------------------------------------------------------- ## ----------------------------------------------------------------------
## Check for non-standard extension __FLOAT128 ## __float128 checks
## ##
HAVE_FLOAT128=0 ## If __float128 exists and we can determine its precision, we will use
HAVE_QUADMATH=0 ## it in the Fortran interface. The checks for this require that the
FLT128_DIG=0 ## precision be specified via a symbol named FLT128_DIG, which might be
LDBL_DIG=0 ## found in quadmath.h.
##
## The checks here are based on the GNU __float128 extension type from
## libquadmath, which is now part of gcc. Other compilers (clang, Intel)
## also expose __float128 and/or __float128 may be an alias for some
## other 128-bit floating point type.
##
## 128-bit floating-point math is usually handled in software and is thus
## orders of magnitude slower than hardware-supported floating-point math.
##
AC_MSG_CHECKING([if __float128 exists])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],[[__float128 x; return 0;]])],
[HAVE___FLOAT128=1; AC_MSG_RESULT([yes])],
[HAVE___FLOAT128=0; AC_MSG_RESULT([no])]
)
AC_CHECK_SIZEOF([__float128]) ## gcc puts symbols like FLT128_DIG in quadmath.h instead of float.h,
AC_CHECK_SIZEOF([_Quad]) ## so check for that before running the precision macro. Note that
AC_CHECK_HEADERS([quadmath.h], [HAVE_QUADMATH=1], []) ## using AC_CHECK_HEADER instead of AC_CHECK_HEADERS keeps the
## H5_HAVE_QUADMATH_H symbol out of the public config header.
##
AC_CHECK_HEADER([quadmath.h], [INCLUDE_QUADMATH_H=1], [INCLUDE_QUADMATH_H=0])
## ----------------------------------------------------------------------
## Get the max decimal precision in C, checking both long double and
## __float128 (if available)
##
AC_MSG_CHECKING([maximum decimal precision for C])
MY_FLT128_DIG=0
MY_LDBL_DIG=0
## Macro to compare long double and __float128 to see which has higher precision
PAC_FC_LDBL_DIG PAC_FC_LDBL_DIG
AC_SUBST([PAC_C_MAX_REAL_PRECISION]) ## Set results
if test "$MY_FLT128_DIG" -gt "$MY_LDBL_DIG" ; then
if test "$ac_cv_sizeof___float128" != 0 && test "$FLT128_DIG" != 0 ; then PAC_C_MAX_REAL_PRECISION=$MY_FLT128_DIG
AC_DEFINE([HAVE_FLOAT128], [1], [Determine if __float128 is available]) PRECISION_TYPE="(__float128)"
PAC_C_MAX_REAL_PRECISION=$FLT128_DIG
else else
PAC_C_MAX_REAL_PRECISION=$LDBL_DIG PAC_C_MAX_REAL_PRECISION=$MY_LDBL_DIG
PRECISION_TYPE="(long double)"
fi fi
AC_DEFINE_UNQUOTED([PAC_C_MAX_REAL_PRECISION], $PAC_C_MAX_REAL_PRECISION, [Determine the maximum decimal precision in C]) AC_MSG_RESULT([$PAC_C_MAX_REAL_PRECISION $PRECISION_TYPE])
AC_MSG_RESULT([$PAC_C_MAX_REAL_PRECISION])
## Store results in config file
AC_SUBST([PAC_C_MAX_REAL_PRECISION])
AC_DEFINE_UNQUOTED([PAC_C_MAX_REAL_PRECISION], $PAC_C_MAX_REAL_PRECISION, [Determine the maximum decimal precision in C])
## Are we going to use __float128?
AC_MSG_CHECKING([if __float128 will be used in the Fortran wrappers])
if test "$MY_FLT128_DIG" -gt "$MY_LDBL_DIG" ; then
AC_MSG_RESULT([yes])
AC_DEFINE([HAVE_FLOAT128], [1], [Determine if __float128 will be used in the Fortran wrappers])
else
## Can't use __float128, but write an undef line anyway
AC_MSG_RESULT([no])
AH_TEMPLATE([HAVE_FLOAT128], [Determine if __float128 will be used in the Fortran wrappers])
fi
## ----------------------------------------------------------------------
## Define interface version
##
VERS_MAJOR=`cat $srcdir/src/H5public.h | sed -n 's/^#define H5_VERS_MAJOR //p'` VERS_MAJOR=`cat $srcdir/src/H5public.h | sed -n 's/^#define H5_VERS_MAJOR //p'`
VERS_MINOR=`cat $srcdir/src/H5public.h | sed -n 's/^#define H5_VERS_MINOR //p'` VERS_MINOR=`cat $srcdir/src/H5public.h | sed -n 's/^#define H5_VERS_MINOR //p'`
VERS_RELEASE=`cat $srcdir/src/H5public.h | sed -n 's/^#define H5_VERS_RELEASE //p'` VERS_RELEASE=`cat $srcdir/src/H5public.h | sed -n 's/^#define H5_VERS_RELEASE //p'`
@ -824,10 +870,10 @@ if test "X$HDF_FORTRAN" = "Xyes"; then
AC_DEFINE_UNQUOTED([VERS_MINOR_TMP], $VERS_MINOR, [Define minor library version]) AC_DEFINE_UNQUOTED([VERS_MINOR_TMP], $VERS_MINOR, [Define minor library version])
AC_DEFINE_UNQUOTED([VERS_RELEASE_TMP], $VERS_RELEASE, [Define release library version]) AC_DEFINE_UNQUOTED([VERS_RELEASE_TMP], $VERS_RELEASE, [Define release library version])
## We will output an include file for Fortran, H5config_f.inc which ## We will output an include file for Fortran, H5config_f.inc which
## contains various configure definitions used by the Fortran Library. ## contains various configure definitions used by the Fortran Library.
## Prepend H5_ to all macro names. This avoids name conflict between HDF5 macro ## Prepend H5_ to all macro names. This avoids name conflict between HDF5 macro
## names and those generated by another software package that uses the HDF5 library. ## names and those generated by another software package that uses the HDF5 library.
AC_CONFIG_HEADERS([fortran/src/H5config_f.inc], AC_CONFIG_HEADERS([fortran/src/H5config_f.inc],
[cat fortran/src/H5config_f.inc | sed '1d;s%^/\* \(.*\) \*/%\1%;s/#define /#define H5_/;s/#undef /#undef H5_/' >fortran/src/H5config_f.inc.tmp; sed -i 's\_TMP\\g' fortran/src/H5config_f.inc.tmp; mv -f fortran/src/H5config_f.inc.tmp fortran/src/H5config_f.inc]) [cat fortran/src/H5config_f.inc | sed '1d;s%^/\* \(.*\) \*/%\1%;s/#define /#define H5_/;s/#undef /#undef H5_/' >fortran/src/H5config_f.inc.tmp; sed -i 's\_TMP\\g' fortran/src/H5config_f.inc.tmp; mv -f fortran/src/H5config_f.inc.tmp fortran/src/H5config_f.inc])

4
fortran/test/tH5T_F03.F90
View File

@ -1090,10 +1090,8 @@ END SUBROUTINE test_array_compound_atomic
CALL check("H5Dcreate_f",error, total_error) CALL check("H5Dcreate_f",error, total_error)
CALL H5Dcreate_f(file_id, dsetnamer8, h5kind_to_type(real_kind_15,H5_REAL_KIND), dspace_id, dset_idr8, error) CALL H5Dcreate_f(file_id, dsetnamer8, h5kind_to_type(real_kind_15,H5_REAL_KIND), dspace_id, dset_idr8, error)
CALL check("H5Dcreate_f",error, total_error) CALL check("H5Dcreate_f",error, total_error)
!#ifdef H5_HAVE_FLOAT128
CALL H5Dcreate_f(file_id, dsetnamer16, h5kind_to_type(real_kind_31,H5_REAL_KIND), dspace_id, dset_idr16, error) CALL H5Dcreate_f(file_id, dsetnamer16, h5kind_to_type(real_kind_31,H5_REAL_KIND), dspace_id, dset_idr16, error)
CALL check("H5Dcreate_f",error, total_error) CALL check("H5Dcreate_f",error, total_error)
!#endif
! !
! Write the dataset. ! Write the dataset.
! !
@ -1123,11 +1121,9 @@ END SUBROUTINE test_array_compound_atomic
f_ptr = C_LOC(dset_data_r15(1)) f_ptr = C_LOC(dset_data_r15(1))
CALL h5dwrite_f(dset_idr8, h5kind_to_type(real_kind_15,H5_REAL_KIND), f_ptr, error) CALL h5dwrite_f(dset_idr8, h5kind_to_type(real_kind_15,H5_REAL_KIND), f_ptr, error)
CALL check("H5Dwrite_f",error, total_error) CALL check("H5Dwrite_f",error, total_error)
!#ifdef H5_HAVE_FLOAT128
f_ptr = C_LOC(dset_data_r31(1)) f_ptr = C_LOC(dset_data_r31(1))
CALL h5dwrite_f(dset_idr16, h5kind_to_type(real_kind_31,H5_REAL_KIND), f_ptr, error) CALL h5dwrite_f(dset_idr16, h5kind_to_type(real_kind_31,H5_REAL_KIND), f_ptr, error)
CALL check("H5Dwrite_f",error, total_error) CALL check("H5Dwrite_f",error, total_error)
!#endif
! !
! Close the file ! Close the file
! !

38
m4/aclocal_fc.m4
View File

@ -528,37 +528,39 @@ FCFLAGS=$saved_FCFLAGS
AC_LANG_POP([Fortran]) AC_LANG_POP([Fortran])
]) ])
dnl Check for the maximum decimal precision for C
dnl
dnl Depends on if __float128 and/or quadmath.h exist. We only support 128-bit
dnl floats that work like GNU's quadmath.h __float128 type, which have the
dnl precision stored in a symbol named FLT128_DIG.
dnl
dnl The MY_(LDBL|FLT128)_DIG variables are from configure.ac
dnl
AC_DEFUN([PAC_FC_LDBL_DIG],[ AC_DEFUN([PAC_FC_LDBL_DIG],[
AC_MSG_CHECKING([maximum decimal precision for C])
AC_LANG_CONFTEST([ AC_LANG_CONFTEST([
AC_LANG_PROGRAM([ AC_LANG_PROGRAM([
#include <float.h> #include <float.h>
#include <stdio.h> #include <stdio.h>
#define CHECK_FLOAT128 $ac_cv_sizeof___float128 #if $HAVE___FLOAT128 != 0
#if CHECK_FLOAT128!=0 # if $INCLUDE_QUADMATH_H != 0
# if $HAVE_QUADMATH!=0 # include <quadmath.h>
#include <quadmath.h> # endif
# endif # ifdef FLT128_DIG
# ifdef FLT128_DIG # define C_FLT128_DIG FLT128_DIG
#define C_FLT128_DIG FLT128_DIG # else
# else # define C_FLT128_DIG 0
#define C_FLT128_DIG 0 # endif
# endif
#else #else
#define C_FLT128_DIG 0 # define C_FLT128_DIG 0
#endif #endif
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
#define C_LDBL_DIG DECIMAL_DIG #define C_LDBL_DIG DECIMAL_DIG
#else
#define C_LDBL_DIG LDBL_DIG
#endif
],[[ ],[[
fprintf(stderr, "%d\n%d\n", C_LDBL_DIG, C_FLT128_DIG); fprintf(stderr, "%d\n%d\n", C_LDBL_DIG, C_FLT128_DIG);
]]) ]])
]) ])
AC_RUN_IFELSE([],[ AC_RUN_IFELSE([],[
LDBL_DIG=$(./conftest$EXEEXT 2>&1 | sed -n '1p') MY_LDBL_DIG=$(./conftest$EXEEXT 2>&1 | sed -n '1p')
FLT128_DIG=$(./conftest$EXEEXT 2>&1 | sed -n '2p') MY_FLT128_DIG=$(./conftest$EXEEXT 2>&1 | sed -n '2p')
],[ ],[
AC_MSG_ERROR([C program fails to build or run!]) AC_MSG_ERROR([C program fails to build or run!])
],[]) ],[])