From d15feace0b08218ef841190baa70a43205099c58 Mon Sep 17 00:00:00 2001 From: maier Date: Wed, 12 Sep 2012 15:41:04 +0000 Subject: [PATCH] Major update of the feature configuration portion git-svn-id: https://svn.dealii.org/branches/branch_cmake@26314 0785d39b-7218-0410-832d-ea1e28bc413d --- deal.II/CMakeLists.txt | 5 +- deal.II/aclocal.m4 | 1460 +--------- deal.II/cmake-TODO | 4 + deal.II/compiler-mumbo-jumbo.m4 | 2386 ----------------- .../cmake/configure/configure_boost.cmake | 23 +- .../configure/configure_functionparser.cmake | 10 +- .../cmake/configure/configure_mpi.cmake | 4 +- .../cmake/configure/configure_threads.cmake | 14 +- .../cmake/configure/configure_umfpack.cmake | 6 +- 9 files changed, 43 insertions(+), 3869 deletions(-) delete mode 100644 deal.II/compiler-mumbo-jumbo.m4 diff --git a/deal.II/CMakeLists.txt b/deal.II/CMakeLists.txt index f23f7fd988..c54859bbbe 100644 --- a/deal.II/CMakeLists.txt +++ b/deal.II/CMakeLists.txt @@ -154,11 +154,10 @@ OPTION(DEAL_II_FORCE_CONTRIB_UMFPACK # library can be compiled: ADD_CUSTOM_TARGET(deal_ii_target_dependencies) -# used to keep track of external libraries and necessary link flags +# used to keep track of external libraries and necessary linker flags SET(deal_ii_external_libraries "") SET(deal_ii_external_debug_libraries "") -SET(deal_ii_required_libraries "") # TODO -SET(deal_II_required_link_flags "") +SET(deal_II_required_linker_flags "") diff --git a/deal.II/aclocal.m4 b/deal.II/aclocal.m4 index c3ff58128b..9f3a1d3bb1 100644 --- a/deal.II/aclocal.m4 +++ b/deal.II/aclocal.m4 @@ -1,73 +1,3 @@ -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. @@ -352,40 +282,6 @@ AC_DEFUN(DEAL_II_DETERMINE_CXX_BRAND, dnl -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_Init (0,0); - ], - [ - AC_MSG_RESULT(yes) - AC_DEFINE(DEAL_II_COMPILER_SUPPORTS_MPI, 1, - [Defined if the compiler supports including ]) - - 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 @@ -1150,73 +1046,6 @@ AC_DEFUN(DEAL_II_SET_CXX_DEBUG_FLAG, dnl -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 @@ -1973,239 +1802,6 @@ AC_DEFUN(DEAL_II_CHECK_CPU_OPTIMIZATIONS, dnl -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 -#include - 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(&a); - ptr[0] = (volatile double)(1.0); - for (int i=1; i(&data[1]); - unsigned int return_value = 0; - if (ptr[0] != 7.3125) - return_value = 1; - for (int i=1; i -#include - 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(&a); - ptr[0] = (volatile double)(1.0); - for (int i=1; i(&data[1]); - unsigned int return_value = 0; - if (ptr[0] != 7.3125) - return_value = 1; - for (int i=1; i - ], - [ - __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 @@ -2312,43 +1908,6 @@ AC_DEFUN(DEAL_II_CHECK_COMPAT_BLOCKER, dnl -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 @@ -2394,241 +1953,6 @@ AC_DEFUN(DEAL_II_CHECK_GETRUSAGE, dnl - -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 -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 (or , 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 - ], - [ - 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 - ], - [ - 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 - ], - [ - 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 - ], - [ - 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 - ], - [ - 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 - ], - [ -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 @@ -2725,67 +2049,8 @@ using namespace StandardExceptions; 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 - ], - [ - std::cout << __PRETTY_FUNCTION__ << std::endl; - ], - [ - AC_MSG_RESULT(yes) - ], - [ - AC_MSG_RESULT(no) - AC_MSG_CHECKING(for __func__) - AC_TRY_COMPILE( - [ -# include - ], - [ - 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 ]) ]) @@ -4434,29 +3699,6 @@ void create_graph (types::Graph) -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 @@ -4559,104 +3801,6 @@ AC_DEFUN(DEAL_II_ICC_C_WD_1572, dnl - -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 - -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 @@ -4699,194 +3843,6 @@ AC_DEFUN(DEAL_II_CHECK_ADVANCE_WARNING, dnl -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 capacity) - AC_TRY_RUN( - [ -#include -int main () { - std::vector 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 can - always hold, i.e. its minimal capacity.]) - ] - ) - - dnl Do same thing with std::vector - AC_MSG_CHECKING(for minimal std::vector capacity) - AC_TRY_RUN( - [ -#include -int main () { - std::vector 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 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 -#include - ], - [ - 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 -#include -#include -#include - -struct empty { }; - -template - struct bar { }; - ], - [ - int status; - char *realname; - - // exception classes not in , 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 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 @@ -5262,101 +4218,6 @@ AC_DEFUN(DEAL_II_CONFIGURE_TECPLOT, dnl -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 - ]], - [[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 @@ -6399,251 +5260,6 @@ AC_DEFUN(DEAL_II_CHECK_TRILINOS_HEADER_FILES, dnl 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 -dnl Copyright (c) 2010 Rhys Ulerich -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= 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= 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= 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 -]) - - @@ -6899,78 +5515,6 @@ AC_DEFUN(DEAL_II_CONFIGURE_METIS, dnl ]) -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 diff --git a/deal.II/cmake-TODO b/deal.II/cmake-TODO index f5af3a6a2e..7da4bd742a 100644 --- a/deal.II/cmake-TODO +++ b/deal.II/cmake-TODO @@ -6,6 +6,8 @@ Next steps: * Add Bugs, Regressions and Feature tests. +* HDF5 + * PETSC * TRILINOS @@ -17,3 +19,5 @@ Next steps: * ARPACK * METIS + +* HSL ??? diff --git a/deal.II/compiler-mumbo-jumbo.m4 b/deal.II/compiler-mumbo-jumbo.m4 deleted file mode 100644 index 0880785d94..0000000000 --- a/deal.II/compiler-mumbo-jumbo.m4 +++ /dev/null @@ -1,2386 +0,0 @@ -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 - ], - [;], - [ - 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 -# include - ], - [;], - [ - 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 void f (T* const); - dnl template 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 - 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(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 or - dnl . 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 -# include - using namespace std; - - typedef map > > T; - - bool f(T& t1, const T* t2) { - t1["s"] = map >(); - map > > - ::const_iterator i2=t1.begin(); - map > > - ::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 ], - [ std::array 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 ], - [ 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 - void f(int, double); ], - [ std::function - 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 - void f(int); ], - [ using namespace std; - using namespace std::placeholders; - bind(multiplies(),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 ], - [ std::shared_ptr 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 - 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 - 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 ], - [ 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 ], - [ std::tuple 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 ], - [ const bool m0 = std::is_trivial::value; - const bool m1 = std::is_standard_layout::value; - const bool m2 = std::is_pod::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 ], - [ - std::vector 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 ], - [ - std::vector v; - for (std::vector::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 -#include - 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(&a); - ptr[0] = (volatile double)(1.0); - for (int i=1; i(&data[1]); - unsigned int return_value = 0; - if (ptr[0] != 7.3125) - return_value = 1; - for (int i=1; i -#include - 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(&a); - ptr[0] = (volatile double)(1.0); - for (int i=1; i(&data[1]); - unsigned int return_value = 0; - if (ptr[0] != 7.3125) - return_value = 1; - for (int i=1; i - ], - [ - __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 -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 (or , 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 - ], - [ - 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 - ], - [ - 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 - ], - [ - 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 - ], - [ - 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 - ], - [ - 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 - ], - [ -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 -#include -#include - -#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 -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 -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 - ], - [ - std::cout << __PRETTY_FUNCTION__ << std::endl; - ], - [ - AC_MSG_RESULT(yes) - ], - [ - AC_MSG_RESULT(no) - AC_MSG_CHECKING(for __func__) - AC_TRY_COMPILE( - [ -# include - ], - [ - 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 - ], - [ - std::complex x; - x = std::complex(1,0); - ], - [ - AC_MSG_RESULT(no) - ], - [ - AC_MSG_RESULT(yes) - CXXFLAGSG="`echo $CXXFLAGSG | perl -pi -e 's/-Wsynth\s*//g;'`" - ]) - fi -]) diff --git a/deal.II/contrib/cmake/configure/configure_boost.cmake b/deal.II/contrib/cmake/configure/configure_boost.cmake index a9a8566101..f48d37a163 100644 --- a/deal.II/contrib/cmake/configure/configure_boost.cmake +++ b/deal.II/contrib/cmake/configure/configure_boost.cmake @@ -1,15 +1,14 @@ -IF(DEAL_II_ALLOW_CONTRIB) - FIND_PACKAGE (Boost COMPONENTS serialization thread) -ELSE() - FIND_PACKAGE (Boost COMPONENTS serialization thread REQUIRED) -ENDIF() +IF(NOT DEAL_II_FORCE_CONTRIB_BOOST) -# -# Get rid of this annoying unimportant variable: -# -MARK_AS_ADVANCED(Boost_DIR) + IF(DEAL_II_ALLOW_CONTRIB) + FIND_PACKAGE (Boost COMPONENTS serialization thread) + ELSE() + FIND_PACKAGE (Boost COMPONENTS serialization thread REQUIRED) + ENDIF() + + # Get rid of this annoying unimportant variable: + MARK_AS_ADVANCED(Boost_DIR) -IF(NOT DEAL_II_FORCE_CONTRIB_BOOST) IF(Boost_THREAD_FOUND AND Boost_SERIALIZATION_FOUND) INCLUDE_DIRECTORIES (${Boost_INCLUDE_DIR}) @@ -22,4 +21,8 @@ IF(NOT DEAL_II_FORCE_CONTRIB_BOOST) SET(DEAL_II_USE_EXTERNAL_BOOST TRUE) ENDIF() + ENDIF() + +# ELSE() nothing to do. We compile the necessary boost source files +# directly if DEAL_II_USE_EXTERNAL_BOOST is not set. diff --git a/deal.II/contrib/cmake/configure/configure_functionparser.cmake b/deal.II/contrib/cmake/configure/configure_functionparser.cmake index 2721f8447d..a429c212c9 100644 --- a/deal.II/contrib/cmake/configure/configure_functionparser.cmake +++ b/deal.II/contrib/cmake/configure/configure_functionparser.cmake @@ -1,7 +1,9 @@ -IF(DEAL_II_ALLOW_CONTRIB) - # TODO: Write a module to search for functionparser -ELSE() - MESSAGE(FATAL_ERROR "FindFunctionparser.cmake not written, yet. :-[") +IF(NOT DEAL_II_FORCE_CONTRIB_FUNCTIONPARSER) + IF(DEAL_II_ALLOW_CONTRIB) + # TODO: Write a module to search for functionparser + ELSE() + MESSAGE(FATAL_ERROR "FindFunctionparser.cmake not written, yet. :-[") + ENDIF() ENDIF() IF(DEAL_II_FORCE_CONTRIB_FUNCTIONPARSER OR NOT Functionparser_FOUND) diff --git a/deal.II/contrib/cmake/configure/configure_mpi.cmake b/deal.II/contrib/cmake/configure/configure_mpi.cmake index 3813254485..c0881018db 100644 --- a/deal.II/contrib/cmake/configure/configure_mpi.cmake +++ b/deal.II/contrib/cmake/configure/configure_mpi.cmake @@ -2,14 +2,14 @@ FIND_PACKAGE(MPI REQUIRED CXX) INCLUDE_DIRECTORIES(${MPI_CXX_INCLUDE_PATH}) +LIST(APPEND deal_II_required_linker_flags ${MPI_CXX_LINK_FLAGS}) LIST(APPEND deal_ii_external_libraries ${MPI_CXX_LIBRARIES}) LIST(APPEND deal_ii_external_debug_libraries ${MPI_CXX_LIBRARIES}) -LIST(APPEND deal_II_required_link_flags ${MPI_CXX_LINK_FLAGS}) SET(DEAL_II_COMPILER_SUPPORTS_MPI TRUE) -# MPI_CXX_COMPILER MPI Compiler wrapper for +# MPI_CXX_COMPILER MPI Compiler wrapper for CXX # MPI_CXX_COMPILE_FLAGS Compilation flags for MPI programs diff --git a/deal.II/contrib/cmake/configure/configure_threads.cmake b/deal.II/contrib/cmake/configure/configure_threads.cmake index c52e43e863..258a522be2 100644 --- a/deal.II/contrib/cmake/configure/configure_threads.cmake +++ b/deal.II/contrib/cmake/configure/configure_threads.cmake @@ -2,12 +2,16 @@ INCLUDE(CheckCXXSourceCompiles) FIND_PACKAGE(Threads REQUIRED) -LIST(APPEND deal_ii_required_libraries ${CMAKE_THREAD_LIBS_INIT}) -IF(DEAL_II_ALLOW_CONTRIB) - FIND_PACKAGE(TBB) -ELSE() - FIND_PACKAGE(TBB REQUIRED) +SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_THREAD_LIBS_INIT}") # TODO +LIST(APPEND deal_ii_required_linker_flags ${CMAKE_THREAD_LIBS_INIT}) # TODO + +IF(NOT DEAL_II_FORCE_CONTRIB_TBB) + IF(DEAL_II_ALLOW_CONTRIB) + FIND_PACKAGE(TBB) + ELSE() + FIND_PACKAGE(TBB REQUIRED) + ENDIF() ENDIF() IF(DEAL_II_FORCE_CONTRIB_TBB OR NOT TBB_FOUND) diff --git a/deal.II/contrib/cmake/configure/configure_umfpack.cmake b/deal.II/contrib/cmake/configure/configure_umfpack.cmake index 7fd9ef19fa..73b33ecbe9 100644 --- a/deal.II/contrib/cmake/configure/configure_umfpack.cmake +++ b/deal.II/contrib/cmake/configure/configure_umfpack.cmake @@ -1,7 +1,7 @@ FIND_PACKAGE(LAPACK REQUIRED) FIND_PACKAGE(BLAS REQUIRED) -IF(DEAL_II_ALLOW_CONTRIB) +IF(DEAL_II_ALLOW_CONTRIB OR DEAL_II_FORCE_CONTRIB_UMFPACK) FIND_PACKAGE(Umfpack) FIND_PACKAGE(AMD) ELSE() @@ -40,6 +40,10 @@ ELSE() INCLUDE_DIRECTORIES(${Umfpack_INCLUDE_DIR} ${AMD_INCLUDE_DIR}) + LIST(APPEND deal_II_required_linker_flags + ${BLAS_LINKER_FLAGS} ${LAPACK_LINKER_FLAGS} + ) + LIST(APPEND deal_ii_external_libraries ${Umfpack_LIBRARY} ${AMD_LIBRARY} ${LAPACK_LIBRARIES} ${BLAS_LIBRARIES} ) -- 2.39.5