dnl -*- shell-script -*- dnl dnl Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana dnl University Research and Technology dnl Corporation. All rights reserved. dnl Copyright (c) 2004-2005 The University of Tennessee and The University dnl of Tennessee Research Foundation. All rights dnl reserved. dnl Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, dnl University of Stuttgart. All rights reserved. dnl Copyright (c) 2004-2005 The Regents of the University of California. dnl All rights reserved. dnl Copyright (c) 2011-2012 Cisco Systems, Inc. All rights reserved. dnl $COPYRIGHT$ dnl dnl Additional copyrights may follow dnl dnl $HEADER$ dnl # OMPI_FORTRAN_CHECK(Fortran type, c type required, types to search, # expected size, define ompi_fortran__t or not)) #---------------------------------------------------------- # Check Fortran type, including: # - whether compiler supports or not # - size of type # - equal to expected size # - alignment # - associated C type # # types to search is a comma-seperated list of values AC_DEFUN([OMPI_FORTRAN_CHECK], [ OPAL_VAR_SCOPE_PUSH([ofc_have_type ofc_type_size ofc_type_alignment ofc_c_type ofc_expected_size]) ofc_expected_size=$4 ofc_define_type=$5 ofc_have_type=0 ofc_type_size=$ac_cv_sizeof_int ofc_type_alignment=$ac_cv_sizeof_int ofc_c_type=ompi_fortran_bogus_type_t ofc_type_kind=0 # Only check if we actually want the Fortran bindings / have a # Fortran compiler. This allows us to call this macro, even if # there is no Fortran compiler. If we have no Fortran compiler, # then just set a bunch of defaults. if test $OMPI_WANT_FORTRAN_BINDINGS -eq 1; then OMPI_FORTRAN_CHECK_TYPE([$1], [ofc_have_type=1], [ofc_have_type=0]) else AC_MSG_CHECKING([if Fortran compiler supports $1]) AC_MSG_RESULT([skipped]) fi if test "$ofc_have_type" = "1"; then # What is the size of this type? # NOTE: Some Fortran compilers actually will return that a # type exists even if it doesn't support it -- the compiler # will automatically convert the unsupported type to a type # that it *does* support. For example, if you try to use # INTEGER*16 and the compiler doesn't support it, it may well # automatically convert it to INTEGER*8 for you (!). So we # have to check the actual size of the type once we determine # that the compiler doesn't error if we try to use it # (i.e,. the compiler *might* support that type). If the size # doesn't match the expected size, then the compiler doesn't # really support it. OMPI_FORTRAN_GET_SIZEOF([], [$1], [ofc_type_size]) if test "$ofc_expected_size" != "-1" -a "$ofc_type_size" != "$ofc_expected_size"; then AC_MSG_WARN([*** Fortran $1 does not have expected size!]) AC_MSG_WARN([*** Expected $ofc_expected_size, got $ofc_type_size]) AC_MSG_WARN([*** Disabling MPI support for Fortran $1]) ofc_have_type=0 else # Look for a corresponding C type (will abort by itself if the # type isn't found and we need it) ofc_c_type= m4_ifval([$3], [OMPI_FIND_TYPE([$1], [$3], [$2], [$ofc_type_size], [ofc_c_type]) if test -z "$ofc_c_type" ; then ofc_have_type=0 fi]) # Get the alignment of the type if test "$ofc_have_type" = "1"; then OMPI_FORTRAN_GET_ALIGNMENT([$1], [ofc_type_alignment]) # Add it to the relevant list of types found if test "$ofc_expected_size" != "-1"; then ofc_letter=m4_translit(m4_bpatsubst($1, [^\(.\).+], [[\1]]), [a-z], [A-Z]) ofc_str="OMPI_FORTRAN_${ofc_letter}KINDS=\"\$OMPI_FORTRAN_${ofc_letter}KINDS $ofc_type_size \"" eval $ofc_str fi fi # Get the kind of the type. We do this by looking at the # Fortran type's corresponding C type (which we figured # out above). Then we look a the official BIND(C) KIND # type for that type. The official BIND(C) types were # taken from table 15.2 of the Fortran 2008 standard, # published on 6 October as ISO/IEC 1539-1:2010 (this is # not a free document). A copy of this table is in the # file ompi/mpi/fortran/c_to_integer_kind_mapping.pdf. # NOTE: Some of the values of these C_* constants *may be # negative* if the compiler doesn't support them. We have # already verified that both the Fortran and the C types # both exist. However, the compiler may still have -1 for # the C_ constants if the C type is not the same # format as its corresponding Fortran type (e.g., Absoft's # "REAL*16" and "long double" are the same size, but not # the same format -- so the compiler is allowed to define # C_LONG_DOUBLE to -1). AC_MSG_CHECKING([for corresponding KIND value of $1]) case "$ofc_c_type" in char) ofc_type_kind=C_SIGNED_CHAR ;; double) ofc_type_kind=C_DOUBLE ;; float) ofc_type_kind=C_FLOAT ;; int) ofc_type_kind=C_INT ;; int16_t) ofc_type_kind=C_INT16_T ;; int32_t) ofc_type_kind=C_INT32_T ;; int64_t) ofc_type_kind=C_INT64_T ;; int8_t) ofc_type_kind=C_INT8_T ;; long) ofc_type_kind=C_LONG ;; long*double) ofc_type_kind=C_LONG_DOUBLE ;; long*long) ofc_type_kind=C_LONG_LONG ;; short) ofc_type_kind=C_SHORT ;; float*_Complex) ofc_type_kind=C_FLOAT_COMPLEX ;; double*_Complex) ofc_type_kind=C_DOUBLE_COMPLEX ;; long*double*_Complex) ofc_type_kind=C_LONG_DOUBLE_COMPLEX ;; *) # Skip types like "DOUBLE PRECISION" ;; esac AS_IF([test "$ofc_type_kind" != ""], [AC_MSG_RESULT([$ofc_type_kind])], [AC_MSG_RESULT([])]) # See if the value is -1. If so, then just say we don't # have a match. OMPI_FORTRAN_GET_KIND_VALUE([$ofc_type_kind], [ofc_type_kind_value]) AS_IF([test $ofc_type_kind_value -le 0], [ofc_have_type=0 AC_MSG_WARN([Compiler $1 and $ofc_c_type mismatch; MPI datatype unsupported])]) fi fi # We always need these defines -- even if we don't have a given # type, there are some places in the code where we have to have # *something*. Note that the bpatsubst's are the same as used # above (see comment above), but we added a translit to make them # uppercase. # If we got a pretty name, use that as the basis. If not, use the # first part of the provided fortran type (e.g., # "logical(selected_int_kind(2))" -> logical1") # Finally, note that it is necessary to use the Big Long Ugly m4 # expressions in the AC_DEFINE_UNQUOTEDs. If you don't (e.g., put # the result of the BLUm4E in a shell variable and use that in # AC_DEFINE_UNQUOTED), autoheader won't put them in the # AC_CONFIG_HEADER (or AM_CONFIG_HEADER, in our case). AC_DEFINE_UNQUOTED([OMPI_HAVE_FORTRAN_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]), [$ofc_have_type], [Whether we have Fortran $1 or not]) AC_DEFINE_UNQUOTED([OMPI_SIZEOF_FORTRAN_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]), [$ofc_type_size], [Size of Fortran $1]) AC_DEFINE_UNQUOTED([OMPI_ALIGNMENT_FORTRAN_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]), [$ofc_type_alignment], [Alignment of Fortran $1]) AC_DEFINE_UNQUOTED([OMPI_KIND_FORTRAN_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]), [$ofc_type_kind], [Fortrn KIND number for $1]) if test "$3" != "" -a "$ofc_define_type" = "yes"; then AC_DEFINE_UNQUOTED([ompi_fortran_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [A-Z], [a-z])[_t], [$ofc_c_type], [C type corresponding to Fortran $1]) fi # Save some in shell variables for later use (e.g., need # OMPI_SIZEOF_FORTRAN_INTEGER in OMPI_FORTRAN_GET_HANDLE_MAX) [OMPI_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])[_C_TYPE=$ofc_c_type] [OMPI_KIND_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])[=$ofc_type_kind] [OMPI_HAVE_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])[=$ofc_have_type] [OMPI_SIZEOF_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])[=$ofc_type_size] [OMPI_ALIGNMENT_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])[=$ofc_type_alignment] # Wow, this is sick. But it works! :-) AC_SUBST([OMPI_HAVE_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])) AC_SUBST([OMPI_KIND_FORTRAN_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z])) AC_SUBST([OMPI_SIZEOF_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])) AC_SUBST([OMPI_SIZEOF_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])) AC_SUBST([OMPI_ALIGNMENT_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])) # Clean up OPAL_VAR_SCOPE_POP ])dnl