-dnl ----------------------------------------------------
-dnl Platform specific autoconf tests
-dnl
-dnl This is part of the input for the ./configure script of
-dnl the deal.II libraries. All options and paths are stored in
-dnl the file common/Make.global_options.
-dnl
-dnl In doc/Makefile some information on the kind of documentation
-dnl is stored.
-dnl
-dnl
-dnl Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 by the deal.II authors
-dnl
-dnl $Id$
-
-
-
-dnl -------------------------------------------------------------
-dnl Helper macros to add libpaths to LIBS
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_ADD_EXTERNAL_LIBS_AT_TAIL, dnl
-[
- LIBS="$LIBS $1"
-])
-AC_DEFUN(DEAL_II_ADD_EXTERNAL_LIBS_AT_FRONT, dnl
-[
- LIBS="$1 $LIBS"
-])
-AC_DEFUN(DEAL_II_EXTERNAL_LIBS_SAVE_VAL, dnl Not reentrant, of course
-[
- OLD_LIBS="$LIBS"
-])
-AC_DEFUN(DEAL_II_EXTERNAL_LIBS_RESTORE_VAL, dnl
-[
- LIBS="$OLD_LIBS"
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl Like AC_PATH_PROG, but do not discard arguments given to the
-dnl program. In other words, while
-dnl AC_PATH_PROG(CXX, [g++ -pg])
-dnl results in CXX=/usr/bin/g++, the result of the current
-dnl macro would be CXX="/usr/bin/g++ -pg".
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_PATH_PROG, dnl
-[
- dnl First get at the name and arguments of the program in $2. Do
- dnl so by having a loop over all components of $2 and putting the
- dnl components either into $testprog or into $testargs
- testprog=""
- testargs=""
- processingargs="no"
- for i in $2 ; do
- if test "$processingargs" = "no" ; then
- testprog="$i" ;
- processingargs="yes" ;
- else
- testargs="$testargs $i" ;
- fi
- done
-
- AC_PATH_PROG([$1],[$testprog])
- eval "$1=\"${$1} $testargs\""
-])
-
-
-
dnl -------------------------------------------------------------
dnl Determine the C++ compiler in use. Return the name and possibly
dnl version of this compiler in GXX_VERSION.
-dnl -------------------------------------------------------------
-dnl See whether the compiler we have has MPI built in (e.g. if it
-dnl is actually mpiCC, etc)
-dnl
-dnl Usage: DEAL_II_DETERMINE_IF_SUPPORTS_MPI
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_DETERMINE_IF_SUPPORTS_MPI, dnl
-[
- AC_MSG_CHECKING(if the compiler is built for MPI)
- AC_TRY_LINK(
- [
- #include <mpi.h>
- ],
- [
- MPI_Init (0,0);
- ],
- [
- AC_MSG_RESULT(yes)
- AC_DEFINE(DEAL_II_COMPILER_SUPPORTS_MPI, 1,
- [Defined if the compiler supports including <mpi.h>])
-
- DEAL_II_COMPILER_SUPPORTS_MPI=1
- DEAL_II_USE_MPI=yes
- ],
- [
- AC_MSG_RESULT(no)
- ])
-])
-
-
-
-
-
dnl -------------------------------------------------------------
dnl Set C++ compiler flags to their default values. They will be
dnl modified according to other options in later steps of
-dnl -------------------------------------------------------------
-dnl See if the compiler understands the attribute to mark functions
-dnl as deprecated.
-dnl
-dnl Usage: DEAL_II_CHECK_DEPRECATED
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_DEPRECATED, dnl
-[
- AC_MSG_CHECKING(whether compiler has attributes to deprecate functions)
-
-
- OLD_CXXFLAGS="$CXXFLAGS"
- CXXFLAGS=""
-
- dnl First see if the following compiles without error (it should
- dnl produce a warning but we don't care about this
- AC_TRY_COMPILE(
- [
- int old_fn () __attribute__((deprecated));
- int old_fn ();
- int (*fn_ptr)() = old_fn;
- ],
- [;],
- [
- test1=yes
- ],
- [
- test1=no
- ])
-
- dnl Now try this again with -Werror. It should now fail
- CXXFLAGS=-Werror
- AC_TRY_COMPILE(
- [
- int old_fn () __attribute__((deprecated));
- int old_fn ();
- int (*fn_ptr)() = old_fn;
- ],
- [;],
- [
- test2=yes
- ],
- [
- test2=no
- ])
- CXXFLAGS="${OLD_CXXFLAGS}"
-
- if test "$test1$test2" = "yesno" ; then
- AC_MSG_RESULT(yes)
- AC_DEFINE(DEAL_II_DEPRECATED, [__attribute__((deprecated))],
- [If the compiler supports this, then this variable is
- defined to a string that when written after a function
- name makes the compiler emit a warning whenever this
- function is used somewhere that its use is deprecated.])
- else
- AC_MSG_RESULT(no)
- AC_DEFINE(DEAL_II_DEPRECATED, [],
- [If the compiler supports this, then this variable is
- defined to a string that when written after a function
- name makes the compiler emit a warning whenever this
- function is used somewhere that its use is deprecated.])
- fi
-])
-
-
-
dnl -------------------------------------------------------------
dnl Determine the C compiler in use. Return the name and possibly
dnl version of this compiler in CC_VERSION. This function is almost
-dnl -------------------------------------------------------------
-dnl Check whether the compiler allows for vectorization and that
-dnl vectorization actually works. For this test, we use compiler
-dnl intrinsics similar to what is used in the deal.II library and
-dnl check whether the arithmetic operations are correctly performed
-dnl on examples where all numbers are exactly represented as
-dnl floating point numbers.
-dnl
-dnl Usage: DEAL_II_COMPILER_VECTORIZATION_LEVEL
-dnl 0 means no vectorization, 1 support for SSE2, 2 support for AVX
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_DETECT_VECTORIZATION_LEVEL, dnl
-[
- AC_LANG(C++)
- CXXFLAGS="$CXXFLAGSG"
- dnl SSE2 check in debug mode
- AC_MSG_CHECKING(whether CPU supports SSE2)
- AC_TRY_RUN(
- [
-#include <emmintrin.h>
-#include <mm_malloc.h>
- int main()
- {
- __m128d a, b;
- const unsigned int vector_bytes = sizeof(__m128d);
- const int n_vectors = vector_bytes/sizeof(double);
- __m128d * data =
- reinterpret_cast<__m128d*>(_mm_malloc (2*vector_bytes, vector_bytes));
- double * ptr = reinterpret_cast<double*>(&a);
- ptr[0] = (volatile double)(1.0);
- for (int i=1; i<n_vectors; ++i)
- ptr[i] = 0.0;
- b = _mm_set1_pd ((volatile double)(2.25));
- data[0] = _mm_add_pd (a, b);
- data[1] = _mm_mul_pd (b, data[0]);
- ptr = reinterpret_cast<double*>(&data[1]);
- unsigned int return_value = 0;
- if (ptr[0] != 7.3125)
- return_value = 1;
- for (int i=1; i<n_vectors; ++i)
- if (ptr[i] != 5.0625)
- return_value = 1;
- _mm_free (data);
- return return_value;
- }
- ],
- [
- AC_MSG_RESULT(yes)
- dnl AVX check in debug mode
- AC_MSG_CHECKING(whether CPU supports AVX)
- AC_TRY_RUN(
- [
-#include <immintrin.h>
-#include <mm_malloc.h>
- int main()
- {
- __m256d a, b;
- const unsigned int vector_bytes = sizeof(__m256d);
- const int n_vectors = vector_bytes/sizeof(double);
- __m256d * data =
- reinterpret_cast<__m256d*>(_mm_malloc (2*vector_bytes, vector_bytes));
- double * ptr = reinterpret_cast<double*>(&a);
- ptr[0] = (volatile double)(1.0);
- for (int i=1; i<n_vectors; ++i)
- ptr[i] = 0.0;
- b = _mm256_set1_pd ((volatile double)(2.25));
- data[0] = _mm256_add_pd (a, b);
- data[1] = _mm256_mul_pd (b, data[0]);
- ptr = reinterpret_cast<double*>(&data[1]);
- unsigned int return_value = 0;
- if (ptr[0] != 7.3125)
- return_value = 1;
- for (int i=1; i<n_vectors; ++i)
- if (ptr[i] != 5.0625)
- return_value = 1;
- _mm_free (data);
- }
- ],
- [
- AC_MSG_RESULT(yes)
- AC_DEFINE(DEAL_II_COMPILER_VECTORIZATION_LEVEL, 2,
- [Equal to 0 in the generic case,
- equal to 1 if CPU compiled for supports SSE2,
- equal to 2 if CPU compiled for supports AVX])
- ],
- [
- AC_MSG_RESULT(no)
- AC_DEFINE(DEAL_II_COMPILER_VECTORIZATION_LEVEL, 1,
- [Equal to 0 in the generic case,
- equal to 1 if CPU compiled for supports SSE2,
- equal to 2 if CPU compiled for supports AVX])
- ])
- ],
- [
- AC_DEFINE(DEAL_II_COMPILER_VECTORIZATION_LEVEL, 0,
- [Equal to 0 in the generic case,
- equal to 1 if CPU compiled for supports SSE2,
- equal to 2 if CPU compiled for supports AVX])
- AC_MSG_RESULT(no)
- ])
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl Check whether the compiler allows to use arithmetic operations
-dnl +-*/ on vectorized data types or whether we need to use
-dnl _mm_add_pd for addition and so on. +-*/ is preferred because
-dnl it allows the compiler to choose other optimizations like
-dnl fused multiply add, whereas _mm_add_pd explicitly enforces the
-dnl assembler command.
-dnl
-dnl Usage: DEAL_II_COMPILER_USE_VECTOR_ARITHMETICS
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_VECTOR_ARITHMETICS, dnl
-
-[
- AC_MSG_CHECKING(whether compiler supports vector arithmetics)
- AC_LANG(C++)
- CXXFLAGS="$CXXFLAGSG"
- AC_TRY_COMPILE(
- [
-#include <emmintrin.h>
- ],
- [
- __m128d a, b;
- a = _mm_set_sd (1.0);
- b = _mm_set1_pd (2.1);
- __m128d c = a + b;
- __m128d d = b - c;
- __m128d e = c * a + d;
- __m128d f = e/a;
- (void)f;
- ],
- [
- AC_MSG_RESULT(yes)
- AC_DEFINE(DEAL_II_COMPILER_USE_VECTOR_ARITHMETICS, 1,
- [Defined if the compiler can use arithmetic operations on
- vectorized data types])
- ],
- [
- AC_MSG_RESULT(no)
- ])
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl In some cases, -threads (or whatever else command line option)
-dnl switches on some preprocessor flags. If this is not the case,
-dnl then define them explicitely.
-dnl
-dnl Usage: DEAL_II_THREAD_CPPFLAGS
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_THREAD_CPPFLAGS, dnl
-[
- AC_MSG_CHECKING(for platform specific multi-threading defines)
- AC_LANG(C++)
- CXXFLAGS="$CXXFLAGSG"
- AC_TRY_COMPILE(
- [
-# if !defined (_REENTRANT) && !defined (_THREAD_SAFE)
-# error Neither _REENTRANT nor _THREAD_SAFE were defined.
- nonsense
-# endif
- ],
- [
- ;
- ],
- [
- AC_MSG_RESULT(not necessary)
- ],
- [
- AC_MSG_RESULT(-D_REENTRANT -D_THREAD_SAFE)
- CXXFLAGSG="$CXXFLAGSG -D_REENTRANT -D_THREAD_SAFE"
- CXXFLAGSO="$CXXFLAGSO -D_REENTRANT -D_THREAD_SAFE"
- ])
-])
-
-
-
-
-dnl -------------------------------------------------------------
-dnl Versions of gcc on different platforms use a multitude of flags to
-dnl denote thread safe libraries and the like. They are, for example
-dnl -threads/-pthread/-mthread, sometimes *thread, sometimes *threads.
-dnl On some other platforms, such as Mac OS X, no flags are necessary
-dnl and none are understood by the compiler.
-dnl
-dnl Find out which flag the right one on the present platform
-dnl
-dnl Usage: DEAL_II_FIND_THREAD_FLAGS
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_GET_THREAD_FLAGS, dnl
-[
- case "$target" in
- *apple-darwin*)
- dnl Mac OS X is special in that the compiler generates thread-safe
- dnl code by default, apparently.
- ;;
-
- *)
- dnl Everything else needs the following setup:
- AC_MSG_CHECKING(for platform specific thread flags)
- AC_LANG(C++)
- for i in threads mt pthread pthreads mthreads Kthread kthread invalid_last_entry; do
- CXXFLAGS="$CXXFLAGSG -$i"
- DEAL_II_TRY_COMPILER_FLAG(
- [
- thread_flag="$i"
- CXXFLAGSG="$CXXFLAGSG -$i"
- CXXFLAGSO="$CXXFLAGSO -$i"
- LDFLAGS="$LDFLAGS -$i"
-
- dnl The right parameter was found, so exit
- break
- ])
- done
-
- if test "$thread_flag" = invalid_last_entry ; then
- AC_MSG_RESULT(no flag found!)
- AC_MSG_ERROR(Could not determine multithreading flag for this platform. Aborting!)
- fi
- AC_MSG_RESULT(-$thread_flag)
- ;;
- esac
-])
-
-
dnl -------------------------------------------------------------
dnl On some systems, notably AIX and SUN Solaris, using threads
-dnl -------------------------------------------------------------
-dnl Try whether the set of compiler flags in CXXFLAGS is reasonable, i.e.
-dnl does not result in compiler messages (which are then produced by
-dnl unknown or unrecognized compiler flags. This macro is mostly copied
-dnl from the definition of AC_TRY_COMPILE, but the first two arguments are
-dnl omitted and some other things are also simplified.
-dnl
-dnl Usage:
-dnl DEAL_II_TRY_COMPILER_FLAG([ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_TRY_COMPILER_FLAG, dnl
-[
- echo 'int main() { return 0; }' > conftest.$ac_ext
-
- dnl lets see whether the compiler generates output to stdout or stderr
- deal_II_compiler_output=`eval $ac_compile 2>&1`
- if test ! "$deal_II_compiler_output"; then
- ifelse([$1], , :,
- [
- rm -rf conftest*
- $1
- ])
- else
- echo "configure: failed program was:" >&AC_FD_CC
- cat conftest.$ac_ext >&AC_FD_CC
- ifelse([$2], , ,
- [
- rm -rf conftest*
- $2
- ])
- fi
- rm -f conftest*
-])
-
-
-
dnl -------------------------------------------------------------
dnl On SunOS 4.x, the `getrusage' function exists, but is not declared
dnl in the respective header file `resource.h', as one would think when
-
-dnl -------------------------------------------------------------
-dnl Check if the declared prototype of abort() has a throw()
-dnl specification. We overload abort() in our testsuite, so have
-dnl to make sure that we match the exception specification
-dnl correctly.
-dnl
-dnl Usage: DEAL_II_CHECK_ABORT
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_ABORT, dnl
-[
- AC_MSG_CHECKING([for exception specifications on abort()])
- AC_LANG(C++)
- CXXFLAGS="-Werror $CXXFLAGSG"
- AC_TRY_COMPILE(
- [
-#include <cstdlib>
-extern "C" void abort () { for(;;) ; }
- ],
- [
- ],
- [
- AC_MSG_RESULT(none)
- ],
- [
- AC_MSG_RESULT(yes)
- AC_DEFINE(DEAL_II_ABORT_NOTHROW_EXCEPTION, 1,
- [Defined if the prototype of abort() has a no-throw
- exception specification.])
- ])
-]
-)
-
-
-
-
-dnl -------------------------------------------------------------
-dnl We'd like to use the `isnan' function. On some systems, this is
-dnl simply declared in <math.h> (or <cmath>, for what it's worth), but
-dnl on Linux for example, it is only declared if we specifically require
-dnl support for ISO C 99. This macro checks whether `isnan' is declared
-dnl or whether we have to pass special compiler flags, namely
-dnl -D_ISOC99_SOURCE (Linux) or -D__EXTENSIONS__ (Sun). Note that when
-dnl checking we have to use the two sets of compiler flags.
-dnl
-dnl Usage: DEAL_II_CHECK_ISNAN
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_ISNAN, dnl
-[
- DEAL_II_CHECK_ISNAN_FLAG(debug, $CXXFLAGSG,
- CXXFLAGSG="$deal_II_isnan_flag $CXXFLAGSG")
- DEAL_II_CHECK_ISNAN_FLAG(optimized, $CXXFLAGSO,
- CXXFLAGSO="$deal_II_isnan_flag $CXXFLAGSO")
-]
-)
-
-
-
-dnl -------------------------------------------------------------
-dnl The following function actually performs the check for the right flag
-dnl for `isnan'. If a flag is found, the third argument is executed, and
-dnl the right flag is available in $deal_II_isnan_flag.
-dnl
-dnl Usage: DEAL_II_CHECK_ISNAN_FLAG("description of options set",
-dnl "compiler options set",
-dnl action when flag is found)
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_ISNAN_FLAG, dnl
-[
- AC_MSG_CHECKING(whether isnan is declared with $1 flags)
- AC_LANG(C++)
- CXXFLAGS="$2"
- deal_II_isnan_flag=""
- AC_TRY_COMPILE(
- [
-#include <cmath>
- ],
- [
- double d=0;
- isnan (d);
- ],
- [
- AC_MSG_RESULT(yes)
- deal_II_isnan_flag="-DHAVE_ISNAN"
- $3
- ])
-
-
- if test "x$deal_II_isnan_flag" = "x" ; then
- dnl Simply using isnan doesn't work. On Microsoft Windows systems, the
- dnl function is called _isnan, so check that
- AC_TRY_COMPILE(
- [
-#include <cmath>
- ],
- [
- double d=0;
- _isnan (d);
- ],
- [
- AC_MSG_RESULT(yes)
- deal_II_isnan_flag="-DHAVE_UNDERSCORE_ISNAN"
- $3
- ])
- fi
-
-
- dnl Let's see whether we _now_ have found something
- if test "x$deal_II_isnan_flag" = "x" ; then
- dnl We need to define something. Unfortunately, this is system
- dnl dependent (argh!)
- deal_II_isnan_flag=""
- for testflag in -D_ISOC99_SOURCE -D__EXTENSIONS__ ; do
- CXXFLAGS="$2 $testflag"
- AC_TRY_COMPILE(
- [
-#include <cmath>
- ],
- [
- double d=0;
- isnan (d);
- ],
- [
- dnl We found a flag by which isnan is defined; store
- dnl this flag and exit the loop
- deal_II_isnan_flag="-DHAVE_ISNAN $testflag"
- break;
- ])
-
- dnl If that didn't work (and it didn't as we are still inside the
- dnl loop), then try the _isnan function (maybe we are on a
- dnl Microsoft Windows system)
- AC_TRY_COMPILE(
- [
-#include <cmath>
- ],
- [
- double d=0;
- _isnan (d);
- ],
- [
- dnl We found a flag by which isnan is defined; store
- dnl this flag and exit the loop
- deal_II_isnan_flag="-DHAVE_UNDERSCORE_ISNAN $testflag"
- break;
- ])
- done
-
- dnl if no such flag was found, then abort ./configure since
- dnl the library will not be compilable on this platform
- dnl without knowledge of the right flag
- if test "x$deal_II_isnan_flag" = "x" ; then
- AC_MSG_RESULT(no.)
- else
- dnl we found something, lets us it
- AC_MSG_RESULT(using $testflag)
- $3
- fi
- fi
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl See if the isfinite function is available in namespace std
-dnl (this function is C99 and therefore not part of C++98, but
-dnl some implementations provide it nevertheless).
-dnl
-dnl Usage: DEAL_II_CHECK_ISFINITE
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_ISFINITE, dnl
-[
- AC_MSG_CHECKING(for std::isfinite)
- AC_LANG(C++)
- CXXFLAGS="$CXXFLAGSG"
- AC_TRY_COMPILE(
- [
-#include <cmath>
- ],
- [
- double d=0;
- std::isfinite (d);
- ],
- [
- AC_MSG_RESULT(yes)
- AC_DEFINE(DEAL_II_HAVE_ISFINITE, 1,
- [Defined if std::isfinite is available])
- ],
- [
- AC_MSG_RESULT(no)
- ])
-])
-
-
-
-
-
-dnl -------------------------------------------------------------
-dnl rand_r is defined for some compiler flag combinations, but not for
-dnl others. check that. note that since these are C++ flags, we can't
-dnl just use AC_CHECK_FUNCS
-dnl
-dnl Usage: DEAL_II_CHECK_RAND_R
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_RAND_R, dnl
-[
- AC_MSG_CHECKING(for rand_r)
- AC_LANG(C++)
- CXXFLAGS="$CXXFLAGSG"
- AC_TRY_COMPILE(
- [
-#include <cstdlib>
- ],
- [
-unsigned int seed = 0;
-int i=rand_r(&i);
- ],
- [
- AC_MSG_RESULT(yes)
- AC_DEFINE(HAVE_RAND_R, 1,
- [Define if you have the rand_r function])
- ],
- [
- AC_MSG_RESULT(no)
- ]
- )
-])
-
-
-
dnl -------------------------------------------------------------
dnl On some systems (well, DEC Alphas are the only ones we know of),
dnl gcc2.95 throws the hands in the air if it sees one of the AssertThrow
AC_MSG_RESULT(yes)
],
[
- AC_MSG_RESULT(no)
- $3
- ])
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl Gcc and some other compilers have __PRETTY_FUNCTION__, showing
-dnl an unmangled version of the function we are presently in,
-dnl while __FUNCTION__ (or __func__ in ISO C99) simply give the
-dnl function name which would not include the arguments of that
-dnl function, leading to problems in C++ with overloaded function
-dnl names.
-dnl
-dnl If __PRETTY_FUNCTION__ is not available, try to find out whether
-dnl __func__ is available and use the preprocessor to set the first
-dnl thing to the second. If this is also not the case, then set it
-dnl to something indicating non-availability.
-dnl
-dnl Usage: DEAL_II_HAVE_PRETTY_FUNCTION
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_HAVE_PRETTY_FUNCTION, dnl
-[
- AC_MSG_CHECKING(for __PRETTY_FUNCTION__)
- AC_LANG(C++)
- CXXFLAGS="$CXXFLAGSG"
- AC_TRY_COMPILE(
- [
-# include <iostream>
- ],
- [
- std::cout << __PRETTY_FUNCTION__ << std::endl;
- ],
- [
- AC_MSG_RESULT(yes)
- ],
- [
- AC_MSG_RESULT(no)
- AC_MSG_CHECKING(for __func__)
- AC_TRY_COMPILE(
- [
-# include <iostream>
- ],
- [
- std::cout << __func__ << std::endl;
- ],
- [
- AC_MSG_RESULT(yes)
- x=__func__
- ],
- [
- AC_MSG_RESULT(no)
- x="\"(not available)\""
- ])
- AC_DEFINE_UNQUOTED(__PRETTY_FUNCTION__, $x,
- [If already available, do not define at all. Otherwise, define
- to __func__ if that is available. In all other cases,
- indicate that no information about the present function
- is available for this compiler.])
+ AC_MSG_RESULT(no)
+ $3
])
])
-dnl -------------------------------------------------------------
-dnl Check for boost option and find pre-installed boost
-dnl -------------------------------------------------------------
-
-AC_DEFUN(DEAL_II_CHECK_BOOST, dnl
-[
- AC_ARG_WITH(boost,
- [AS_HELP_STRING([--with-boost=/path/to/boost],
- [Use an installed boost library instead of the contributed one. The optional argument points to the directory containing the boost subdirectory for header files.])],
- DEAL_II_WITH_BOOST($withval))
-
- CPPFLAGS="$BOOST_INCLUDE_DIR $CPPFLAGS"
- LDFLAGS="$BOOST_LIB_DIR $LDFLAGS"
-
- AC_CHECK_HEADER(boost/shared_ptr.hpp,,
- [AC_MSG_ERROR([Your boost installation is incomplete!])])
- AC_CHECK_HEADER(boost/type_traits.hpp,,
- [AC_MSG_ERROR([Your boost installation is incomplete!])])
- AC_CHECK_HEADER(boost/tuple/tuple.hpp,,
- [AC_MSG_ERROR([Your boost installation is incomplete!])])
- DEAL_II_CHECK_BOOST_SHARED_PTR_ASSIGNMENT
-])
-
dnl -------------------------------------------------------------
dnl The boost::shared_ptr class has a templated assignment operator
dnl but no assignment operator matching the default operator
-
-dnl -------------------------------------------------------------
-dnl Check for existence of the __builtin_expect facility of newer
-dnl gcc compilers. This can be used to hint the compiler's branch
-dnl prediction unit in some cases. We use it in the AssertThrow
-dnl macros.
-dnl
-dnl Annoyingly, the Portland Group compiler compiles code with
-dnl __builtin_expect just fine, but then doesn't want to link it,
-dnl saying it doesn't know this function. So simply not test for
-dnl __builtin_expect with that compiler, and to be extrasure make
-dnl sure we're doing the right thing also link .
-dnl
-dnl Usage: DEAL_II_HAVE_BUILTIN_EXPECT
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_HAVE_BUILTIN_EXPECT, dnl
-[
- if test ! "x$GXX_BRAND" = "PortlandGroup" ; then
- AC_MSG_CHECKING(for __builtin_expect)
- AC_LANG(C++)
- CXXFLAGS="$CXXFLAGSG"
- AC_TRY_LINK(
- [
- bool f() {}
- ],
- [
- if (__builtin_expect(f(),false));
- ],
- [
- AC_MSG_RESULT(yes)
- AC_DEFINE(HAVE_BUILTIN_EXPECT, 1,
- [Define if the compiler provides __builtin_expect])
- ],
- [
- AC_MSG_RESULT(no)
- ])
- fi
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl Newer versions of gcc have a very nice feature: you can set
-dnl a verbose terminate handler, that not only aborts a program
-dnl when an exception is thrown and not caught somewhere, but
-dnl before aborting it prints that an exception has been thrown,
-dnl and possibly what the std::exception::what() function has to
-dnl say. Since many people run into the trap of not having a
-dnl catch clause in main(), they wonder where that abort may be
-dnl coming from. The terminate handler then at least says what is
-dnl missing in their program.
-dnl
-dnl This test checks whether this feature is available.
-dnl
-dnl Usage: DEAL_II_HAVE_VERBOSE_TERMINATE
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_HAVE_VERBOSE_TERMINATE, dnl
-[
- AC_MSG_CHECKING(for __verbose_terminate_handler)
- AC_LANG(C++)
- CXXFLAGS="$CXXFLAGSG"
- AC_TRY_LINK(
- [
-#include <exception>
-
-namespace __gnu_cxx
-{
- extern void __verbose_terminate_handler ();
-}
-
-struct preload_terminate_dummy
-{
- preload_terminate_dummy()
- { std::set_terminate (__gnu_cxx::__verbose_terminate_handler); }
-};
-
-static preload_terminate_dummy dummy;
- ],
- [
- throw 1;
- ],
- [
- AC_MSG_RESULT(yes)
- AC_DEFINE(HAVE_VERBOSE_TERMINATE, 1,
- [Define if the compiler provides __verbose_terminate_handler])
- ],
- [
- AC_MSG_RESULT(no)
- ])
-])
-
-
-
-
-
-
dnl -------------------------------------------------------------
dnl gcc versions up to 2.95.3 had a problem with the std::advance function,
dnl when the number of steps forward was given by an unsigned number, since
-dnl -------------------------------------------------------------
-dnl
-dnl Usage: DEAL_II_CHECK_MIN_VECTOR_CAPACITY
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_MIN_VECTOR_CAPACITY, dnl
-[
- AC_LANG(C++)
- CXXFLAGS="$CXXFLAGSG -Werror"
-
- AC_MSG_CHECKING(for minimal std::vector<T> capacity)
- AC_TRY_RUN(
- [
-#include <vector>
-int main () {
- std::vector<int> v(1);
- v.reserve (1);
- v.resize (1);
- return v.capacity();
-}
- ],
- [
- dnl That's impossible: the return value can't be zero!
- AC_MSG_ERROR(impossible result -- aborting)
- ],
- [
- result="$?"
- AC_MSG_RESULT($result)
- AC_DEFINE_UNQUOTED(DEAL_II_MIN_VECTOR_CAPACITY, $result,
- [Set to the minimal number of elements a std::vector<T> can
- always hold, i.e. its minimal capacity.])
- ]
- )
-
- dnl Do same thing with std::vector<bool>
- AC_MSG_CHECKING(for minimal std::vector<bool> capacity)
- AC_TRY_RUN(
- [
-#include <vector>
-int main () {
- std::vector<bool> v(1);
- v.reserve (1);
- v.resize (1);
- return v.capacity();
-}
- ],
- [
- dnl That's impossible: the return value can't be zero!
- AC_MSG_ERROR(impossible result -- aborting)
- ],
- [
- result="$?"
- AC_MSG_RESULT($result)
- AC_DEFINE_UNQUOTED(DEAL_II_MIN_BOOL_VECTOR_CAPACITY, $result,
- [Set to the minimal number of elements a std::vector<bool> can
- always hold, i.e. its minimal capacity.])
- ]
- )
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl Check whether glibc-like stacktrace information is available
-dnl for the Exception class. If it is, then try to also determine
-dnl whether the compiler accepts the -rdynamic flag, since that is
-dnl recommended for linking if one wants to have meaningful
-dnl backtraces.
-dnl
-dnl Usage: DEAL_II_HAVE_GLIBC_STACKTRACE
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_HAVE_GLIBC_STACKTRACE, dnl
-[
- AC_MSG_CHECKING(for glibc-like stacktrace information)
- AC_LANG(C++)
- CXXFLAGS="$CXXFLAGSG"
- AC_TRY_COMPILE(
- [
-#include <execinfo.h>
-#include <stdlib.h>
- ],
- [
- void * array[25];
- int nSize = backtrace(array, 25);
- char ** symbols = backtrace_symbols(array, nSize);
- free(symbols);
- ],
- [
- AC_MSG_RESULT(yes)
- AC_DEFINE(HAVE_GLIBC_STACKTRACE, 1,
- [Define if deal.II is linked against a libc that
- provides stacktrace debug information that can be
- printed out in the exception class])
-
- dnl On Mac OS X, -rdynamic is accepted by the compiler (i.e.
- dnl it doesn't produce an error) but we always get a warning
- dnl that it isn't supported. That's pretty stupid because
- dnl we can't test for it. Consequently, only run the test
- dnl if not on OS X.
- case "$target" in
- *apple-darwin*)
- ;;
-
- *)
- AC_MSG_CHECKING(whether compiler accepts -rdynamic)
-
- CXXFLAGS="$CXXFLAGSG -rdynamic"
- AC_TRY_LINK(
- [],
- [;],
- [
- AC_MSG_RESULT(yes)
- LDFLAGS="$LDFLAGS -rdynamic"
- ],
- [
- AC_MSG_RESULT(no)
- ])
- ;;
- esac
- ],
- [
- AC_MSG_RESULT(no)
- ])
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl Check whether the compiler offers a way to demangle symbols
-dnl from within the program. Used inside the exception stacktrace
-dnl mechanism.
-dnl
-dnl The example code is taken from
-dnl http://gcc.gnu.org/onlinedocs/libstdc++/18_support/howto.html#6
-dnl
-dnl Usage: DEAL_II_HAVE_DEMANGLER
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_HAVE_DEMANGLER, dnl
-[
- AC_MSG_CHECKING(for libstdc++ demangler)
- AC_LANG(C++)
- CXXFLAGS="$CXXFLAGSG"
- AC_TRY_LINK(
- [
-#include <exception>
-#include <iostream>
-#include <cxxabi.h>
-#include <cstdlib>
-
-struct empty { };
-
-template <typename T, int N>
- struct bar { };
- ],
- [
- int status;
- char *realname;
-
- // exception classes not in <stdexcept>, thrown by the implementation
- // instead of the user
- std::bad_exception e;
- realname = abi::__cxa_demangle(e.what(), 0, 0, &status);
- std::cout << e.what() << "\t=> " << realname << "\t: " << status << '\n';
- free(realname);
-
-
- // typeid
- bar<empty,17> u;
- const std::type_info &ti = typeid(u);
-
- realname = abi::__cxa_demangle(ti.name(), 0, 0, &status);
- std::cout << ti.name() << "\t=> " << realname << "\t: " << status << '\n';
- free(realname);
-
- return 0;
- ],
- [
- AC_MSG_RESULT(yes)
- AC_DEFINE(HAVE_LIBSTDCXX_DEMANGLER, 1,
- [Define if the std c++ library provides a demangler conforming
- to the GCC libstdc++ interface.])
- ],
- [
- AC_MSG_RESULT(no)
- ])
-])
-
dnl -------------------------------------------------------------
dnl On some Cygwin systems, a system header file includes this
-dnl -------------------------------------------------------------
-dnl Check whether NetCDF is installed. If so we will be able to read
-dnl from and write to NetCDF binary or ascii files.
-dnl
-dnl The NetCDF installation directory (including the lib and include
-dnl directory) is given to the --with-netcdf configure option or to
-dnl the NETCDF_DIR environment variable
-dnl
-dnl Usage: DEAL_II_CONFIGURE_NETCDF
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CONFIGURE_NETCDF, dnl
-[
- AC_ARG_WITH(netcdf,
- [AS_HELP_STRING([--with-netcdf=/path/to/netcdf],
- [Specify the path to the NetCDF installation, of which the include and library directories are subdirs; use this if you want to override the NETCDF_DIR environment variable.])],
- [
- DEAL_II_NETCDF_DIR="$withval"
- ],
- [
- dnl Take something from the environment variables, if it is there
- if test "x$NETCDF_DIR" != "x" ; then
- DEAL_II_NETCDF_DIR="$NETCDF_DIR"
- else
- DEAL_II_NETCDF_DIR=""
- fi
- ])
-
- AC_ARG_WITH(netcdf-include,
- [AS_HELP_STRING([--with-netcdf-include=/path/to/netcdf],
- [Specify the path to the NetCDF headers file; use this if you want to override the NETCDF_INCLUDE_DIR environment variable.])],
- [
- NETCDF_INCLUDE_DIR="$withval"
- ])
-
- AC_ARG_WITH(netcdf-libs,
- [AS_HELP_STRING([--with-netcdf-libs=/path/to/netcdf],
- [Specify the path to the NetCDF libraries; use this if you want to override the NETCDF_LIBDIR environment variable.])],
- [
- NETCDF_LIBDIR="$withval"
- ])
-
-
- if test "x$DEAL_II_NETCDF_DIR" != "x" ; then
- if test "x$NETCDF_INCLUDE_DIR" != "x" ; then
- CPPFLAGS="-I$NETCDF_INCLUDE_DIR $CPPFLAGS"
- CXXFLAGS="-I$NETCDF_INCLUDE_DIR $CXXFLAGS"
- else
- CPPFLAGS="-I$DEAL_II_NETCDF_DIR/include $CPPFLAGS"
- CXXFLAGS="-I$DEAL_II_NETCDF_DIR/include $CXXFLAGS"
- fi
- if test "x$NETCDF_LIBDIR" != "x" ; then
- LDFLAGS="$LDFLAGS -L$NETCDF_LIBDIR"
- else
- LDFLAGS="-L$DEAL_II_NETCDF_DIR/lib $LDFLAGS"
- if test "$LD_PATH_OPTION" != "no" ; then
- LDFLAGS="$LD_PATH_OPTION$DEAL_II_NETCDF_DIR/lib $LDFLAGS"
- fi
- fi
- else
- if test "x$NETCDF_INCLUDE_DIR" != "x" ; then
- CPPFLAGS="-I$NETCDF_INCLUDE_DIR $CPPFLAGS"
- CXXFLAGS="-I$NETCDF_INCLUDE_DIR $CXXFLAGS"
- fi
- if test "x$NETCDF_LIBDIR" != "x" ; then
- LDFLAGS="$LDFLAGS -L$NETCDF_LIBDIR"
- fi
- fi
-
- dnl Check for header, if found check for C library,
- dnl if found check for C++ library,
- dnl if successful, HAVE_LIBNETCDF will be set
- AC_CHECK_HEADER(netcdfcpp.h)
-
- AC_CHECK_LIB(netcdf, nc_open,
- [ DEAL_II_EXTERNAL_LIBS_SAVE_VAL()
- DEAL_II_ADD_EXTERNAL_LIBS_AT_FRONT(-lnetcdf_c++ -lnetcdf)
- AC_MSG_CHECKING([for NcFile::NcFile in -lnetcdf_c++])
- AC_LINK_IFELSE(
- [ AC_LANG_PROGRAM([[#include <netcdfcpp.h>
- ]],
- [[NcFile test("test")]])
- ],
- [ AC_MSG_RESULT(yes)
- AC_DEFINE(HAVE_LIBNETCDF,1,[Define to 1 if you have the `NetCDF' library (-lnetcdf).])
- ],
- [ AC_MSG_RESULT(no)
- DEAL_II_EXTERNAL_LIBS_RESTORE_VAL()
- ])
- ])
-
-])
-
-
-
dnl ------------------------------------------------------------
dnl Check whether PETSc is installed, and if so store the
dnl respective links
CXXFLAGS="${OLD_CXXFLAGS}"
])
-dnl ===========================================================================
-dnl http://www.gnu.org/software/autoconf-archive/ax_lib_hdf5.html
-dnl ===========================================================================
-dnl
-dnl SYNOPSIS
-dnl
-dnl AX_LIB_HDF5([serial/parallel])
-dnl
-dnl DESCRIPTION
-dnl
-dnl This macro provides tests of the availability of HDF5 library.
-dnl
-dnl The optional macro argument should be either 'serial' or 'parallel'. The
-dnl former only looks for serial HDF5 installations via h5cc. The latter
-dnl only looks for parallel HDF5 installations via h5pcc. If the optional
-dnl argument is omitted, serial installations will be preferred over
-dnl parallel ones.
-dnl
-dnl The macro adds a --with-hdf5 option accepting one of three values:
-dnl
-dnl no - do not check for the HDF5 library.
-dnl yes - do check for HDF5 library in standard locations.
-dnl path - complete path to where lib/libhdf5* libraries and
-dnl include/H5* include files reside.
-dnl
-dnl If HDF5 is successfully found, this macro calls
-dnl
-dnl AC_SUBST(DEAL_II_HDF5_VERSION)
-dnl AC_SUBST(DEAL_II_HDF5_CFLAGS)
-dnl AC_SUBST(DEAL_II_HDF5_CPPFLAGS)
-dnl AC_SUBST(DEAL_II_HDF5_LDFLAGS)
-dnl AC_SUBST(DEAL_II_HDF5_INCDIR)
-dnl AC_DEFINE(DEAL_II_HAVE_HDF5)
-dnl
-dnl and sets with_hdf5="yes".
-dnl
-dnl If HDF5 is disabled or not found, this macros sets with_hdf5="no".
-dnl
-dnl Your configuration script can test $with_hdf to take any further
-dnl actions. HDF5_{C,CPP,LD}FLAGS may be used when building with C or C++.
-dnl
-dnl LICENSE
-dnl
-dnl Copyright (c) 2009 Timothy Brown <tbrown@freeshell.org>
-dnl Copyright (c) 2010 Rhys Ulerich <rhys.ulerich@gmail.com>
-dnl
-dnl Copying and distribution of this file, with or without modification, are
-dnl permitted in any medium without royalty provided the copyright notice
-dnl and this notice are preserved. This file is offered as-is, without any
-dnl warranty.
-
-AC_DEFUN(DEAL_II_CONFIGURE_HDF5, dnl
-[
-
-AC_REQUIRE([AC_PROG_SED])
-AC_REQUIRE([AC_PROG_AWK])
-AC_REQUIRE([AC_PROG_GREP])
-
-dnl Add a default --with-hdf5 configuration option.
-AC_ARG_WITH([hdf5],
- AS_HELP_STRING(
- [--with-hdf5=[yes/no/PATH]],
- m4_case(m4_normalize([$1]),
- [serial], [location of h5cc for serial HDF5 configuration],
- [parallel], [location of h5pcc for parallel HDF5 configuration],
- [location of h5cc or h5pcc for HDF5 configuration])
- ),
- [if test "$withval" = "no"; then
- with_hdf5="no"
- elif test "$withval" = "yes"; then
- with_hdf5="yes"
- warn_if_cannot_find_hdf5="yes"
- elif test -z "$withval"; then
- with_hdf5="yes"
- H5CC="$withval"
- else
- warn_if_cannot_find_hdf5="yes"
- with_hdf5="yes"
- H5CC="$withval"
- fi],
- [with_hdf5="yes"]
-)
-
-dnl Set defaults to blank
-USE_CONTRIB_HDF5=no
-DEAL_II_HDF5_VERSION=""
-DEAL_II_HDF5_CFLAGS=""
-DEAL_II_HDF5_CPPFLAGS=""
-DEAL_II_HDF5_LDFLAGS=""
-DEAL_II_HDF5_INCDIR=""
-
-dnl Try and find hdf5 compiler tools and options.
-if test "$with_hdf5" = "yes"; then
- if test -z "$H5CC"; then
- dnl Check to see if H5CC is in the path.
- AC_PATH_PROGS(
- [H5CC],
- m4_case(m4_normalize([$1]),
- [serial], [h5cc],
- [parallel], [h5pcc],
- [h5cc h5pcc]),
- [])
- else
- AC_MSG_CHECKING([Using provided HDF5 C wrapper])
- AC_MSG_RESULT([$H5CC])
- fi
- AC_MSG_CHECKING([for HDF5 libraries])
- if test ! -x "$H5CC"; then
- AC_MSG_RESULT([no])
- if test "$warn_if_cannot_find_hdf5" = "yes"; then
- AC_MSG_WARN(m4_case(m4_normalize([$1]),
- [serial], [
-Unable to locate serial HDF5 compilation helper script 'h5cc'.
-Please specify --with-hdf5=<LOCATION> as the full path to h5cc.
-HDF5 support is being disabled (equivalent to --with-hdf5=no).
-], [parallel],[
-Unable to locate parallel HDF5 compilation helper script 'h5pcc'.
-Please specify --with-hdf5=<LOCATION> as the full path to h5pcc.
-HDF5 support is being disabled (equivalent to --with-hdf5=no).
-], [
-Unable to locate HDF5 compilation helper scripts 'h5cc' or 'h5pcc'.
-Please specify --with-hdf5=<LOCATION> as the full path to h5cc or h5pcc.
-HDF5 support is being disabled (equivalent to --with-hdf5=no).
-]))
- fi
- with_hdf5="no"
- else
- dnl h5cc provides both AM_ and non-AM_ options
- dnl depending on how it was compiled either one of
- dnl these are empty. Lets roll them both into one.
-
- dnl Look for "HDF5 Version: X.Y.Z"
- DEAL_II_HDF5_VERSION=$(eval $H5CC -showconfig | grep 'HDF5 Version:' \
- | $AWK '{print $[]3}')
-
-dnl A ideal situation would be where everything we needed was
-dnl in the AM_* variables. However most systems are not like this
-dnl and seem to have the values in the non-AM variables.
-dnl
-dnl We try the following to find the flags:
-dnl (1) Look for "NAME:" tags
-dnl (2) Look for "NAME/H5_NAME:" tags
-dnl (3) Look for "AM_NAME:" tags
-dnl
- dnl (1)
- dnl Look for "CFLAGS: "
- DEAL_II_HDF5_CFLAGS=$(eval $H5CC -showconfig | grep '\bCFLAGS:' \
- | $AWK -F: '{print $[]2}')
- dnl Look for "CPPFLAGS"
- DEAL_II_HDF5_CPPFLAGS=$(eval $H5CC -showconfig | grep '\bCPPFLAGS:' \
- | $AWK -F: '{print $[]2}')
- dnl Look for "LD_FLAGS"
- DEAL_II_HDF5_LDFLAGS=$(eval $H5CC -showconfig | grep '\bLDFLAGS:' \
- | $AWK -F: '{print $[]2}')
-
- dnl (2)
- dnl CFLAGS/H5_CFLAGS: .../....
- dnl We could use $SED with something like the following
- dnl 's/CFLAGS.*\/H5_CFLAGS.*[:]\(.*\)\/\(.*\)/\1/p'
- if test -z "$DEAL_II_HDF5_CFLAGS"; then
- DEAL_II_HDF5_CFLAGS=$(eval $H5CC -showconfig \
- | $SED -n 's/CFLAGS.*[:]\(.*\)\/\(.*\)/\1/p')
- fi
- dnl Look for "CPPFLAGS"
- if test -z "$DEAL_II_HDF5_CPPFLAGS"; then
- DEAL_II_HDF5_CPPFLAGS=$(eval $H5CC -showconfig \
- | $SED -n 's/CPPFLAGS.*[:]\(.*\)\/\(.*\)/\1/p')
- fi
- dnl Look for "LD_FLAGS"
- if test -z "$DEAL_II_HDF5_LDFLAGS"; then
- DEAL_II_HDF5_LDFLAGS=$(eval $H5CC -showconfig \
- | $SED -n 's/LDFLAGS.*[:]\(.*\)\/\(.*\)/\1/p')
- fi
-
- dnl (3)
- dnl Check to see if these are not empty strings. If so
- dnl find the AM_ versions and use them.
- if test -z "$DEAL_II_HDF5_CFLAGS"; then
- DEAL_II_HDF5_CFLAGS=$(eval $H5CC -showconfig \
- | grep '\bAM_CFLAGS:' | $AWK -F: '{print $[]2}')
- fi
- if test -z "$DEAL_II_HDF5_CPPFLAGS"; then
- DEAL_II_HDF5_CPPFLAGS=$(eval $H5CC -showconfig \
- | grep '\bAM_CPPFLAGS:' | $AWK -F: '{print $[]2}')
- fi
- if test -z "$DEAL_II_HDF5_LDFLAGS"; then
- DEAL_II_HDF5_LDFLAGS=$(eval $H5CC -showconfig \
- | grep '\bAM_LDFLAGS:' | $AWK -F: '{print $[]2}')
- fi
-
- dnl Frustratingly, the necessary -Idir,-Ldir still may not be found!
- dnl Attempt to pry any more required include directories from wrapper.
- for arg in `$H5CC -c -show`
- do
- case "$arg" in #(
- -I*) echo $DEAL_II_HDF5_CPPFLAGS | $GREP -e "$arg" 2>&1 >/dev/null \
- || DEAL_II_HDF5_CPPFLAGS="$arg $DEAL_II_HDF5_CPPFLAGS"
- ;;
- esac
- done
- for arg in `$H5CC -show`
- do
- case "$arg" in #(
- -L*) echo $DEAL_II_HDF5_LDFLAGS | $GREP -e "$arg" 2>&1 >/dev/null \
- || DEAL_II_HDF5_LDFLAGS="$arg $DEAL_II_HDF5_LDFLAGS"
- ;;
- esac
- done
-
- AC_MSG_RESULT([yes (version $[DEAL_II_HDF5_VERSION])])
-
- dnl Look for any extra libraries also needed to link properly
- EXTRA_LIBS=$(eval $H5CC -showconfig | grep 'Extra libraries:'\
- | $AWK -F: '{print $[]2}')
-
- dnl Look for HDF5's high level library
- ax_lib_hdf5_save_LDFLAGS=$LDFLAGS
- ax_lib_hdf5_save_LIBS=$LIBS
- LDFLAGS=$DEAL_II_HDF5_LDFLAGS
- AC_HAVE_LIBRARY([hdf5_hl],
- [DEAL_II_HDF5_LDFLAGS="$DEAL_II_HDF5_LDFLAGS -lhdf5_hl"],
- [],
- [-lhdf5 $EXTRA_LIBS])
- LIBS=$ax_lib_hdf5_save_LIBS
- LDFLAGS=$ax_lib_hdf5_save_LDFLAGS
-
- dnl Add the HDF5 library itself
- DEAL_II_HDF5_LDFLAGS="$DEAL_II_HDF5_LDFLAGS -lhdf5"
-
- dnl Add any EXTRA_LIBS afterwards
- if test "$EXTRA_LIBS"; then
- DEAL_II_HDF5_LDFLAGS="$DEAL_II_HDF5_LDFLAGS $EXTRA_LIBS"
- fi
-
- dnl remove "-I" from cpp flags to get include path
- DEAL_II_HDF5_INCDIR=$(eval echo $DEAL_II_HDF5_CPPFLAGS | cut -c 3-)
-
- LDFLAGS="$LDFLAGS $DEAL_II_HDF5_LDFLAGS"
- USE_CONTRIB_HDF5=yes
- AC_DEFINE([DEAL_II_HAVE_HDF5], [1], [Defined if you have HDF5 support])
- fi
-fi
-])
-
-
])
-dnl --------------------------------------------------
-dnl Make sure we can link with blas. If something was
-dnl given as an argument to --with-blas=xxx, then use
-dnl that library, otherwise use 'blas' as library name.
-dnl
-dnl On Mac OS X, first try something different. OS X has
-dnl the concept of a 'framework', which is something like
-dnl a collection of libraries. One links with a framework
-dnl using '-framework name' on the linker line. On OS X
-dnl 10.3, there is a framework called 'vecLib', later
-dnl versions have 'Accelerate', both of which include
-dnl both the standard blas and cblas libraries. So if no
-dnl name is given to --with-blas, and we are on Mac OS X,
-dnl try first to link with the Accelerate framework, and
-dnl if that fails with the vecLib framework. Only if
-dnl that too fails, fall back to the usual rules.
-dnl
-dnl For more information on frameworks, see here:
-dnl http://www.macresearch.org/performance_tutorial_part_i_introducing_accelerate
-dnl http://www.macresearch.org/using_the_accelerate_framework
-dnl --------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_BLAS_FRAMEWORK, dnl
-[
- dnl No argument to --with-blas has been given.
- dnl Try the special arguments for Mac OS X if
- dnl we are on that sort of system
- if (echo $target | grep apple-darwin > /dev/null) ; then
- OLD_LDFLAGS="$LDFLAGS"
-
- dnl Try to use -framework Accelerate
- AC_MSG_CHECKING(-framework Accelerate)
- LDFLAGS="$OLD_LDFLAGS -framework Accelerate"
- AC_LINK_IFELSE(
- [ AC_LANG_PROGRAM([[extern "C" void daxpy(int,double,double*,int,double*,int);]],
- [[daxpy(0,0.,0,0,0,0);]])
- ],
- [
- AC_MSG_RESULT(yes)
- framework_works=yes
- ],
- [
- AC_MSG_RESULT(no)
- ])
-
- dnl If that didn't work, try to use -framework vecLib
- if test "x$framework_works" != "xyes"; then
- AC_MSG_CHECKING(-framework vecLib)
- LDFLAGS="$OLD_LDFLAGS -framework vecLib"
- AC_LINK_IFELSE(
- [ AC_LANG_PROGRAM([[extern "C" void daxpy(int,double,double*,int,double*,int);]],
- [[daxpy(0,0.,0,0,0,0);]])
- ],
- [
- AC_MSG_RESULT(yes)
- framework_works=yes
- ],
- [
- AC_MSG_RESULT(no)
- ])
- fi
-
- dnl If none of the above worked, revert LDFLAGS to their previous
- dnl values
- if test "x$framework_works" != "xyes"; then
- LDFLAGS="$OLD_LDFLAGS"
- fi
- fi
-])
-
-
-
-
dnl ------------------------------------------------------------
dnl Check whether P4EST is to be used to parallelize meshes
dnl
+++ /dev/null
-dnl -------------------------------------------------------------
-dnl Determine the C++ compiler in use. Return the name and possibly
-dnl version of this compiler in GXX_VERSION.
-dnl
-dnl Usage: DEAL_II_DETERMINE_CXX_BRAND
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_DETERMINE_CXX_BRAND, dnl
-[
- dnl It used to be the case that AC_PROG_CXX could properly detect
- dnl whether we are working with gcc or not, but then Intel came across
- dnl the brilliant idea to disguise it's compiler as gcc by setting
- dnl GCC preprocessor variables for versions etc. So we have to figure
- dnl out again whether this is really gcc
- if test "$GXX" = "yes" ; then
- GXX_VERSION_STRING=`($CXX -v 2>&1) | grep "gcc version"`
- if test "x$GXX_VERSION_STRING" = "x" ; then
- GXX=no
- fi
- fi
-
- dnl And because it is so convenient, the PathScale compiler also identifies
- dnl itself as GCC...
- if test "$GXX" = "yes" ; then
- GXX_VERSION_STRING=`($CXX -v 2>&1) | grep "PathScale"`
- if test "x$GXX_VERSION_STRING" != "x" ; then
- GXX=no
- fi
- fi
-
- dnl Then icc came along and started to identify itself as
- dnl icpc version 12.1.0 (gcc version 4.2.1 compatibility)
- dnl which also doesn't help...
- if test "$GXX" = "yes" ; then
- GXX_VERSION_STRING=`($CXX -v 2>&1) | grep "icpc"`
- if test "x$GXX_VERSION_STRING" != "x" ; then
- GXX=no
- fi
- fi
-
- if test "$GXX" = yes ; then
- dnl find out the right version
- GXX_VERSION_STRING=`($CXX -v 2>&1) | grep "gcc version"`
-
- full_version=`echo "$GXX_VERSION_STRING" | perl -pi -e 's/.*version (\d\.\d\.\d).*/\1/g;'`
- GXX_BRAND=GNU
- GXX_VERSION=gcc`echo $full_version | perl -pi -e 's/(\d\.\d).*/\1/g;'`
- GXX_VERSION_DETAILED=gcc$full_version
-
- AC_MSG_RESULT([C++ compiler is $GXX_VERSION (subversion $GXX_VERSION_DETAILED)])
-
-
- else
- dnl Check other (non-gcc) compilers
-
- dnl Check for IBM xlC. For some reasons, depending on some environment
- dnl variables, moon position, and other reasons unknown to me, the
- dnl compiler displays different names in the first line of output, so
- dnl check various possibilities
- is_ibm_xlc="`($CXX -qversion 2>&1) | grep IBM`"
- if test "x$is_ibm_xlc" != "x" ; then
- dnl Ah, this is IBM's C++ compiler. Unfortunately, we don't presently
- dnl know how to check the version number, so assume that is sufficiently
- dnl high...
- AC_MSG_RESULT(C++ compiler is IBM xlC)
- GXX_BRAND=IBM
- GXX_VERSION=ibm_xlc
- GXX_VERSION_DETAILED="$GXX_VERSION"
- else
-
- dnl Check whether we are dealing with the MIPSpro C++ compiler
- mips_pro="`($CXX -version 2>&1) | grep MIPSpro`"
- if test "x$mips_pro" != "x" ; then
- GXX_BRAND=MIPSpro
- case "$mips_pro" in
- *7.0* | *7.1* | *7.2* | *7.3*)
- dnl MIPSpro 7.3 does not support standard C++, therefore it is not
- dnl able to compile deal.II. Previous compiler versions neither.
- AC_MSG_RESULT(C++ compiler is $mips_pro)
- AC_MSG_ERROR(This compiler is not supported)
- GXX_VERSION=MIPSpro7.3
- GXX_VERSION_DETAILED="$GXX_VERSION"
- ;;
- *7.4)
- AC_MSG_RESULT(C++ compiler is MIPSpro compiler 7.4)
- AC_MSG_ERROR(This compiler is not supported. Use MIPSPro compiler 7.4x)
- GXX_VERSION=MIPSpro7.4
- GXX_VERSION_DETAILED="$GXX_VERSION"
- ;;
- *7.41* | *7.42* | *7.43* | *7.44*)
- AC_MSG_RESULT(C++ compiler is MIPSpro compiler 7.4x)
- GXX_VERSION=MIPSpro7.4x
- GXX_VERSION_DETAILED="$GXX_VERSION"
- ;;
- *"7.5"*)
- AC_MSG_RESULT(C++ compiler is MIPSpro compiler 7.5)
- GXX_VERSION=MIPSpro7.5
- GXX_VERSION_DETAILED="$GXX_VERSION"
- ;;
- *)
- AC_MSG_RESULT(C++ compiler is unknown version but accepted MIPSpro compiler version)
- GXX_VERSION=MIPSpro-other
- GXX_VERSION_DETAILED="$GXX_VERSION"
- ;;
- esac
- else
-
- dnl Intel's ICC C++ compiler? On Linux, it uses -V, on Windows
- dnl it is -help
- is_intel_icc1="`($CXX -V 2>&1) | grep 'Intel'`"
- is_intel_icc2="`($CXX -help 2>&1) | grep 'Intel'`"
- is_intel_icc="$is_intel_icc1$is_intel_icc2"
-
- dnl When calling the Portland Group compiler, it also
- dnl outputs the string 'Intel' in its help text, so make
- dnl sure we're not confused
- is_pgi="`($CXX -V 2>&1) | grep 'Portland'`"
-
- if test "x$is_intel_icc" != "x" -a "x$is_pgi" = "x" ; then
- GXX_BRAND=Intel
- version_string="`($CXX -V 2>&1) | grep 'Version'` `($CXX -help 2>&1) | grep 'Version'`"
- version5="`echo $version_string | grep 'Version 5'`"
- version6="`echo $version_string | grep 'Version 6'`"
- version7="`echo $version_string | grep 'Version 7'`"
- version8="`echo $version_string | grep 'Version 8'`"
- version9="`echo $version_string | grep 'Version 9'`"
- version10="`echo $version_string | grep 'Version 10'`"
- version11="`echo $version_string | grep 'Version 11'`"
- if test "x$version5" != "x" ; then
- AC_MSG_RESULT(C++ compiler is icc-5)
- GXX_VERSION=intel_icc5
- else if test "x$version6" != "x" ; then
- AC_MSG_RESULT(C++ compiler is icc-6)
- GXX_VERSION=intel_icc6
- else if test "x$version7" != "x" ; then
- AC_MSG_RESULT(C++ compiler is icc-7)
- GXX_VERSION=intel_icc7
- else if test "x$version8" != "x" ; then
- AC_MSG_RESULT(C++ compiler is icc-8)
- GXX_VERSION=intel_icc8
- else if test "x$version9" != "x" ; then
- AC_MSG_RESULT(C++ compiler is icc-9)
- GXX_VERSION=intel_icc9
- else if test "x$version10" != "x" ; then
- AC_MSG_RESULT(C++ compiler is icc-10)
- GXX_VERSION=intel_icc10
- else if test "x$version11" != "x" ; then
- AC_MSG_RESULT(C++ compiler is icc-11)
- GXX_VERSION=intel_icc11
- else if test "x$version12" != "x" ; then
- AC_MSG_RESULT(C++ compiler is icc-12)
- GXX_VERSION=intel_icc12
- else
- AC_MSG_RESULT(C++ compiler is icc)
- GXX_VERSION=intel_icc
- fi fi fi fi fi fi fi fi
- GXX_VERSION_DETAILED="$GXX_VERSION"
- else
-
- dnl Or DEC's cxx compiler?
- is_dec_cxx="`($CXX -V 2>&1) | grep 'Compaq C++'`"
- if test "x$is_dec_cxx" != "x" ; then
- AC_MSG_RESULT(C++ compiler is Compaq-cxx)
- GXX_BRAND=Compaq
- GXX_VERSION=compaq_cxx
- GXX_VERSION_DETAILED="$GXX_VERSION"
- else
-
- dnl Sun Workshop/Studio?
- is_sun_cc_1="`($CXX -V 2>&1) | grep 'Sun WorkShop'`"
- is_sun_cc_2="`($CXX -V 2>&1) | grep 'Sun C++'`"
- if test "x$is_sun_cc_1$is_sun_cc_2" != "x" ; then
- AC_MSG_RESULT(C++ compiler is Sun Workshop compiler)
- GXX_BRAND=SunWorkshop
- GXX_VERSION=sun_workshop
- GXX_VERSION_DETAILED="$GXX_VERSION"
- else
-
- dnl Sun Forte?
- is_sun_forte_cc="`($CXX -V 2>&1) | grep 'Forte'`"
- if test "x$is_sun_forte_cc" != "x" ; then
- AC_MSG_RESULT(C++ compiler is Sun Forte compiler)
- GXX_BRAND=SunForte
- GXX_VERSION=sun_forte
- GXX_VERSION_DETAILED="$GXX_VERSION"
- else
-
- dnl Portland Group C++?
- is_pgcc="`($CXX -V 2>&1) | grep 'Portland Group'`"
- if test "x$is_pgcc" != "x" ; then
- GXX_VERSION_STRING=`($CXX -V 2>&1) | grep "^pgCC"`
- full_version=`echo "$GXX_VERSION_STRING" | perl -pi -e 's/.*pgCC\s+(\S+).*/\1/g;'`
- GXX_BRAND=PortlandGroup
- GXX_VERSION=pgCC`echo $full_version | perl -pi -e 's/(\d\.\d).*/\1/g;'`
- GXX_VERSION_DETAILED=pgCC"$full_version"
- AC_MSG_RESULT(C++ compiler is Portland Group C++ $full_version)
- else
-
- dnl HP aCC?
- is_aCC="`($CXX -V 2>&1) | grep 'aCC'`"
- if test "x$is_aCC" != "x" ; then
- AC_MSG_RESULT(C++ compiler is HP aCC)
- GXX_BRAND=HP
- GXX_VERSION=hp_aCC
- GXX_VERSION_DETAILED="$GXX_VERSION"
- else
-
- dnl Borland C++
- is_bcc="`($CXX -h 2>&1) | grep 'Borland'`"
- if test "x$is_bcc" != "x" ; then
- AC_MSG_RESULT(C++ compiler is Borland C++)
- GXX_BRAND=Borland
- GXX_VERSION=borland_bcc
- GXX_VERSION_DETAILED="$GXX_VERSION"
- else
-
- dnl KAI C++? It seems as if the documented options
- dnl -V and --version are not always supported, so give
- dnl the whole thing a second try by looking for /KCC/
- dnl somewhere in the paths that are output by -v. This
- dnl is risky business, since this combination of
- dnl characters might appear on other installations
- dnl of other compilers as well, so put this test to
- dnl the very end of the detection chain for the
- dnl various compilers
- is_kai_cc="`($CXX --version 2>&1) | grep 'KAI C++'`"
- is_kai_cc="$is_kai_cc`($CXX -v 2>&1) | grep /KCC/`"
- if test "x$is_kai_cc" != "x" ; then
- AC_MSG_RESULT(C++ compiler is KAI C++)
- GXX_BRAND=KAI
- GXX_VERSION=kai_cc
- GXX_VERSION_DETAILED="$GXX_VERSION"
- else
-
- dnl Maybe PathScale's compiler?
- is_pathscale="`($CXX -v 2>&1) | grep PathScale`"
- if test "x$is_pathscale" != "x" ; then
- AC_MSG_RESULT(C++ compiler is PathScale C++)
- GXX_BRAND=PathScale
- GXX_VERSION=pathscale_cc
- GXX_VERSION_DETAILED="$GXX_VERSION"
- else
-
- dnl Maybe CLang?
- is_clang="`($CXX --version 2>&1) | grep clang`"
- if test "x$is_clang" != x ; then
- AC_MSG_RESULT(C++ compiler is clang)
- GXX_BRAND=clang
- GXX_VERSION=clang
- GXX_VERSION_DETAILED="$GXX_VERSION"
- else
-
- dnl Maybe Cray C++?
- is_cray="`($CXX -V 2>&1) | grep Cray`"
- if test "x$is_cray" != x ; then
- AC_MSG_RESULT(C++ compiler is Cray C++)
- GXX_BRAND=cray
- GXX_VERSION=cray
- GXX_VERSION_DETAILED="$GXX_VERSION"
- else
-
- dnl Aw, nothing suitable found...
- AC_MSG_RESULT(Unrecognized C++ compiler -- Try to go ahead and get help from dealii@dealii.org)
- GXX_BRAND=Unknown
- GXX_VERSION=unknown_cc
- GXX_VERSION_DETAILED="$GXX_VERSION"
- fi
- fi
- fi
- fi
- fi
- fi
- fi
- fi
- fi
- fi
- fi
- fi
- fi
- fi
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl Set C++ compiler flags to their default values. They will be
-dnl modified according to other options in later steps of
-dnl configuration
-dnl
-dnl CXXFLAGSO : flags for optimized mode
-dnl CXXFLAGSG : flags for debug mode
-dnl CXXFLAGSPIC: flags for generation of object files that are suitable
-dnl for shared libs
-dnl LDFLAGSPIC : flags needed for linking of object files to shared
-dnl libraries
-dnl
-dnl Usage: DEAL_II_SET_CXX_FLAGS
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_SET_CXX_FLAGS, dnl
-[
- dnl If CXXFLAGSG or CXXFLAGSO are not set, then initialize them with
- dnl CXXFLAGS
- if test "x$CXXFLAGSG" = "x" ; then
- CXXFLAGSG="$CXXFLAGS" ;
- fi
-
- if test "x$CXXFLAGSO" = "x" ; then
- CXXFLAGSO="$CXXFLAGS" ;
- fi
-
- dnl In no case do we want to induce BOOST to use deprecated header files
- CXXFLAGSG="$CXXFLAGSG -DBOOST_NO_HASH -DBOOST_NO_SLIST"
- CXXFLAGSO="$CXXFLAGSO -DBOOST_NO_HASH -DBOOST_NO_SLIST"
-
- dnl First the flags for gcc compilers
- if test "$GXX" = yes ; then
- CXXFLAGSO="$CXXFLAGSO -O2 -funroll-loops -funroll-all-loops -fstrict-aliasing -Wuninitialized -felide-constructors"
- CXXFLAGSG="$CXXFLAGSG -DDEBUG -Wall -W -Wpointer-arith -Wwrite-strings -Wsynth -Wsign-compare -Wswitch"
-
- dnl gcc 4.4 has an interesting problem in that it doesn't
- dnl care for one of BOOST signals2's header files and produces
- dnl dozens of pages of error messages of the form
- dnl warning: invoking macro BOOST_PP_CAT argument 1: empty macro arguments are undefined in ISO C90 and ISO C++98
- dnl This can be avoided by not using -pedantic for this compiler.
- dnl For all other versions, we use this flag, however.
- if test $GXX_VERSION != gcc4.4 ; then
- CXXFLAGS="$CXXFLAGS -pedantic"
- fi
-
- dnl BOOST uses long long, so don't warn about this
- CXXFLAGSG="$CXXFLAGSG -Wno-long-long"
-
- dnl See whether the gcc we use already has a flag for C++2011 features.
- DEAL_II_CHECK_CXX1X
-
-
- dnl On some gcc 4.3 snapshots, a 'const' qualifier on a return type triggers a
- dnl warning. This is unfortunate, since we happen to stumble on this
- dnl in some of our template trickery with iterator classes. If necessary,
- dnl do not use the relevant warning flag
- CXXFLAGS="-Wreturn-type -Werror"
- AC_MSG_CHECKING(whether qualifiers in return types lead to a warning)
- AC_TRY_COMPILE(
- [
- const double foo() { return 1.; }
- ],
- [;],
- [
- AC_MSG_RESULT(no)
- ],
- [
- AC_MSG_RESULT(yes)
- CXXFLAGSG="$CXXFLAGSG -Wno-return-type"
- ])
-
- dnl Newer versions of gcc can pass a flag to the assembler to
- dnl compress debug sections. At the time of writing this test,
- dnl this can save around 230 MB of disk space on the object
- dnl files we produce (810MB down to 570MB for the debug versions
- dnl of object files). Unfortunately, the sections have to be
- dnl unpacked again when they are put into the shared libs, so
- dnl no savings there.
- dnl
- dnl The flag also doesn't appear to be working on Cygwin, as
- dnl per email by John Fowkes on the mailing list in Feb 2012,
- dnl so don't run the test on cygwin.
- case "$target" in
- *cygwin* )
- ;;
-
- * )
- CXXFLAGS="-Wa,--compress-debug-sections"
- AC_MSG_CHECKING([whether the assembler understands -Wa,--compress-debug-sections])
- AC_TRY_LINK(
- [
- ],
- [;],
- [
- AC_MSG_RESULT(yes)
- CXXFLAGSG="$CXXFLAGSG -Wa,--compress-debug-sections"
- ],
- [
- AC_MSG_RESULT(no)
- ])
- ;;
- esac
-
- dnl Set PIC flags. On some systems, -fpic/PIC is implied, so don't set
- dnl anything to avoid a warning. on AIX make sure we always pass -lpthread
- dnl because this seems to be somehow required to make things work. Likewise
- dnl DEC OSF and linux on x86_64.
- case "$target" in
- *aix* )
- CXXFLAGSPIC=
- LDFLAGSPIC=
- LDFLAGS="$LDFLAGS -lpthread"
- ;;
-
- *dec-osf* )
- CXXFLAGSPIC="-fPIC"
- LDFLAGSPIC="-fPIC"
- LDFLAGS="$LDFLAGS -lpthread"
- ;;
-
- *x86_64*)
- CXXFLAGSPIC="-fPIC"
- LDFLAGSPIC="-fPIC"
- LDFLAGS="$LDFLAGS -lpthread"
- ;;
-
- *cygwin* )
- dnl On Cygwin, when using shared libraries, there might occur
- dnl difficulties when linking libraries for several dimensions,
- dnl as some symbols are defined in all of them. This leads to a
- dnl linker error. We force the linker to ignore multiple symbols,
- dnl but of course this might lead to strange program behaviour if
- dnl you accidentally defined one symbol multiple times...
- dnl (added 2005/07/13, Ralf B. Schulz)
- dnl (modified 2005/12/20, Ralf B. Schulz)
- CXXFLAGSPIC=
- LDFLAGS="$LDFLAGS -Xlinker --allow-multiple-definition"
- SHLIBFLAGS="$SHLIBFLAGS -Xlinker --allow-multiple-definition"
- ;;
-
- *)
- CXXFLAGSPIC="-fPIC"
- LDFLAGSPIC="-fPIC"
- ;;
- esac
-
- dnl Some gcc compiler versions have a problem when using an unsigned count
- dnl in the std::advance function. Unfortunately, this also happens
- dnl occasionally from within the standard library, so we can't prevent the
- dnl warning messages. Since this is annoying, switch of the flag -W which
- dnl causes this.
- DEAL_II_CHECK_ADVANCE_WARNING
- if test "x$DEAL_II_ADVANCE_WARNING" = "xyes" ; then
- CXXFLAGSG="`echo $CXXFLAGSG | perl -pi -e 's/-W //g;'`"
- fi
-
- if test "x$DEAL_II_USE_MPI" = "xyes" ; then
- AC_MSG_CHECKING(whether MPI headers have unused parameters)
- CXXFLAGS="-Wunused-parameter -Werror"
- AC_TRY_COMPILE(
- [
- #include <mpi.h>
- ],
- [;],
- [
- AC_MSG_RESULT(no)
- ],
- [
- AC_MSG_RESULT(yes)
- CXXFLAGSG="$CXXFLAGSG -Wno-unused-parameter"
- CXXFLAGSO="$CXXFLAGSO -Wno-unused-parameter"
- ])
- fi
-
- dnl Some system specific things
- case "$target" in
- dnl Use -Wno-long-long on Apple Darwin to avoid some unnecessary
- dnl warnings. However, newer gccs on that platform do not have
- dnl this flag any more, so check whether we can indeed do this
- dnl
- dnl Also, the TBB tries to determine whether the system is
- dnl 64-bit enabled and if so, it builds the object files in 64bit.
- dnl In order to be able to link with these files, we then have to
- dnl link with -m64 as well
- *apple-darwin*)
- OLD_CXXFLAGS="$CXXFLAGS"
- CXXFLAGS=-Wno-long-double
-
- AC_MSG_CHECKING(whether we can use -Wno-long-double)
- AC_TRY_COMPILE([], [;],
- [
- AC_MSG_RESULT(yes)
- CXXFLAGSG="$CXXFLAGSG -Wno-long-double"
- CXXFLAGSO="$CXXFLAGSO -Wno-long-double"
- ],
- [
- AC_MSG_RESULT(no)
- ])
-
- if test "`/usr/sbin/sysctl -n hw.optional.x86_64`" = "1" ; then
- CXXFLAGS="$CXXFLAGS -m64"
- CXXFLAGSG="$CXXFLAGSG -m64"
- CXXFLAGSO="$CXXFLAGSO -m64"
-
- CFLAGS="$CFLAGS -m64"
- CFLAGSG="$CFLAGSG -m64"
- CFLAGSO="$CFLAGSO -m64"
-
- LDFLAGS="$LDFLAGS -m64"
- fi
-
- CXXFLAGS="${OLD_CXXFLAGS}"
- ;;
-
- dnl On DEC OSF, including both stdio.h and unistd.h causes a warning
- dnl from the preprocessor that cuserid is redefined as a preprocessor
- dnl variable. Suppress this if necessary by switching off warnings
- dnl from the preprocessor
- *dec-osf*)
- AC_MSG_CHECKING(for preprocessor warning with cuserid)
- CXXFLAGS="$CXXFLAGSG -Werror"
- AC_TRY_COMPILE(
- [
-# include <stdio.h>
-# include <unistd.h>
- ],
- [;],
- [
- AC_MSG_RESULT(no)
- ],
- [
- AC_MSG_RESULT(yes)
- CXXFLAGSG="$CXXFLAGSG -Wp,-w"
- CXXFLAGSO="$CXXFLAGSO -Wp,-w"
- ])
- ;;
- esac
-
- SHLIBLD="$CXX"
-
- else
- dnl Non-gcc compilers. By default, use the C++ compiler also for linking
- dnl shared libraries. If some compiler cannot do that and needs something
- dnl different, then this must be specified in the respective section
- dnl below, overriding this define:
- SHLIBLD="$CXX"
-
- case "$GXX_VERSION" in
- ibm_xlc)
- dnl Set flags for IBM's xlC compiler. As of version 11.1, it still
- dnl doesn't grok all of deal.II, but it's getting closer. The
- dnl -qxflag=EnableIssue214PartialOrdering flag is necessary to
- dnl resolve code like this that we have in the MemoryConsumption
- dnl namespace:
- dnl ----------------------------------------------
- dnl template <typename T> void f (T* const);
- dnl template <typename T> void f (const T &);
- dnl
- dnl void g() {
- dnl int *p;
- dnl f(p);
- dnl }
- dnl ----------------------------------------------
- dnl
- dnl Similarly, -qxflag=IgnoreCVOnTopOfFunctionTypes is necessary for
- dnl ----------------------------------------------
- dnl struct S {};
- dnl S & foo (const S&);
- dnl
- dnl struct X {
- dnl template <typename T>
- dnl void f (const T &t) const;
- dnl };
- dnl
- dnl void
- dnl print_summary ()
- dnl {
- dnl X x;
- dnl x.f (foo);
- dnl }
- dnl ----------------------------------------------
- dnl We have this kind of code with S=std::ostream, foo=std::endl
- dnl and X=LogStream when we do things like
- dnl deallog << std::endl;
- CXXFLAGSG="$CXXFLAGSG -DDEBUG -check=bounds -info=all -qrtti=all -qsuppress=1540-2907 -qsuppress=1540-2909 -qxflag=EnableIssue214PartialOrdering -qxflag=IgnoreCVOnTopOfFunctionTypes"
- CXXFLAGSO="$CXXFLAGSO -O2 -w -qansialias -qrtti=all -qsuppress=1540-2907 -qsuppress=1540-2909 -qxflag=EnableIssue214PartialOrdering -qxflag=IgnoreCVOnTopOfFunctionTypes"
- CXXFLAGSPIC="-qpic"
- LDFLAGSPIC="-qpic"
- ;;
-
- MIPSpro*)
- dnl Disable some compiler warnings, as they trigger some warnings in
- dnl system and compiler include files
- dnl cc-1429 CC: WARNING File = /usr/include/internal/stdlib_core.h, Line = 128
- dnl The type "long long" is nonstandard.
- dnl cc-1066 CC: WARNING File = /usr/include/CC/stl_ctype.h, Line = 28
- dnl The indicated enumeration value is out of "int" range.
- dnl cc-1485 CC: WARNING File = /usr/include/CC/iomanip, Line = 122
- dnl This form for taking the address of a member function is nonstandard.
- CXXFLAGSG="$CXXFLAGSG -DDEBUG -D__sgi__ -no_auto_include -ansiW -woff 1429,1066,1485"
- dnl Disable some compiler warnings, that warn about variables
- dnl which are used in Assert templates but not in optimized mode
- dnl cc-1174 CC: full_matrix.templates.h, Line = 1461
- dnl The variable "typical_diagonal_element" was declared but never referenced.
- dnl cc-1552 CC: WARNING File = source/data_out_base.cc, Line = 3493
- dnl The variable "ierr" is set but never used.
- CXXFLAGSO="$CXXFLAGSO -D__sgi__ -O2 -no_auto_include -woff 1174,1552"
- CXXFLAGSPIC="-KPIC"
- LDFLAGSPIC="-KPIC"
- dnl Avoid output of prelinker (-quiet_prelink)
- dnl Disable compiler warning:
- dnl ld32: WARNING 131: Multiply defined weak symbol:
- dnl (_M_acquire_lock__Q2_3std15_STL_mutex_lockGv) in auto_derivative_function.g.o
- dnl and convergence_table.g.o (2nd definition ignored)
- LDFLAGS="$LDFLAGS -quiet_prelink -woff 131"
- dnl
- dnl Always link with math library: The -lm option must be at the end of the
- dnl linker command, therefore it cannot be included into LDFLAGS
- DEAL_II_ADD_EXTERNAL_LIBS_AT_TAIL(-lm)
- ;;
-
- clang*)
- dnl Like many other compilers, clang produces warnings for array
- dnl accesses out of bounds, even if they are in code that's dead
- dnl for this dimension. Suppress this.
- dnl
- dnl There are a number of other warnings we get that can't easily
- dnl be worked around and that are definitely not useful. Suppress
- dnl those too.
- CXXFLAGSG="$CXXFLAGS -DDEBUG -g -Wall -Wno-array-bounds -Wno-parentheses -Wno-delete-non-virtual-dtor -Wno-unneeded-internal-declaration -Wno-unused-function -Wno-unused-variable"
- CXXFLAGSO="$CXXFLAGS -O2 -Wno-array-bounds -Wno-parentheses -Wno-delete-non-virtual-dtor -Wno-unneeded-internal-declaration -Wno-unused-function -Wno-unused-variable"
- CXXFLAGSPIC="-fPIC"
- LDFLAGSPIC="-fPIC"
- ;;
-
- intel_icc*)
- dnl Earlier icc versions used -Kxxx for flags. Later versions use
- dnl the gcc convention -fxxx. Also, at least since icc11, the
- dnl flag -inline_debug_info has been deprecated, so don't use
- dnl it any more
- dnl
- dnl Exception handling is also standard in later versions, as is rtti
- case "$GXX_VERSION" in
- intel_icc5 | intel_icc6 | intel_icc7 | intel_icc8 | intel_icc9)
- CXXFLAGSG="$CXXFLAGSG -Kc++eh -Krtti -DDEBUG -inline_debug_info"
- CXXFLAGSO="$CXXFLAGSO -Kc++eh -Krtti -O2 -unroll"
- CXXFLAGSPIC="-KPIC"
- LDFLAGSPIC="-KPIC"
- ;;
-
- intel_icc*)
- CXXFLAGSG="$CXXFLAGSG -DDEBUG"
- CXXFLAGSO="$CXXFLAGSO -O2 -unroll"
- CXXFLAGSPIC="-fPIC"
- LDFLAGS="$LDFLAGS -lstdc++ -lpthread"
- LDFLAGSPIC="-fPIC"
- ;;
- esac
-
- dnl Disable some compiler warnings, as they often are wrong on
- dnl our code:
- dnl #11: ` unrecognized preprocessing directive" (we use
- dnl #warning at one place)
- dnl #175: `subscript out of range' (doesn't take into account that
- dnl some code is only reachable for some dimensions)
- dnl #327: `NULL reference is not allowed' (this happens when we
- dnl write "*static_cast<double*>(0)" or some such thing,
- dnl which we do to create invalid references)
- dnl #424: `extra ";" ignored'
- dnl #525: `type "DataOutBase::DataOutBase" is an inaccessible type
- dnl (allowed for compatibility)' (I don't understand what the
- dnl compiler means)
- dnl #734: `X::X(const X&), required for copy that was eliminated, is
- dnl inaccessible'
- dnl (valid, but annoying and sometimes hard to work around)
- dnl #858: `type qualifier on return type is meaningless'
- dnl (on conversion operators to types that are already const)
- dnl #1565: attributes are ignored on a class declaration that is not
- dnl also a definition (this happens in BOOST in a number of
- dnl places)
- CXXFLAGSG="$CXXFLAGSG -w1 -wd175 -wd525 -wd327 -wd424 -wd11 -wd734 -wd858 -wd1565"
- CXXFLAGSO="$CXXFLAGSO -w0 -wd424 -wd11"
-
- dnl To reduce output, use -opt_report_levelmin where possible,
- dnl i.e. post icc5. from icc10 onwards, this flag is called
- dnl -opt-report, and -vec-report controls output of the
- dnl autovectorizer (to make things simpler, one of the two options
- dnl wants a space between option and level, whereas the other does
- dnl not)
- dnl
- dnl Since only the x86 and x86_64 compilers can vectorize, this
- dnl flag needs to be suppressed on ia64 (itanium)
- case "$GXX_VERSION" in
- intel_icc5)
- ;;
- intel_icc6 | intel_icc7 | intel_icc8 | intel_icc9)
- CXXFLAGSO="$CXXFLAGSO -opt_report_levelmin"
- ;;
- *)
- case "$target" in
- *ia64*)
- CXXFLAGSO="$CXXFLAGSO -opt-report 0"
- ;;
- *)
- CXXFLAGSO="$CXXFLAGSO -opt-report 0 -vec-report0"
- ;;
- esac
- ;;
- esac
-
- dnl Some versions of icc on some platforms issue a lot of warnings
- dnl about the unreliability of floating point comparisons. Check
- dnl whether we can switch that off
- DEAL_II_ICC_WD_1572
-
- dnl We would really like to use -ansi -Xc, since that
- dnl is _very_ picky about standard C++, and is thus very efficient
- dnl in detecting slight standard violations, but these flags are
- dnl also very efficient in crashing the compiler (it generates a
- dnl segfault), at least with versions prior to 7.0. So only
- dnl use these flags with versions we know are safe
- dnl
- dnl Second thing: icc7 allows using alias information for
- dnl optimization. Use this.
- if test "x$GXX_VERSION" = "xintel_icc7"; then
- CXXFLAGSG="$CXXFLAGSG -Xc -ansi"
- CXXFLAGSO="$CXXFLAGSO -ansi_alias"
- dnl For icc8:
- dnl avoid the annoying `LOOP WAS VECTORIZED' remarks
- dnl use -vec_report0 for reducing output
- else if test "x$GXX_VERSION" = "xintel_icc8" ; then
- CXXFLAGSO="$CXXFLAGSO -ansi_alias -vec_report0"
- fi fi
-
- dnl If we are on an x86 platform, add -tpp6 to optimization
- dnl flags (for version <10), or the equivalent for later
- dnl processors
- case "$target" in
- *x86_64*)
- LDFLAGS="$LDFLAGS -lpthread"
- ;;
-
- *86*)
- case "$GXX_VERSION" in
- intel_icc5)
- ;;
- intel_icc6 | intel_icc7 | intel_icc8 | intel_icc9)
- CXXFLAGSO="$CXXFLAGSO -tpp6"
- ;;
- *)
- CXXFLAGSO="$CXXFLAGSO -mcpu=pentium4"
- ;;
- esac
- ;;
- esac
-
- dnl Intel's MPI implementation based on ICC requires that
- dnl mpi.h be included *before* things like <stdio.h> or
- dnl <iostream>. How they envision this to work is beyond
- dnl me because they may be indirectly included from other
- dnl header files. Besides this, autoconf generates tests
- dnl that don't follow this rule and so fail at ./configure
- dnl time. There is nothing we can do about it. However,
- dnl there is a workaround described here:
- dnl http://software.intel.com/en-us/articles/intel-mpi-library-for-linux-running-list-of-known-issues/#A3
- dnl We switch this on if we use Intel's ICC + MPI
- if test "x$DEAL_II_USE_MPI" = "xyes" ; then
- CXXFLAGSG="$CXXFLAGSG -DMPICH_IGNORE_CXX_SEEK"
- CXXFLAGSO="$CXXFLAGSO -DMPICH_IGNORE_CXX_SEEK"
- fi
-
- dnl Finally, see if the compiler supports C++0x
- DEAL_II_CHECK_CXX1X
- ;;
-
- compaq_cxx)
- dnl Disable some warning messages:
- dnl #11: ` unrecognized preprocessing directive" (we use
- dnl #warning at one place)
- dnl #175: `subscript out of range' (detected when instantiating a
- dnl template and looking at the indices of an array of
- dnl template dependent size, this error is triggered in a
- dnl branch that is not taken for the present space dimension)
- dnl #236 and
- dnl #237: `controlling expression is constant' (in while(true), or
- dnl switch(dim))
- dnl #381: `extra ";" ignored' (at function or namespace closing
- dnl brace)
- dnl #487: `Inline function ... cannot be explicitly instantiated'
- dnl (also reported when we instantiate the entire class)
- dnl #1136:`conversion to integral type of smaller size could lose data'
- dnl (occurs rather often in addition of int and x.size(),
- dnl because the latter is size_t=long unsigned int on Alpha)
- dnl #1156:`meaningless qualifiers not compatible with "..." and "..."'
- dnl (cause unknown, happens when taking the address of a
- dnl template member function)
- dnl #111 and
- dnl #1182:`statement either is unreachable or causes unreachable code'
- dnl (happens in switch(dim) clauses for other dimensions than
- dnl the present one)
- dnl #450:`the type "long long" is nonstandard'
- dnl BOOST uses long long, unfortunately
- dnl
- dnl Also disable the following error:
- dnl #265: `class "..." is inaccessible' (happens when we try to
- dnl initialize a static member variable in terms of another
- dnl static member variable of the same class if the latter is
- dnl not public and therefore not accessible at global scope in
- dnl general. I nevertheless think that this is valid.)
- dnl
- dnl Besides this, choose the most standard conforming mode of the
- dnl compiler, i.e. -model ansi and -std strict_ansi. Unfortunately,
- dnl we have to also add the flag -implicit_local (generating implicit
- dnl instantiations of template with the `weak' link flag) since
- dnl otherwise not all templates are instantiated (also some from the
- dnl standards library are missing).
-
- CXXFLAGSG="$CXXFLAGSG -model ansi -std strict_ansi -w1 -msg_display_number -timplicit_local -DDEBUG"
- CXXFLAGSO="$CXXFLAGSO -model ansi -std strict_ansi -w2 -msg_display_number -timplicit_local -fast"
-
- for i in 11 175 236 237 381 487 1136 1156 111 1182 265 450 ; do
- CXXFLAGSG="$CXXFLAGSG -msg_disable $i"
- CXXFLAGSO="$CXXFLAGSO -msg_disable $i"
- done
-
-
- dnl If we use -model ansi to compile the files, we also have to
- dnl specify it for linking
- LDFLAGS="$LDFLAGS -model ansi"
-
- dnl For some reason, cxx also forgets to add the math lib to the
- dnl linker line, so we do that ourselves
- LDFLAGS="$LDFLAGS -lm"
-
- CXXFLAGSPIC="-shared"
- LDFLAGSPIC=""
- ;;
-
- sun_workshop | sun_forte)
-
- CXXFLAGSG="$CXXFLAGSG -DDEBUG -w"
- CXXFLAGSO="$CXXFLAGSO -w"
- CXXFLAGSPIC="-KPIC"
- LDFLAGSPIC="-G"
-
- dnl See if the flag -library=stlport4 is available, and if so use it
- CXXFLAGS="$CXXFLAGSG -library=stlport4"
- AC_MSG_CHECKING(whether -library=stlport4 works)
- AC_TRY_COMPILE(
- [
- ],
- [
- ;
- ],
- [
- AC_MSG_RESULT(yes)
- CXXFLAGSG="$CXXFLAGSG -library=stlport4"
- CXXFLAGSO="$CXXFLAGSO -library=stlport4"
- ],
- [
- AC_MSG_RESULT(no)
- ])
- ;;
-
- pgCC*)
- dnl Suppress warnings:
- dnl #68: "integer conversion resulted in a change of sign". This
- dnl is what we get every time we use
- dnl numbers::invalid_unsigned_int
- dnl #111: "Statement unreachable": we use return statements
- dnl occasionally after case-switches where you cannot
- dnl fall though, but other compilers sometimes complain
- dnl that the function might not return with a value, if
- dnl it can't figure out that the function always uses
- dnl one case. Also: a return statement after a failing
- dnl assertion
- dnl #128: a similar case -- code not reachable because there's
- dnl a return that's active for a particular space dimension
- dnl #155: no va_start() seen -- happens alwas in lines 138 and 891
- dnl and seems to be spurious
- dnl #177: "function declared but not used": might happen with
- dnl templates and conditional compilation
- dnl #175: "out-of-bounds array indices": the same reason as
- dnl for Compaq cxx
- dnl #185: "dynamic initialization in unreachable code". similar to
- dnl the case #128 above
- dnl #236: "controlling expression is constant". this triggers
- dnl somewhere in BOOST with BOOST_ASSERT. I have no idea
- dnl what happens here
- dnl #284: "NULL references not allowed"
- CXXFLAGSG="$CXXFLAGSG -DDEBUG -g --display_error_number --diag_suppress 68 --diag_suppress 111 --diag_suppress 128 --diag_suppress 155 --diag_suppress 177 --diag_suppress 175 --diag_suppress 185 --diag_suppress 236 --diag_suppress 284"
- CXXFLAGSO="$CXXFLAGSO -fast -O2 --display_error_number --diag_suppress 68 --diag_suppress 111 --diag_suppress 128 --diag_suppress 155 --diag_suppress 177 --diag_suppress 175 --diag_suppress 185 --diag_suppress 236 --diag_suppress 284"
- CXXFLAGSPIC="-Kpic"
-
- dnl pgCC can't (as of writing this, with version 12.5 in mid-2012) compile a part of BOOST.
- dnl Fortunately, BOOST provides a workaround by setting a specific preprocessor
- dnl symbol that can be set. Do so.
- CXXFLAGSG="$CXXFLAGSG -DBOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE"
- CXXFLAGSO="$CXXFLAGSO -DBOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE"
- ;;
-
- kai_cc)
- CXXFLAGSG="$CXXFLAGSG --strict -D__KAI_STRICT --max_pending_instantiations 32 --display_error_number -g +K0 --no_implicit_typename"
- CXXFLAGSO="$CXXFLAGSO +K3 -O2 --abstract_float --abstract_pointer -w --display_error_number --max_pending_instantiations 32 --display_error_number"
- CXXFLAGSPIC="-fPIC"
- ;;
-
- hp_aCC)
- dnl ??? disable warning 655 (about all-inlined functions) which
- dnl triggers for each and every of our DeclExceptionX calls ???
- CXXFLAGSG="$CXXFLAGSG -g1 -AA +p"
- CXXFLAGSO="$CXXFLAGSO -z +O2 -AA"
- CXXFLAGSPIC="+Z"
- # for linking shared libs, -b is also necessary...
- ;;
-
- borland_bcc)
- CXXFLAGSG="$CXXFLAGSG -q -DDEBUG -w -w-use -w-amp -w-prc"
- CXXFLAGSO="$CXXFLAGSO -q -O2"
- CXXFLAGSPIC=""
- LDFLAGSPIC=""
- AC_MSG_ERROR(Attention! deal.II is not known to work with Borland C++!
- If you intend to port it to Borland C++, please remove this message from aclocal.m4 and call autoconf and configure. If you do not understand this, you will NOT want to do it!)
- ;;
-
- pathscale_cc)
- CXXFLAGSG="$CXXFLAGSG -DDEBUG -g"
- CXXFLAGSO="$CXXFLAGSO -O3"
- ;;
-
- *)
- CXXFLAGSG="$CXXFLAGSG -DDEBUG"
- CXXFLAGSO="$CXXFLAGSO -O2"
- AC_MSG_RESULT(Unknown C++ compiler - using generic options)
- ;;
- esac
- fi
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl Depending on what compiler we use, set the flag necessary to
-dnl obtain debug output. We will usually use -ggdb, but on DEC Alpha
-dnl OSF1, this leads to stabs symbols that are too long for the system
-dnl assembler. We will therefore check whether the assembler can handle
-dnl these symbols by a rather perverse function with many templates,
-dnl and if the assembler can't handle them, then use -gstabs
-dnl instead. This reduces debugging possibilities, but no other
-dnl way is known at present.
-dnl
-dnl For all compilers other than gcc, use -g instead and don't check.
-dnl
-dnl Usage: DEAL_II_SET_CXX_DEBUG_FLAG
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_SET_CXX_DEBUG_FLAG, dnl
-[
- if test "$GXX" = yes ; then
- case "$target" in
- dnl On Alpha, use the special treatment
- alpha*-osf*)
- AC_MSG_CHECKING(whether -ggdb works for long symbols)
- CXXFLAGS="-ggdb $CXXFLAGSG"
- AC_TRY_COMPILE(
- [
-# include <string>
-# include <map>
- using namespace std;
-
- typedef map<string,map<string,pair<string,string> > > T;
-
- bool f(T& t1, const T* t2) {
- t1["s"] = map<string,pair<string,string> >();
- map<string,map<string,pair<string,string> > >
- ::const_iterator i2=t1.begin();
- map<string,map<string,pair<string,string> > >
- ::const_iterator i1=t2->begin();
- return (i1==i2);
- }
- ],
- [
- ;
- ],
- [
- CXXFLAGSG="-ggdb $CXXFLAGSG"
- AC_MSG_RESULT(yes)
- ],
- [
- CXXFLAGSG="-gstabs $CXXFLAGSG"
- AC_MSG_RESULT(no -- using -gstabs instead)
- ])
- ;;
-
- dnl For all other systems test whether -ggdb works at all, and if
- dnl not fall back on -g instead. This test is mainly used to
- dnl accomodate for a failure on Mac OS X, where -ggdb leads to
- dnl information the assembler does not understand (see mailing
- dnl list thread on this from mid-October 2002)
- *)
- AC_MSG_CHECKING(whether -ggdb works)
- CXXFLAGS="-ggdb $CXXFLAGSG"
- AC_TRY_COMPILE(
- [],
- [ ; ],
- [
- CXXFLAGSG="-ggdb $CXXFLAGSG"
- AC_MSG_RESULT(yes)
- ],
- [
- CXXFLAGSG="-g $CXXFLAGSG"
- AC_MSG_RESULT(no -- using -g instead)
- ])
- ;;
- esac
-
- else
- dnl Non-gcc compilers use -g instead of -ggdb, except for Borland C++
- dnl which wants something entirely different
- case "$GXX_VERSION" in
- borland_bcc)
- CXXFLAGSG="-v -y $CXXFLAGSG"
- ;;
-
- *)
- CXXFLAGSG="-g $CXXFLAGSG"
- ;;
- esac
- fi
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl See if there is a compiler flag to enable C++1x features
-dnl
-dnl Usage: DEAL_II_CHECK_CXX1X
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_CXX1X, dnl
-[
- AC_MSG_CHECKING(whether compiler has a flag to support C++2011)
-
- dnl See if -std=c++0x exists
- OLD_CXXFLAGS="$CXXFLAGS"
- CXXFLAGS=-std=c++0x
- AC_TRY_COMPILE([], [;],
- [
- AC_MSG_RESULT(yes)
- test_cxx1x=yes
- ],
- [
- AC_MSG_RESULT(no)
- test_cxx1x=no
- ])
- CXXFLAGS="${OLD_CXXFLAGS}"
-
- dnl If the flag above works, then see if the compiler is complete
- dnl enough in this area
- if test "x$test_cxx1x" = "xyes" ; then
- DEAL_II_CHECK_CXX1X_COMPONENTS("-std=c++0x")
- fi
-])
-
-
-dnl -------------------------------------------------------------
-dnl Given the command line flag specified as argument to this macro,
-dnl test whether all components that we need from the C++1X
-dnl standard are actually available. If so, add the flag to
-dnl CXXFLAGS.g and CXXFLAGS.o, and set a flag in config.h
-dnl
-dnl Usage: DEAL_II_CHECK_CXX1X_COMPONENTS(cxxflag)
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_CXX1X_COMPONENTS, dnl
-[
- OLD_CXXFLAGS="$CXXFLAGS"
- CXXFLAGS="$1"
-
- all_cxx1x_classes_available=yes
-
- AC_MSG_CHECKING(for std::array)
- AC_TRY_COMPILE(
- [#include <array>],
- [ std::array<int,3> p; p[0];],
- [ AC_MSG_RESULT(yes) ],
- [ AC_MSG_RESULT(no); all_cxx1x_classes_available=no ]
- )
-
- AC_MSG_CHECKING(for std::condition_variable)
- AC_TRY_COMPILE(
- [#include <condition_variable> ],
- [ std::condition_variable c; c.notify_all()],
- [ AC_MSG_RESULT(yes) ],
- [ AC_MSG_RESULT(no); all_cxx1x_classes_available=no ]
- )
-
- AC_MSG_CHECKING(for std::function and std::bind)
- AC_TRY_COMPILE(
- [#include <functional>
- void f(int, double); ],
- [ std::function<void (int)>
- g = std::bind (f, std::placeholders::_1, 1.1) ;],
- [ AC_MSG_RESULT(yes) ],
- [ AC_MSG_RESULT(no); all_cxx1x_classes_available=no ]
- )
-
- dnl Make sure we don't run into GCC bug 35569
- AC_MSG_CHECKING(for std::bind works with rvalues)
- AC_TRY_COMPILE(
- [#include <functional>
- void f(int); ],
- [ using namespace std;
- using namespace std::placeholders;
- bind(multiplies<int>(),4,_1)(5); ;],
- [ AC_MSG_RESULT(yes) ],
- [ AC_MSG_RESULT(no); all_cxx1x_classes_available=no ]
- )
-
- AC_MSG_CHECKING(for std::shared_ptr)
- AC_TRY_COMPILE(
- [#include <memory>],
- [ std::shared_ptr<int> p(new int(3))],
- [ AC_MSG_RESULT(yes) ],
- [ AC_MSG_RESULT(no); all_cxx1x_classes_available=no ]
- )
-
- AC_MSG_CHECKING(for std::thread)
- AC_TRY_COMPILE(
- [#include <thread>
- void f(int); ],
- [ std::thread t(f,1); t.join();],
- [ AC_MSG_RESULT(yes) ],
- [ AC_MSG_RESULT(no); all_cxx1x_classes_available=no ]
- )
-
- dnl On some systems with gcc 4.5.0, we can compile the code
- dnl above but it will throw an exception when run. So test
- dnl that as well. The test will only be successful if we have
- dnl libpthread available, so link it in for this test. If
- dnl multithreading is requested, it will be added to CXXFLAGS
- dnl later on so there is no need to do this here.
- CXXFLAGS="$1 -lpthread"
- AC_MSG_CHECKING(whether std::thread actually works)
- AC_TRY_RUN(
- [#include <thread>
- void f(int) {}
- int main() { std::thread t(f,1); t.join(); } ],
- [ AC_MSG_RESULT(yes) ],
- [ AC_MSG_RESULT(no); all_cxx1x_classes_available=no ]
- )
- CXXFLAGS="$1"
-
- AC_MSG_CHECKING(for std::mutex)
- AC_TRY_COMPILE(
- [#include <mutex> ],
- [ std::mutex m; m.lock();],
- [ AC_MSG_RESULT(yes) ],
- [ AC_MSG_RESULT(no); all_cxx1x_classes_available=no ]
- )
-
- AC_MSG_CHECKING(for std::tuple)
- AC_TRY_COMPILE(
- [#include <tuple>],
- [ std::tuple<int,double,char> p(1,1.1,'a')],
- [ AC_MSG_RESULT(yes) ],
- [ AC_MSG_RESULT(no); all_cxx1x_classes_available=no ]
- )
-
- AC_MSG_CHECKING(for std::type_traits)
- AC_TRY_COMPILE(
- [#include <type_traits>],
- [ const bool m0 = std::is_trivial<double>::value;
- const bool m1 = std::is_standard_layout<double>::value;
- const bool m2 = std::is_pod<double>::value; ],
- [ AC_MSG_RESULT(yes) ],
- [ AC_MSG_RESULT(no); all_cxx1x_classes_available=no ]
- )
-
- CXXFLAGS="${OLD_CXXFLAGS}"
-
- dnl If the above classes and operations are all defined then we can
- dnl use the corresponding flag in CXXFLAGS* to switch on support and
- dnl correspondingly use the C++ classes instead of the BOOST classes
- AC_MSG_CHECKING(whether C++1x support is complete enough)
- if test "x$all_cxx1x_classes_available" = "xyes" ; then
- AC_MSG_RESULT(yes)
-
- CXXFLAGSG="$CXXFLAGSG $1"
- CXXFLAGSO="$CXXFLAGSO $1"
-
- AC_DEFINE(DEAL_II_CAN_USE_CXX1X, 1,
- [Defined if the compiler we use supports the C++2011 standard
- well enough to allow using the standard library classes instead
- of the corresponding BOOST classes.])
-
-
- dnl Also test for a couple C++1x things that we don't use in the library
- dnl but that users may want to use in their applications and that we
- dnl might want to test in the testsuite
- OLD_CXXFLAGS="$CXXFLAGS"
- CXXFLAGS="$CXXFLAGSG"
-
- extra_cxx1x_features_available=yes
-
- AC_MSG_CHECKING(for auto typed variables)
- AC_TRY_COMPILE(
- [#include <vector>],
- [
- std::vector<int> v;
- auto i = v.begin();
- *i;
- ],
- [ AC_MSG_RESULT(yes) ],
- [ AC_MSG_RESULT(no); extra_cxx1x_features_available=no ]
- )
-
- AC_MSG_CHECKING(for range-based for)
- AC_TRY_COMPILE(
- [#include <vector>],
- [
- std::vector<int> v;
- for (std::vector<int>::iterator i : v)
- *i;
- ],
- [ AC_MSG_RESULT(yes) ],
- [ AC_MSG_RESULT(no); extra_cxx1x_features_available=no ]
- )
-
- CXXFLAGS="${OLD_CXXFLAGS}"
-
- dnl Right now, do nothing with this information since we don't
- dnl have any compiler that gets all this right (gcc 4.5 included)
- dnl and that we could use to test these features.
- else
- AC_MSG_RESULT(no)
-
- dnl Intel icc 12.1 has this crazy behavior where it needs -std=c++0x
- dnl to compile BOOST, but it fails every single one of the header
- dnl file tests above. So we end up here. Work around this by using
- dnl the flag even though we can't use a single piece of functionality.
- if test "x$GXX_VERSION" = "xintel_icc12" ; then
- CXXFLAGSG="$CXXFLAGSG $1"
- CXXFLAGSO="$CXXFLAGSO $1"
- fi
- fi
-])
-
-
-dnl -------------------------------------------------------------
-dnl Determine the C compiler in use. Return the name and possibly
-dnl version of this compiler in CC_VERSION. This function is almost
-dnl identifical to DEAL_II_DETERMINE_CXX_BRAND and therefore lacks
-dnl a lot of the comments found there to keep it short
-dnl
-dnl Usage: DEAL_II_DETERMINE_CC_BRAND
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_DETERMINE_CC_BRAND, dnl
-[
- if test "$GCC" = "yes" ; then
- dnl Verify that we indeed have a compiler that identifies
- dnl itself as GCC
- CC_VERSION_STRING=`($CC -v 2>&1) | grep "gcc version"`
- if test "x$CC_VERSION_STRING" = "x" ; then
- GCC=no
- fi
-
- dnl Then icc came along and started to identify itself as
- dnl icc version 12.1.0 (gcc version 4.2.1 compatibility)
- dnl which also doesn't help...
- CC_VERSION_STRING=`($CC -v 2>&1) | grep "icc"`
- if test "x$CC_VERSION_STRING" != "x" ; then
- GCC=no
- fi
- fi
-
- if test "$GCC" = yes ; then
- dnl find out the right version
- CC_VERSION_STRING=`($CC -v 2>&1) | grep "gcc version"`
-
- full_version=`echo "$CC_VERSION_STRING" | perl -pi -e 's/.*version (\d\.\d\.\d).*/\1/g;'`
- CC_VERSION=gcc`echo $full_version | perl -pi -e 's/(\d\.\d).*/\1/g;'`
-
- AC_MSG_RESULT(C compiler is $CC_VERSION)
- else
- dnl Check other (non-gcc) compilers
-
- dnl Check for IBM xlC. For some reasons, depending on some environment
- dnl variables, moon position, and other reasons unknown to me, the
- dnl compiler displays different names in the first line of output, so
- dnl check various possibilities
- is_ibm_xlc="`($CC 2>&1) | egrep 'VisualAge C|C Set ++|C for AIX Compiler'`"
- if test "x$is_ibm_xlc" != "x" ; then
- dnl Ah, this is IBM's C compiler. Unfortunately, we don't presently
- dnl know how to check the version number, so assume that is sufficiently
- dnl high...
- AC_MSG_RESULT(C compiler is IBM xlC)
- CC_VERSION=ibm_xlc
- else
-
- dnl Check whether we are dealing with the MIPSpro C compiler
- mips_pro="`($CC -version 2>&1) | grep MIPSpro`"
- if test "x$mips_pro" != "x" ; then
- case "$mips_pro" in
- *7.0* | *7.1* | *7.2* | *7.3*)
- dnl MIPSpro 7.3 does not support standard C++, therefore it is not
- dnl able to compile deal.II. Previous compiler versions neither.
- AC_MSG_RESULT(C compiler is $mips_pro)
- AC_MSG_ERROR(This compiler is not supported)
- CC_VERSION=MIPSpro7.3
- ;;
- *7.4)
- AC_MSG_RESULT(C compiler is MIPSpro compiler 7.4)
- AC_MSG_ERROR(This compiler is not supported. Use MIPSPro compiler 7.4x)
- CC_VERSION=MIPSpro7.4
- ;;
- *7.41* | *7.42* | *7.43* | *7.44*)
- AC_MSG_RESULT(C compiler is MIPSpro compiler 7.4x)
- CC_VERSION=MIPSpro7.4x
- ;;
- *"7.5"*)
- AC_MSG_RESULT(C compiler is MIPSpro compiler 7.5)
- CC_VERSION=MIPSpro7.5
- ;;
- *)
- AC_MSG_RESULT(C compiler is unknown version but accepted MIPSpro compiler version)
- CC_VERSION=MIPSpro-other
- ;;
- esac
- else
-
- dnl Intel's ICC C compiler? On Linux, it uses -V, on Windows
- dnl it is -help
- dnl
- dnl Annoyingly, ecc6.0 prints its version number on a separate
- dnl line (the previous one ends with the string "applications"),
- dnl so join this one to the previous one with a little bit of
- dnl perl.
- is_intel_icc1="`($CC -V 2>&1) | grep 'Intel'`"
- is_intel_icc2="`($CC -help 2>&1) | grep 'Intel'`"
- is_intel_ecc="`($CC -V 2>&1) | perl -pi -e 's/applications\n/\1/g;' | grep 'Intel(R) C++ Itanium(TM) Compiler'`"
- is_intel_icc="$is_intel_icc1$is_intel_icc2$is_intel_ecc"
-
- dnl When calling the Portland Group compiler, it also
- dnl outputs the string 'Intel' in its help text, so make
- dnl sure we're not confused
- is_pgi="`($CXX -V 2>&1) | grep 'Portland'`"
-
- if test "x$is_intel_icc" != "x" -a "x$is_pgi" = "x"; then
- version_string="`($CC -V 2>&1) | grep 'Version'` `($CC -help 2>&1) | grep 'Version'`"
- version5="`echo $version_string | grep 'Version 5'`"
- version6="`echo $version_string | grep 'Version 6'`"
- version7="`echo $version_string | grep 'Version 7'`"
- version8="`echo $version_string | grep 'Version 8'`"
- version9="`echo $version_string | grep 'Version 9'`"
- version10="`echo $version_string | grep 'Version 10'`"
- if test "x$version5" != "x" ; then
- AC_MSG_RESULT(C compiler is icc-5)
- CC_VERSION=intel_icc5
- else if test "x$version6" != "x" ; then
- AC_MSG_RESULT(C compiler is icc-6)
- CC_VERSION=intel_icc6
- else if test "x$version7" != "x" ; then
- AC_MSG_RESULT(C compiler is icc-7)
- CC_VERSION=intel_icc7
- else if test "x$version8" != "x" ; then
- AC_MSG_RESULT(C compiler is icc-8)
- CC_VERSION=intel_icc8
- else if test "x$version9" != "x" ; then
- AC_MSG_RESULT(C compiler is icc-9)
- CC_VERSION=intel_icc9
- else if test "x$version10" != "x" ; then
- AC_MSG_RESULT(C compiler is icc-10)
- CC_VERSION=intel_icc10
- else
- AC_MSG_RESULT(C compiler is icc)
- CC_VERSION=intel_icc
- fi fi fi fi fi fi
- else
-
- dnl Or DEC's cxx compiler?
- is_dec_cxx="`($CC -V 2>&1) | grep 'Compaq C'`"
- if test "x$is_dec_cxx" != "x" ; then
- AC_MSG_RESULT(C compiler is Compaq cxx)
- CC_VERSION=compaq_cxx
- else
-
- dnl Sun Workshop?
- is_sun_cc="`($CC -V 2>&1) | grep 'Sun WorkShop'`"
- if test "x$is_sun_cc" != "x" ; then
- AC_MSG_RESULT(C compiler is Sun Workshop compiler)
- CC_VERSION=sun_workshop
- else
-
- dnl Sun Forte?
- is_sun_forte_cc="`($CC -V 2>&1) | grep 'Forte'`"
- is_sun_cc="`($CC -V 2>&1) | grep 'Sun C'`"
- if test "x$is_sun_forte_cc$is_sun_cc" != "x" ; then
- AC_MSG_RESULT(C compiler is Sun C compiler)
- CC_VERSION=sun_cc
- else
-
- dnl Portland Group C?
- is_pgcc="`($CC -V 2>&1) | grep 'Portland Group'`"
- if test "x$is_pgcc" != "x" ; then
- CC_VERSION_STRING=`($CC -V 2>&1) | grep "^pgcc"`
- full_version=`echo "$CC_VERSION_STRING" | perl -pi -e 's/.*pgcc\s+(\S+).*/\1/g;'`
- CC_VERSION=pgcc`echo $full_version | perl -pi -e 's/(\d\.\d).*/\1/g;'`
- AC_MSG_RESULT(C compiler is Portland Group C $full_version)
- else
-
- dnl HP aCC?
- is_aCC="`($CC -V 2>&1) | grep 'aCC'`"
- if test "x$is_aCC" != "x" ; then
- AC_MSG_RESULT(C compiler is HP aCC)
- CC_VERSION=hp_aCC
- else
-
- dnl Borland C
- is_bcc="`($CC -h 2>&1) | grep 'Borland'`"
- if test "x$is_bcc" != "x" ; then
- AC_MSG_RESULT(C compiler is Borland C)
- CC_VERSION=borland_bcc
- else
-
- is_clang="`($CC --version 2>&1) | grep clang`"
- if test "x$is_clang" != x ; then
- AC_MSG_RESULT(C compiler is clang)
- CC_VERSION=clang
- else
-
- dnl KAI C? It seems as if the documented options
- dnl -V and --version are not always supported, so give
- dnl the whole thing a second try by looking for /KCC/
- dnl somewhere in the paths that are output by -v. This
- dnl is risky business, since this combination of
- dnl characters might appear on other installations
- dnl of other compilers as well, so put this test to
- dnl the very end of the detection chain for the
- dnl various compilers
- is_kai_cc="`($CC --version 2>&1) | grep 'KAI C'`"
- is_kai_cc="$is_kai_cc`($CC -v 2>&1) | grep /KCC/`"
- if test "x$is_kai_cc" != "x" ; then
- AC_MSG_RESULT(C compiler is KAI C)
- CC_VERSION=kai_cc
- else
-
- dnl Aw, nothing suitable found...
- AC_MSG_RESULT([Unrecognized compiler -- still trying])
- CC_VERSION=unknown_cc
- fi
- fi
- fi
- fi
- fi
- fi
- fi
- fi
- fi
- fi
- fi
- fi
-])
-
-
-
-
-
-dnl -------------------------------------------------------------
-dnl Set C compiler flags to their default values. They will be
-dnl modified according to other options in later steps of
-dnl configuration
-dnl
-dnl CFLAGS.o : flags for optimized mode
-dnl CFLAGS.g : flags for debug mode
-dnl
-dnl Usage: DEAL_II_SET_CC_FLAGS
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_SET_CC_FLAGS, dnl
-[
- dnl First the flags for gcc compilers
- if test "$GCC" = yes ; then
- CFLAGSO="$CFLAGS -O3 -funroll-loops -funroll-all-loops -fstrict-aliasing"
- CFLAGSG="$CFLAGS -g"
- dnl Set PIC flags. On some systems, -fpic/PIC is implied, so don't set
- dnl anything to avoid a warning. on AIX make sure we always pass -lpthread
- dnl because this seems to be somehow required to make things work. Likewise
- dnl DEC OSF.
- case "$target" in
- *aix* )
- CFLAGSPIC=
- ;;
-
- *dec-osf* )
- CFLAGSPIC="-fPIC"
- ;;
-
- *cygwin*)
- CFLAGSPIC=
- ;;
-
- *apple-darwin*)
- dnl The TBB tries to determine whether the system is
- dnl 64-bit enabled and if so, it builds the object files in 64bit.
- dnl In order to be able to link with these files, we then have to
- dnl link with -m64 as well
- if test "`/usr/sbin/sysctl -n hw.optional.x86_64`" = "1" ; then
- CFLAGS="$CFLAGS -m64"
- fi
- ;;
-
- *)
- CFLAGSPIC="-fPIC"
- ;;
- esac
-
- else
- dnl Non-gcc compilers. By default, use the C compiler also for linking
- dnl shared libraries. If some compiler cannot do that and needs something
- dnl different, then this must be specified in the respective section
- dnl below, overriding this define:
- SHLIBLD="$CC"
-
- case "$CC_VERSION" in
- ibm_xlc)
- CFLAGSO="$CFLAGS -O2"
- CFLAGSPIC="-fPIC"
- SHLIBLD="$CXX"
- ;;
-
- MIPSpro*)
- CFLAGSO="$CFLAGS -O2"
- CFLAGSPIC="-KPIC"
- ;;
-
- intel_icc*)
- CFLAGSO="$CFLAGS -O2 -unroll"
- case "$CC_VERSION" in
- intel_icc5 | intel_icc6 | intel_icc7 | intel_icc8 | intel_icc9)
- CFLAGSPIC="-KPIC"
- ;;
-
- intel_icc*)
- CFLAGSPIC="-fPIC"
- ;;
- esac
-
- dnl To reduce output, use -opt_report_levelmin where possible,
- dnl i.e. post icc5. from icc10 onwards, this flag is called
- dnl -opt-report, and -vec-report controls output of the
- dnl autovectorizer (to make things simpler, one of the two options
- dnl wants a space between option and level, whereas the other does
- dnl not)
- case "$CC_VERSION" in
- intel_icc5)
- ;;
- intel_icc6 | intel_icc7 | intel_icc8 | intel_icc9)
- CFLAGSO="$CFLAGSO -opt_report_levelmin"
- ;;
- *)
- CFLAGSO="$CFLAGSO -opt-report 0 -vec-report0"
- ;;
- esac
-
- CFLAGSO="$CFLAGSO -ansi_alias -vec_report0"
-
- dnl If we are on an x86 platform, add -tpp6 to optimization
- dnl flags
- case "$target" in
- *86*)
- case "$CC_VERSION" in
- intel_icc5)
- ;;
- intel_icc6 | intel_icc7 | intel_icc8 | intel_icc9)
- CFLAGSO="$CFLAGSO -tpp6"
- ;;
- *)
- CFLAGSO="$CFLAGSO -mcpu=pentium4"
- ;;
- esac
- ;;
- esac
-
- dnl Check whether we can switch off the annoying 1572 warning
- dnl message about unreliable floating point comparisons
- DEAL_II_ICC_C_WD_1572
-
- ;;
-
- clang)
- CFLAGS="$CFLAGS -g"
- CFLAGSO="$CFLAGS -fast -O2"
- CFLAGSPIC="-fPIC"
- ;;
-
- sun_cc*)
- CFLAGS="$CFLAGS -g"
- CFLAGSO="$CFLAGS -fast -O2"
- CFLAGSPIC="-fPIC"
- ;;
-
- *)
- AC_MSG_RESULT(Unknown C compiler - using generic options)
- CFLAGSO="$CFLAGSO -O2"
- ;;
- esac
- fi
-])
-
-
-dnl -------------------------------------------------------------
-dnl
-dnl Check whether we can use -rpath for linking. If so, we can use
-dnl -rpath instead of -L in LDFLAGS below, so the dynamic linker
-dnl finds all libraries.
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_RPATH,
-[ OLD_LDFLAGS="$LDFLAGS"
- LDFLAGS="-Wl,-rpath,$DEAL_II_PATH/lib $LDFLAGS"
- AC_MSG_CHECKING([whether compiler understands option -Wl,-rpath])
- AC_LINK_IFELSE(
- [ AC_LANG_PROGRAM([[]],[[]])],
- [ AC_MSG_RESULT(yes)
- LD_PATH_OPTION="-Wl,-rpath,"
- DEAL_II_LD_UNDERSTANDS_RPATH=yes
- ],
- [ AC_MSG_RESULT(no)
- LDFLAGS="$OLD_LDFLAGS"
- LD_PATH_OPTION="no"
- ])
- AC_SUBST(DEAL_II_LD_UNDERSTANDS_RPATH)
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl
-dnl Check whether we can use -soname for linking in the shared
-dnl library version. On Mac OS X, -soname is called
-dnl -dylib_install_name
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_LINK_SONAME,
-[
- dnl First try -soname
- OLD_LDFLAGS="$LDFLAGS"
- LDFLAGS="-Wl,-soname,libbase.so.6.2.1 $LDFLAGS $LDFLAGSPIC $SHLIBFLAGS"
- AC_MSG_CHECKING([whether compiler understands option -Wl,-soname])
- AC_LINK_IFELSE(
- [ AC_LANG_PROGRAM([[]],[[]])],
- [
- AC_MSG_RESULT(yes)
- DEAL_II_LD_UNDERSTANDS_SONAME="yes"
- ],
- [
- AC_MSG_RESULT(no)
- DEAL_II_LD_UNDERSTANDS_SONAME="no"
- ]
- )
- LDFLAGS="$OLD_LDFLAGS"
- AC_SUBST(DEAL_II_LD_UNDERSTANDS_SONAME)
-
- dnl Now try the -dylib_install_name thing
- OLD_LDFLAGS="$LDFLAGS"
- LDFLAGS="-Wl,-dynamic,-install_name -Wl,libbase.so.6.2.1 $LDFLAGS -shared"
- AC_MSG_CHECKING([whether compiler understands option -Wl,-dynamic,-install_name])
- AC_LINK_IFELSE(
- [ AC_LANG_PROGRAM([[]],[[]])],
- [
- AC_MSG_RESULT(yes)
- DEAL_II_LD_UNDERSTANDS_DYLIB_INSTALL_NAME="yes"
- ],
- [
- AC_MSG_RESULT(no)
- DEAL_II_LD_UNDERSTANDS_DYLIB_INSTALL_NAME="no"
- ]
- )
- LDFLAGS="$OLD_LDFLAGS"
- AC_SUBST(DEAL_II_LD_UNDERSTANDS_DYLIB_INSTALL_NAME)
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl Check whether user wants optimization for a certain type of
-dnl CPU. If so, then set some flags, dependent on what he
-dnl wants and the compiler. Not very many CPUS are listed here,
-dnl but this is simple to expand if desired.
-dnl
-dnl To use this feature, use --with-cpu=something
-dnl
-dnl Usage: DEAL_II_CHECK_CPU_OPTIMIZATIONS
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_CPU_OPTIMIZATIONS, dnl
-[
- AC_ARG_WITH(cpu,
- [AS_HELP_STRING([--with-cpu=cpu],
- [Optimize specifically for the given CPU type, rather than just generating code for this processor family.])],
- withcpu="$withval",
- withcpu="")
- AC_MSG_CHECKING(for CPU to optimize for)
- case "$withcpu" in
- PowerPC64)
- AC_MSG_RESULT(PowerPC64)
- case "$GXX_VERSION" in
- gcc*)
- dnl Tune for this processor
- CXXFLAGSG="$CXXFLAGSG -maix64"
- CXXFLAGSO="$CXXFLAGSO -maix64 -mpowerpc64 -mcpu=powerpc64 -mtune=powerpc64"
-
- dnl On this stupid system, we get TOC overflows if we use the
- dnl standard flags, so restrict TOC entries to the absolute minimal
- CXXFLAGSG="$CXXFLAGSG -mminimal-toc"
- CXXFLAGSO="$CXXFLAGSO -mminimal-toc"
-
- dnl Also set 64-bit mode for f77 compiler, assuming we use IBM's xlf
- F77FLAGSG="$F77FLAGSG -q64"
- F77FLAGSO="$F77FLAGSO -q64"
-
- dnl When generating 64-bit code, we need to pass respective flags when
- dnl linking (also for static libs)
- AR="$AR -X 64"
- LDFLAGS="$LDFLAGS -maix64"
-
- dnl And we must always link with pthreads
- DEAL_II_ADD_EXTERNAL_LIBS_AT_TAIL(-lpthread)
- ;;
- esac
- ;;
- athlon* | pentium* | i386 | i486 | i586 | i686 | k6* | winchip* | opteron)
- AC_MSG_RESULT(x86 derivate ($withcpu))
- case "$GXX_VERSION" in
- gcc*)
- dnl Tune for this processor
- CXXFLAGSG="$CXXFLAGSG -march=$withcpu"
- CXXFLAGSO="$CXXFLAGSO -march=$withcpu"
-
- dnl Also set the mode for f77 compiler
- F77FLAGSG="$F77FLAGSG -march=$withcpu"
- F77FLAGSO="$F77FLAGSO -march=$withcpu"
- ;;
- esac
- ;;
-
- native)
- AC_MSG_RESULT(native processor variant)
- case "$GXX_VERSION" in
- gcc*)
- dnl Tune for this processor
- CXXFLAGSG="$CXXFLAGSG -march=native"
- CXXFLAGSO="$CXXFLAGSO -march=native"
-
- dnl Also set the mode for f77 compiler
- F77FLAGSG="$F77FLAGSG -march=native"
- F77FLAGSO="$F77FLAGSO -march=native"
- ;;
-
- intel_icc*)
- dnl Same, but for the icc compiler
- CXXFLAGSO="$CXXFLAGSO -xhost"
- CXXFLAGSG="$CXXFLAGSG -xhost"
- ;;
- esac
- ;;
-
- *)
- AC_MSG_RESULT(none given or not recognized)
- ;;
- esac
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl Check whether the compiler allows for vectorization and that
-dnl vectorization actually works. For this test, we use compiler
-dnl intrinsics similar to what is used in the deal.II library and
-dnl check whether the arithmetic operations are correctly performed
-dnl on examples where all numbers are exactly represented as
-dnl floating point numbers.
-dnl
-dnl Usage: DEAL_II_COMPILER_VECTORIZATION_LEVEL
-dnl 0 means no vectorization, 1 support for SSE2, 2 support for AVX
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_DETECT_VECTORIZATION_LEVEL, dnl
-[
- AC_LANG(C++)
- CXXFLAGS="$CXXFLAGSG"
- dnl SSE2 check in debug mode
- AC_MSG_CHECKING(whether CPU supports SSE2)
- AC_TRY_RUN(
- [
-#include <emmintrin.h>
-#include <mm_malloc.h>
- int main()
- {
- __m128d a, b;
- const unsigned int vector_bytes = sizeof(__m128d);
- const int n_vectors = vector_bytes/sizeof(double);
- __m128d * data =
- reinterpret_cast<__m128d*>(_mm_malloc (2*vector_bytes, vector_bytes));
- double * ptr = reinterpret_cast<double*>(&a);
- ptr[0] = (volatile double)(1.0);
- for (int i=1; i<n_vectors; ++i)
- ptr[i] = 0.0;
- b = _mm_set1_pd ((volatile double)(2.25));
- data[0] = _mm_add_pd (a, b);
- data[1] = _mm_mul_pd (b, data[0]);
- ptr = reinterpret_cast<double*>(&data[1]);
- unsigned int return_value = 0;
- if (ptr[0] != 7.3125)
- return_value = 1;
- for (int i=1; i<n_vectors; ++i)
- if (ptr[i] != 5.0625)
- return_value = 1;
- _mm_free (data);
- return return_value;
- }
- ],
- [
- AC_MSG_RESULT(yes)
- dnl AVX check in debug mode
- AC_MSG_CHECKING(whether CPU supports AVX)
- AC_TRY_RUN(
- [
-#include <immintrin.h>
-#include <mm_malloc.h>
- int main()
- {
- __m256d a, b;
- const unsigned int vector_bytes = sizeof(__m256d);
- const int n_vectors = vector_bytes/sizeof(double);
- __m256d * data =
- reinterpret_cast<__m256d*>(_mm_malloc (2*vector_bytes, vector_bytes));
- double * ptr = reinterpret_cast<double*>(&a);
- ptr[0] = (volatile double)(1.0);
- for (int i=1; i<n_vectors; ++i)
- ptr[i] = 0.0;
- b = _mm256_set1_pd ((volatile double)(2.25));
- data[0] = _mm256_add_pd (a, b);
- data[1] = _mm256_mul_pd (b, data[0]);
- ptr = reinterpret_cast<double*>(&data[1]);
- unsigned int return_value = 0;
- if (ptr[0] != 7.3125)
- return_value = 1;
- for (int i=1; i<n_vectors; ++i)
- if (ptr[i] != 5.0625)
- return_value = 1;
- _mm_free (data);
- }
- ],
- [
- AC_MSG_RESULT(yes)
- AC_DEFINE(DEAL_II_COMPILER_VECTORIZATION_LEVEL, 2,
- [Equal to 0 in the generic case,
- equal to 1 if CPU compiled for supports SSE2,
- equal to 2 if CPU compiled for supports AVX])
- ],
- [
- AC_MSG_RESULT(no)
- AC_DEFINE(DEAL_II_COMPILER_VECTORIZATION_LEVEL, 1,
- [Equal to 0 in the generic case,
- equal to 1 if CPU compiled for supports SSE2,
- equal to 2 if CPU compiled for supports AVX])
- ])
- ],
- [
- AC_DEFINE(DEAL_II_COMPILER_VECTORIZATION_LEVEL, 0,
- [Equal to 0 in the generic case,
- equal to 1 if CPU compiled for supports SSE2,
- equal to 2 if CPU compiled for supports AVX])
- AC_MSG_RESULT(no)
- ])
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl Check whether the compiler allows to use arithmetic operations
-dnl +-*/ on vectorized data types or whether we need to use
-dnl _mm_add_pd for addition and so on. +-*/ is preferred because
-dnl it allows the compiler to choose other optimizations like
-dnl fused multiply add, whereas _mm_add_pd explicitly enforces the
-dnl assembler command.
-dnl
-dnl Usage: DEAL_II_COMPILER_USE_VECTOR_ARITHMETICS
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_VECTOR_ARITHMETICS, dnl
-
-[
- AC_MSG_CHECKING(whether compiler supports vector arithmetics)
- AC_LANG(C++)
- CXXFLAGS="$CXXFLAGSG"
- AC_TRY_COMPILE(
- [
-#include <emmintrin.h>
- ],
- [
- __m128d a, b;
- a = _mm_set_sd (1.0);
- b = _mm_set1_pd (2.1);
- __m128d c = a + b;
- __m128d d = b - c;
- __m128d e = c * a + d;
- __m128d f = e/a;
- (void)f;
- ],
- [
- AC_MSG_RESULT(yes)
- AC_DEFINE(DEAL_II_COMPILER_USE_VECTOR_ARITHMETICS, 1,
- [Defined if the compiler can use arithmetic operations on
- vectorized data types])
- ],
- [
- AC_MSG_RESULT(no)
- ])
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl Try whether the set of compiler flags in CXXFLAGS is reasonable, i.e.
-dnl does not result in compiler messages (which are then produced by
-dnl unknown or unrecognized compiler flags. This macro is mostly copied
-dnl from the definition of AC_TRY_COMPILE, but the first two arguments are
-dnl omitted and some other things are also simplified.
-dnl
-dnl Usage:
-dnl DEAL_II_TRY_COMPILER_FLAG([ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_TRY_COMPILER_FLAG, dnl
-[
- echo 'int main() { return 0; }' > conftest.$ac_ext
-
- dnl lets see whether the compiler generates output to stdout or stderr
- deal_II_compiler_output=`eval $ac_compile 2>&1`
- if test ! "$deal_II_compiler_output"; then
- ifelse([$1], , :,
- [
- rm -rf conftest*
- $1
- ])
- else
- echo "configure: failed program was:" >&AC_FD_CC
- cat conftest.$ac_ext >&AC_FD_CC
- ifelse([$2], , ,
- [
- rm -rf conftest*
- $2
- ])
- fi
- rm -f conftest*
-])
-
-
-
-
-dnl -------------------------------------------------------------
-dnl Check if the declared prototype of abort() has a throw()
-dnl specification. We overload abort() in our testsuite, so have
-dnl to make sure that we match the exception specification
-dnl correctly.
-dnl
-dnl Usage: DEAL_II_CHECK_ABORT
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_ABORT, dnl
-[
- AC_MSG_CHECKING([for exception specifications on abort()])
- AC_LANG(C++)
- CXXFLAGS="-Werror $CXXFLAGSG"
- AC_TRY_COMPILE(
- [
-#include <cstdlib>
-extern "C" void abort () { for(;;) ; }
- ],
- [
- ],
- [
- AC_MSG_RESULT(none)
- ],
- [
- AC_MSG_RESULT(yes)
- AC_DEFINE(DEAL_II_ABORT_NOTHROW_EXCEPTION, 1,
- [Defined if the prototype of abort() has a no-throw
- exception specification.])
- ])
-]
-)
-
-
-
-
-dnl -------------------------------------------------------------
-dnl We'd like to use the `isnan' function. On some systems, this is
-dnl simply declared in <math.h> (or <cmath>, for what it's worth), but
-dnl on Linux for example, it is only declared if we specifically require
-dnl support for ISO C 99. This macro checks whether `isnan' is declared
-dnl or whether we have to pass special compiler flags, namely
-dnl -D_ISOC99_SOURCE (Linux) or -D__EXTENSIONS__ (Sun). Note that when
-dnl checking we have to use the two sets of compiler flags.
-dnl
-dnl Usage: DEAL_II_CHECK_ISNAN
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_ISNAN, dnl
-[
- DEAL_II_CHECK_ISNAN_FLAG(debug, $CXXFLAGSG,
- CXXFLAGSG="$deal_II_isnan_flag $CXXFLAGSG")
- DEAL_II_CHECK_ISNAN_FLAG(optimized, $CXXFLAGSO,
- CXXFLAGSO="$deal_II_isnan_flag $CXXFLAGSO")
-]
-)
-
-
-
-dnl -------------------------------------------------------------
-dnl The following function actually performs the check for the right flag
-dnl for `isnan'. If a flag is found, the third argument is executed, and
-dnl the right flag is available in $deal_II_isnan_flag.
-dnl
-dnl Usage: DEAL_II_CHECK_ISNAN_FLAG("description of options set",
-dnl "compiler options set",
-dnl action when flag is found)
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_ISNAN_FLAG, dnl
-[
- AC_MSG_CHECKING(whether isnan is declared with $1 flags)
- AC_LANG(C++)
- CXXFLAGS="$2"
- deal_II_isnan_flag=""
- AC_TRY_COMPILE(
- [
-#include <cmath>
- ],
- [
- double d=0;
- isnan (d);
- ],
- [
- AC_MSG_RESULT(yes)
- deal_II_isnan_flag="-DHAVE_ISNAN"
- $3
- ])
-
-
- if test "x$deal_II_isnan_flag" = "x" ; then
- dnl Simply using isnan doesn't work. On Microsoft Windows systems, the
- dnl function is called _isnan, so check that
- AC_TRY_COMPILE(
- [
-#include <cmath>
- ],
- [
- double d=0;
- _isnan (d);
- ],
- [
- AC_MSG_RESULT(yes)
- deal_II_isnan_flag="-DHAVE_UNDERSCORE_ISNAN"
- $3
- ])
- fi
-
-
- dnl Let's see whether we _now_ have found something
- if test "x$deal_II_isnan_flag" = "x" ; then
- dnl We need to define something. Unfortunately, this is system
- dnl dependent (argh!)
- deal_II_isnan_flag=""
- for testflag in -D_ISOC99_SOURCE -D__EXTENSIONS__ ; do
- CXXFLAGS="$2 $testflag"
- AC_TRY_COMPILE(
- [
-#include <cmath>
- ],
- [
- double d=0;
- isnan (d);
- ],
- [
- dnl We found a flag by which isnan is defined; store
- dnl this flag and exit the loop
- deal_II_isnan_flag="-DHAVE_ISNAN $testflag"
- break;
- ])
-
- dnl If that didn't work (and it didn't as we are still inside the
- dnl loop), then try the _isnan function (maybe we are on a
- dnl Microsoft Windows system)
- AC_TRY_COMPILE(
- [
-#include <cmath>
- ],
- [
- double d=0;
- _isnan (d);
- ],
- [
- dnl We found a flag by which isnan is defined; store
- dnl this flag and exit the loop
- deal_II_isnan_flag="-DHAVE_UNDERSCORE_ISNAN $testflag"
- break;
- ])
- done
-
- dnl if no such flag was found, then abort ./configure since
- dnl the library will not be compilable on this platform
- dnl without knowledge of the right flag
- if test "x$deal_II_isnan_flag" = "x" ; then
- AC_MSG_RESULT(no.)
- else
- dnl we found something, lets us it
- AC_MSG_RESULT(using $testflag)
- $3
- fi
- fi
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl See if the isfinite function is available in namespace std
-dnl (this function is C99 and therefore not part of C++98, but
-dnl some implementations provide it nevertheless).
-dnl
-dnl Usage: DEAL_II_CHECK_ISFINITE
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_ISFINITE, dnl
-[
- AC_MSG_CHECKING(for std::isfinite)
- AC_LANG(C++)
- CXXFLAGS="$CXXFLAGSG"
- AC_TRY_COMPILE(
- [
-#include <cmath>
- ],
- [
- double d=0;
- std::isfinite (d);
- ],
- [
- AC_MSG_RESULT(yes)
- AC_DEFINE(DEAL_II_HAVE_ISFINITE, 1,
- [Defined if std::isfinite is available])
- ],
- [
- AC_MSG_RESULT(no)
- ])
-])
-
-
-
-
-
-dnl -------------------------------------------------------------
-dnl rand_r is defined for some compiler flag combinations, but not for
-dnl others. check that. note that since these are C++ flags, we can't
-dnl just use AC_CHECK_FUNCS
-dnl
-dnl Usage: DEAL_II_CHECK_RAND_R
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_RAND_R, dnl
-[
- AC_MSG_CHECKING(for rand_r)
- AC_LANG(C++)
- CXXFLAGS="$CXXFLAGSG"
- AC_TRY_COMPILE(
- [
-#include <cstdlib>
- ],
- [
-unsigned int seed = 0;
-int i=rand_r(&i);
- ],
- [
- AC_MSG_RESULT(yes)
- AC_DEFINE(HAVE_RAND_R, 1,
- [Define if you have the rand_r function])
- ],
- [
- AC_MSG_RESULT(no)
- ]
- )
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl On some systems (well, DEC Alphas are the only ones we know of),
-dnl gcc2.95 throws the hands in the air if it sees one of the AssertThrow
-dnl calls, and dies with an internal compiler error. If this is the case,
-dnl we disable AssertThrow and simply replace it with an `abort' if the
-dnl condition is not satisfied.
-dnl
-dnl Usage: DEAL_II_CHECK_ASSERT_THROW("description of options set",
-dnl "compiler options set",
-dnl action if compiler crashes)
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_ASSERT_THROW, dnl
-[
- AC_MSG_CHECKING(whether AssertThrow works with $1 flags)
- AC_LANG(C++)
- CXXFLAGS="$2"
- AC_TRY_COMPILE(
- [
-#include <exception>
-#include <iostream>
-#include <cstdlib>
-
-#ifndef __GNUC__
-# define __PRETTY_FUNCTION__ "(unknown)"
-#endif
-class ExceptionBase : public std::exception {
- public:
- ExceptionBase ();
- ExceptionBase (const char* f, const int l, const char *func,
- const char* c, const char *e);
- virtual ~ExceptionBase () throw();
- void SetFields (const char *f, const int l, const char *func,
- const char *c, const char *e);
- void PrintExcData (std::ostream &out) const;
- virtual void PrintInfo (std::ostream &out) const;
- virtual const char * what () const throw ();
- protected:
- const char *file;
- unsigned int line;
- const char *function, *cond, *exc;
-};
-
-template <class exc>
-void __IssueError_Assert (const char *file,
- int line,
- const char *function,
- const char *cond,
- const char *exc_name,
- exc e){
- e.SetFields (file, line, function, cond, exc_name);
- std::cerr << "--------------------------------------------------------"
- << std::endl;
- e.PrintExcData (std::cerr);
- e.PrintInfo (std::cerr);
- std::cerr << "--------------------------------------------------------"
- << std::endl;
- std::abort ();
-}
-
-template <class exc>
-void __IssueError_Throw (const char *file,
- int line,
- const char *function,
- const char *cond,
- const char *exc_name,
- exc e) {
- // Fill the fields of the exception object
- e.SetFields (file, line, function, cond, exc_name);
- throw e;
-}
-
-#define AssertThrow(cond, exc) \
- { \
- if (!(cond)) \
- __IssueError_Throw (__FILE__, \
- __LINE__, \
- __PRETTY_FUNCTION__, #cond, #exc, exc); \
- }
-
-#define DeclException0(Exception0) \
-class Exception0 : public ExceptionBase {}
-
-namespace StandardExceptions
-{
- DeclException0 (ExcInternalError);
-}
-using namespace StandardExceptions;
- ],
- [
- AssertThrow (false, ExcInternalError());
- ],
- [
- AC_MSG_RESULT(yes)
- ],
- [
- AC_MSG_RESULT(no)
- $3
- ])
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl Gcc and some other compilers have __PRETTY_FUNCTION__, showing
-dnl an unmangled version of the function we are presently in,
-dnl while __FUNCTION__ (or __func__ in ISO C99) simply give the
-dnl function name which would not include the arguments of that
-dnl function, leading to problems in C++ with overloaded function
-dnl names.
-dnl
-dnl If __PRETTY_FUNCTION__ is not available, try to find out whether
-dnl __func__ is available and use the preprocessor to set the first
-dnl thing to the second. If this is also not the case, then set it
-dnl to something indicating non-availability.
-dnl
-dnl Usage: DEAL_II_HAVE_PRETTY_FUNCTION
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_HAVE_PRETTY_FUNCTION, dnl
-[
- AC_MSG_CHECKING(for __PRETTY_FUNCTION__)
- AC_LANG(C++)
- CXXFLAGS="$CXXFLAGSG"
- AC_TRY_COMPILE(
- [
-# include <iostream>
- ],
- [
- std::cout << __PRETTY_FUNCTION__ << std::endl;
- ],
- [
- AC_MSG_RESULT(yes)
- ],
- [
- AC_MSG_RESULT(no)
- AC_MSG_CHECKING(for __func__)
- AC_TRY_COMPILE(
- [
-# include <iostream>
- ],
- [
- std::cout << __func__ << std::endl;
- ],
- [
- AC_MSG_RESULT(yes)
- x=__func__
- ],
- [
- AC_MSG_RESULT(no)
- x="\"(not available)\""
- ])
- AC_DEFINE_UNQUOTED(__PRETTY_FUNCTION__, $x,
- [If already available, do not define at all. Otherwise, define
- to __func__ if that is available. In all other cases,
- indicate that no information about the present function
- is available for this compiler.])
- ])
-])
-
-
-
-dnl -------------------------------------------------------------
-dnl In the gcc libstdc++ headers for std::complex, there is
-dnl no defined default copy constructor, but a templated copy
-dnl constructor. So when using using a normal assignment
-dnl between identical types, the compiler synthesizes the
-dnl default operator, rather than using the template.
-dnl The code will still be ok, though.
-dnl
-dnl With -Wsynth in gcc we then get a warning. So if we find that
-dnl this is still the case, disable -Wsynth, i.e. remove it from
-dnl the list of warning flags.
-dnl
-dnl This is gcc bug 18644:
-dnl http://gcc.gnu.org/bugzilla/show_bug.cgi?id=18644
-dnl
-dnl Usage: DEAL_II_CHECK_WSYNTH_AND_STD_COMPLEX
-dnl
-dnl -------------------------------------------------------------
-AC_DEFUN(DEAL_II_CHECK_WSYNTH_AND_STD_COMPLEX, dnl
-[
- if test "x$GXX" = "xyes" ; then
- AC_MSG_CHECKING(for problem with -Wsynth and std::complex)
- AC_LANG(C++)
- CXXFLAGS="-Wsynth -Werror"
- AC_TRY_COMPILE(
- [
-# include <complex>
- ],
- [
- std::complex<double> x;
- x = std::complex<double>(1,0);
- ],
- [
- AC_MSG_RESULT(no)
- ],
- [
- AC_MSG_RESULT(yes)
- CXXFLAGSG="`echo $CXXFLAGSG | perl -pi -e 's/-Wsynth\s*//g;'`"
- ])
- fi
-])