ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность
openmpi/config/opal_setup_cc.m4
Nathan Hjelm ade1b58d84 config: add support for setting the wrapper C compiler 
This PR adds a new configure option: --with-wrapper-cc.
This option allows the user to set the compiler that will
be invoked by mpicc, shmemcc, etc. This allows the user
to build Open MPI with one compiler (a C standards compliant
compiler like clang or gcc) and have the wrapper use
another compiler (icc for example). This allows building
Open MPI with the best available compiler while still
supporting compiling Open MPI for a specific compiler
suite.

Signed-off-by: Nathan Hjelm <hjelmn@google.com>
2020-07-07 22:43:43 -07:00

529 строки
21 KiB
Bash
Исходник Ответственный История

dnl -*- shell-script -*-
dnl
dnl Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
dnl University Research and Technology
dnl Corporation. All rights reserved.
dnl Copyright (c) 2004-2006 The University of Tennessee and The University
dnl of Tennessee Research Foundation. All rights
dnl reserved.
dnl Copyright (c) 2004-2008 High Performance Computing Center Stuttgart,
dnl University of Stuttgart. All rights reserved.
dnl Copyright (c) 2004-2006 The Regents of the University of California.
dnl All rights reserved.
dnl Copyright (c) 2007-2009 Sun Microsystems, Inc. All rights reserved.
dnl Copyright (c) 2008-2015 Cisco Systems, Inc. All rights reserved.
dnl Copyright (c) 2012-2017 Los Alamos National Security, LLC. All rights
dnl reserved.
dnl Copyright (c) 2015-2019 Research Organization for Information Science
dnl and Technology (RIST). All rights reserved.
dnl $COPYRIGHT$
dnl
dnl Additional copyrights may follow
dnl
dnl $HEADER$
dnl
AC_DEFUN([OPAL_CC_HELPER],[
OPAL_VAR_SCOPE_PUSH([opal_cc_helper_result])
AC_MSG_CHECKING([$1])
AC_LINK_IFELSE([AC_LANG_PROGRAM([$3],[$4])],
[$2=1
opal_cc_helper_result=yes],
[$2=0
opal_cc_helper_result=no])
AC_MSG_RESULT([$opal_cc_helper_result])
OPAL_VAR_SCOPE_POP
])
AC_DEFUN([OPAL_PROG_CC_C11_HELPER],[
OPAL_VAR_SCOPE_PUSH([opal_prog_cc_c11_helper_CFLAGS_save])
opal_prog_cc_c11_helper_CFLAGS_save=$CFLAGS
CFLAGS="$CFLAGS $1"
OPAL_CC_HELPER([if $CC $1 supports C11 _Thread_local], [opal_prog_cc_c11_helper__Thread_local_available],
[],[[static _Thread_local int foo = 1;++foo;]])
OPAL_CC_HELPER([if $CC $1 supports C11 atomic variables], [opal_prog_cc_c11_helper_atomic_var_available],
[[#include <stdatomic.h>]], [[static atomic_long foo = 1;++foo;]])
OPAL_CC_HELPER([if $CC $1 supports C11 _Atomic keyword], [opal_prog_cc_c11_helper__Atomic_available],
[[#include <stdatomic.h>]],[[static _Atomic long foo = 1;++foo;]])
OPAL_CC_HELPER([if $CC $1 supports C11 _Generic keyword], [opal_prog_cc_c11_helper__Generic_available],
[[#define FOO(x) (_Generic (x, int: 1))]], [[static int x, y; y = FOO(x);]])
OPAL_CC_HELPER([if $CC $1 supports C11 _Static_assert], [opal_prog_cc_c11_helper__static_assert_available],
[[#include <stdint.h>]],[[_Static_assert(sizeof(int64_t) == 8, "WTH");]])
OPAL_CC_HELPER([if $CC $1 supports C11 atomic_fetch_xor_explicit], [opal_prog_cc_c11_helper_atomic_fetch_xor_explicit_available],
[[#include <stdatomic.h>
#include <stdint.h>]],[[_Atomic uint32_t a; uint32_t b; atomic_fetch_xor_explicit(&a, b, memory_order_relaxed);]])
AS_IF([test $opal_prog_cc_c11_helper__Thread_local_available -eq 1 && test $opal_prog_cc_c11_helper_atomic_var_available -eq 1 && test $opal_prog_cc_c11_helper_atomic_fetch_xor_explicit_available -eq 1],
[$2],
[$3])
CFLAGS=$opal_prog_cc_c11_helper_CFLAGS_save
OPAL_VAR_SCOPE_POP
])
AC_DEFUN([OPAL_PROG_CC_C11],[
OPAL_VAR_SCOPE_PUSH([opal_prog_cc_c11_flags])
if test -z "$opal_cv_c11_supported" ; then
opal_cv_c11_supported=no
opal_cv_c11_flag_required=yes
AC_MSG_CHECKING([if $CC requires a flag for C11])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#if __STDC_VERSION__ < 201112L
#error "Without any CLI flags, this compiler does not support C11"
#endif
]],[])],
[opal_cv_c11_flag_required=no])
AC_MSG_RESULT([$opal_cv_c11_flag_required])
if test "x$opal_cv_c11_flag_required" = "xno" ; then
AC_MSG_NOTICE([verifying $CC supports C11 without a flag])
OPAL_PROG_CC_C11_HELPER([], [], [opal_cv_c11_flag_required=yes])
fi
if test "x$opal_cv_c11_flag_required" = "xyes" ; then
opal_prog_cc_c11_flags="-std=gnu11 -std=c11 -c11"
AC_MSG_NOTICE([checking if $CC supports C11 with a flag])
opal_cv_c11_flag=
for flag in $(echo $opal_prog_cc_c11_flags | tr ' ' '\n') ; do
OPAL_PROG_CC_C11_HELPER([$flag],[opal_cv_c11_flag=$flag],[])
if test "x$opal_cv_c11_flag" != "x" ; then
CFLAGS="$CFLAGS $opal_cv_c11_flag"
AC_MSG_NOTICE([using $flag to enable C11 support])
opal_cv_c11_supported=yes
break
fi
done
else
AC_MSG_NOTICE([no flag required for C11 support])
opal_cv_c11_supported=yes
fi
fi
OPAL_VAR_SCOPE_POP
])
# OPAL_CHECK_CC_IQUOTE()
# ----------------------
# Check if the compiler supports the -iquote option. This options
# removes the specified directory from the search path when using
# #include <>. This check works around an issue caused by C++20
# which added a <version> header. This conflicts with the
# VERSION file at the base of our source directory on case-
# insensitive filesystems.
AC_DEFUN([OPAL_CHECK_CC_IQUOTE],[
OPAL_VAR_SCOPE_PUSH([opal_check_cc_iquote_CFLAGS_save])
opal_check_cc_iquote_CFLAGS_save=${CFLAGS}
CFLAGS="${CFLAGS} -iquote ."
AC_MSG_CHECKING([for $CC option to add a directory only to the search path for the quote form of include])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],[])],
[opal_cc_iquote="-iquote"],
[opal_cc_iquote="-I"])
CFLAGS=${opal_check_cc_iquote_CFLAGS_save}
OPAL_VAR_SCOPE_POP
AC_MSG_RESULT([$opal_cc_iquote])
])
# OPAL_SETUP_CC()
# ---------------
# Do everything required to setup the C compiler. Safe to AC_REQUIRE
# this macro.
AC_DEFUN([OPAL_SETUP_CC],[
# AM_PROG_CC_C_O AC_REQUIREs AC_PROG_CC, so we have to be a little
# careful about ordering here, and AC_REQUIRE these things so that
# they get stamped out in the right order.
AC_REQUIRE([_OPAL_START_SETUP_CC])
AC_REQUIRE([_OPAL_PROG_CC])
AC_REQUIRE([AM_PROG_CC_C_O])
OPAL_VAR_SCOPE_PUSH([opal_prog_cc_c11_helper__Thread_local_available opal_prog_cc_c11_helper_atomic_var_available opal_prog_cc_c11_helper__Atomic_available opal_prog_cc_c11_helper__static_assert_available opal_prog_cc_c11_helper__Generic_available opal_prog_cc__thread_available opal_prog_cc_c11_helper_atomic_fetch_xor_explicit_available])
OPAL_PROG_CC_C11
OPAL_CHECK_CC_IQUOTE
if test $opal_cv_c11_supported = no ; then
# It is not currently an error if C11 support is not available. Uncomment the
# following lines and update the warning when we require a C11 compiler.
# AC_MSG_WARNING([Open MPI requires a C11 (or newer) compiler])
# AC_MSG_ERROR([Aborting.])
# From Open MPI 1.7 on we require a C99 compiant compiler
AC_PROG_CC_C99
# The result of AC_PROG_CC_C99 is stored in ac_cv_prog_cc_c99
if test "x$ac_cv_prog_cc_c99" = xno ; then
AC_MSG_WARN([Open MPI requires a C99 (or newer) compiler. C11 is recommended.])
AC_MSG_ERROR([Aborting.])
fi
# Get the correct result for C11 support flags now that the compiler flags have
# changed
OPAL_PROG_CC_C11_HELPER([], [], [])
fi
# Check if compiler support __thread
OPAL_CC_HELPER([if $CC $1 supports __thread], [opal_prog_cc__thread_available],
[],[[static __thread int foo = 1;++foo;]])
OPAL_CC_HELPER([if $CC $1 supports C11 _Thread_local], [opal_prog_cc_c11_helper__Thread_local_available],
[],[[static _Thread_local int foo = 1;++foo;]])
dnl At this time Open MPI only needs thread local and the atomic convenience types for C11 support. These
dnl will likely be required in the future.
AC_DEFINE_UNQUOTED([OPAL_C_HAVE__THREAD_LOCAL], [$opal_prog_cc_c11_helper__Thread_local_available],
[Whether C compiler supports __Thread_local])
AC_DEFINE_UNQUOTED([OPAL_C_HAVE_ATOMIC_CONV_VAR], [$opal_prog_cc_c11_helper_atomic_var_available],
[Whether C compiler support atomic convenience variables in stdatomic.h])
AC_DEFINE_UNQUOTED([OPAL_C_HAVE__ATOMIC], [$opal_prog_cc_c11_helper__Atomic_available],
[Whether C compiler supports __Atomic keyword])
AC_DEFINE_UNQUOTED([OPAL_C_HAVE__GENERIC], [$opal_prog_cc_c11_helper__Generic_available],
[Whether C compiler supports __Generic keyword])
AC_DEFINE_UNQUOTED([OPAL_C_HAVE__STATIC_ASSERT], [$opal_prog_cc_c11_helper__static_assert_available],
[Whether C compiler support _Static_assert keyword])
AC_DEFINE_UNQUOTED([OPAL_C_HAVE___THREAD], [$opal_prog_cc__thread_available],
[Whether C compiler supports __thread])
OPAL_C_COMPILER_VENDOR([opal_c_vendor])
# Check for standard headers, needed here because needed before
# the types checks.
AC_HEADER_STDC
# GNU C and autotools are inconsistent about whether this is
# defined so let's make it true everywhere for now... However, IBM
# XL compilers on PPC Linux behave really badly when compiled with
# _GNU_SOURCE defined, so don't define it in that situation.
#
# Don't use AC_GNU_SOURCE because it requires that no compiler
# tests are done before setting it, and we need to at least do
# enough tests to figure out if we're using XL or not.
AS_IF([test "$opal_cv_c_compiler_vendor" != "ibm"],
[AH_VERBATIM([_GNU_SOURCE],
[/* Enable GNU extensions on systems that have them. */
#ifndef _GNU_SOURCE
# undef _GNU_SOURCE
#endif])
AC_DEFINE([_GNU_SOURCE])])
# Do we want code coverage
if test "$WANT_COVERAGE" = "1"; then
if test "$opal_c_vendor" = "gnu" ; then
# For compilers > gcc-4.x, use --coverage for
# compiling and linking to circumvent trouble with
# libgcov.
CFLAGS_orig="$CFLAGS"
LDFLAGS_orig="$LDFLAGS"
CFLAGS="$CFLAGS_orig --coverage"
LDFLAGS="$LDFLAGS_orig --coverage"
OPAL_COVERAGE_FLAGS=
AC_CACHE_CHECK([if $CC supports --coverage],
[opal_cv_cc_coverage],
[AC_TRY_COMPILE([], [],
[opal_cv_cc_coverage="yes"],
[opal_cv_cc_coverage="no"])])
if test "$opal_cv_cc_coverage" = "yes" ; then
OPAL_COVERAGE_FLAGS="--coverage"
CLEANFILES="*.gcno ${CLEANFILES}"
CONFIG_CLEAN_FILES="*.gcda *.gcov ${CONFIG_CLEAN_FILES}"
else
OPAL_COVERAGE_FLAGS="-ftest-coverage -fprofile-arcs"
CLEANFILES="*.bb *.bbg ${CLEANFILES}"
CONFIG_CLEAN_FILES="*.da *.*.gcov ${CONFIG_CLEAN_FILES}"
fi
CFLAGS="$CFLAGS_orig $OPAL_COVERAGE_FLAGS"
LDFLAGS="$LDFLAGS_orig $OPAL_COVERAGE_FLAGS"
OPAL_WRAPPER_FLAGS_ADD([CFLAGS], [$OPAL_COVERAGE_FLAGS])
OPAL_WRAPPER_FLAGS_ADD([LDFLAGS], [$OPAL_COVERAGE_FLAGS])
OPAL_FLAGS_UNIQ(CFLAGS)
OPAL_FLAGS_UNIQ(LDFLAGS)
AC_MSG_WARN([$OPAL_COVERAGE_FLAGS has been added to CFLAGS (--enable-coverage)])
WANT_DEBUG=1
else
AC_MSG_WARN([Code coverage functionality is currently available only with GCC])
AC_MSG_ERROR([Configure: Cannot continue])
fi
fi
# Do we want debugging?
if test "$WANT_DEBUG" = "1" && test "$enable_debug_symbols" != "no" ; then
CFLAGS="$CFLAGS -g"
OPAL_FLAGS_UNIQ(CFLAGS)
AC_MSG_WARN([-g has been added to CFLAGS (--enable-debug)])
fi
# These flags are generally gcc-specific; even the
# gcc-impersonating compilers won't accept them.
OPAL_CFLAGS_BEFORE_PICKY="$CFLAGS"
if test $WANT_PICKY_COMPILER -eq 1; then
CFLAGS_orig=$CFLAGS
add=
# These flags are likely GCC-specific (or, more specifically,
# we don't have general tests for each one, and we know they
# work with all versions of GCC that we have used throughout
# the years, so we'll keep them limited just to GCC).
if test "$opal_c_vendor" = "gnu" ; then
add="$add -Wall -Wundef -Wno-long-long -Wsign-compare"
add="$add -Wmissing-prototypes -Wstrict-prototypes"
add="$add -Wcomment -pedantic"
fi
# see if -Wno-long-double works...
# Starting with GCC-4.4, the compiler complains about not
# knowing -Wno-long-double, only if -Wstrict-prototypes is set, too.
#
# Actually, this is not real fix, as GCC will pass on any -Wno- flag,
# have fun with the warning: -Wno-britney
CFLAGS="$CFLAGS_orig $add -Wno-long-double -Wstrict-prototypes"
AC_CACHE_CHECK([if $CC supports -Wno-long-double],
[opal_cv_cc_wno_long_double],
[AC_TRY_COMPILE([], [],
[
dnl So -Wno-long-double did not produce any errors...
dnl We will try to extract a warning regarding
dnl unrecognized or ignored options
AC_TRY_COMPILE([], [long double test;],
[
opal_cv_cc_wno_long_double="yes"
if test -s conftest.err ; then
dnl Yes, it should be "ignor", in order to catch ignoring and ignore
for i in unknown invalid ignor unrecognized ; do
$GREP -iq $i conftest.err
if test "$?" = "0" ; then
opal_cv_cc_wno_long_double="no"
break;
fi
done
fi
],
[opal_cv_cc_wno_long_double="no"])],
[opal_cv_cc_wno_long_double="no"])
])
if test "$opal_cv_cc_wno_long_double" = "yes" ; then
add="$add -Wno-long-double"
fi
# Per above, we know that this flag works with GCC / haven't
# really tested it elsewhere.
if test "$opal_c_vendor" = "gnu" ; then
add="$add -Werror-implicit-function-declaration "
fi
CFLAGS="$CFLAGS_orig $add"
OPAL_FLAGS_UNIQ(CFLAGS)
AC_MSG_WARN([$add has been added to CFLAGS (--enable-picky)])
unset add
fi
# See if this version of gcc allows -finline-functions and/or
# -fno-strict-aliasing. Even check the gcc-impersonating compilers.
if test "$GCC" = "yes"; then
CFLAGS_orig="$CFLAGS"
# Note: Some versions of clang (at least >= 3.5 -- perhaps
# older versions, too?) will *warn* about -finline-functions,
# but still allow it. This is very annoying, so check for
# that warning, too. The clang warning looks like this:
# clang: warning: optimization flag '-finline-functions' is not supported
# clang: warning: argument unused during compilation: '-finline-functions'
CFLAGS="$CFLAGS_orig -finline-functions"
add=
AC_CACHE_CHECK([if $CC supports -finline-functions],
[opal_cv_cc_finline_functions],
[AC_TRY_COMPILE([], [],
[opal_cv_cc_finline_functions="yes"
if test -s conftest.err ; then
for i in unused 'not supported' ; do
if $GREP -iq "$i" conftest.err; then
opal_cv_cc_finline_functions="no"
break;
fi
done
fi
],
[opal_cv_cc_finline_functions="no"])])
if test "$opal_cv_cc_finline_functions" = "yes" ; then
add=" -finline-functions"
fi
CFLAGS="$CFLAGS_orig$add"
CFLAGS_orig="$CFLAGS"
CFLAGS="$CFLAGS_orig -fno-strict-aliasing"
add=
AC_CACHE_CHECK([if $CC supports -fno-strict-aliasing],
[opal_cv_cc_fno_strict_aliasing],
[AC_TRY_COMPILE([], [],
[opal_cv_cc_fno_strict_aliasing="yes"],
[opal_cv_cc_fno_strict_aliasing="no"])])
if test "$opal_cv_cc_fno_strict_aliasing" = "yes" ; then
add=" -fno-strict-aliasing"
fi
CFLAGS="$CFLAGS_orig$add"
OPAL_FLAGS_UNIQ(CFLAGS)
AC_MSG_WARN([$add has been added to CFLAGS])
unset add
fi
# Try to enable restrict keyword
RESTRICT_CFLAGS=
case "$opal_c_vendor" in
intel)
RESTRICT_CFLAGS="-restrict"
;;
sgi)
RESTRICT_CFLAGS="-LANG:restrict=ON"
;;
esac
if test ! -z "$RESTRICT_CFLAGS" ; then
CFLAGS_orig="$CFLAGS"
CFLAGS="$CFLAGS_orig $RESTRICT_CFLAGS"
add=
AC_CACHE_CHECK([if $CC supports $RESTRICT_CFLAGS],
[opal_cv_cc_restrict_cflags],
[AC_TRY_COMPILE([], [],
[opal_cv_cc_restrict_cflags="yes"],
[opal_cv_cc_restrict_cflags="no"])])
if test "$opal_cv_cc_restrict_cflags" = "yes" ; then
add=" $RESTRICT_CFLAGS"
fi
CFLAGS="${CFLAGS_orig}${add}"
OPAL_FLAGS_UNIQ([CFLAGS])
if test "$add" != "" ; then
AC_MSG_WARN([$add has been added to CFLAGS])
fi
unset add
fi
# see if the C compiler supports __builtin_expect
AC_CACHE_CHECK([if $CC supports __builtin_expect],
[opal_cv_cc_supports___builtin_expect],
[AC_TRY_LINK([],
[void *ptr = (void*) 0;
if (__builtin_expect (ptr != (void*) 0, 1)) return 0;],
[opal_cv_cc_supports___builtin_expect="yes"],
[opal_cv_cc_supports___builtin_expect="no"])])
if test "$opal_cv_cc_supports___builtin_expect" = "yes" ; then
have_cc_builtin_expect=1
else
have_cc_builtin_expect=0
fi
AC_DEFINE_UNQUOTED([OPAL_C_HAVE_BUILTIN_EXPECT], [$have_cc_builtin_expect],
[Whether C compiler supports __builtin_expect])
# see if the C compiler supports __builtin_prefetch
AC_CACHE_CHECK([if $CC supports __builtin_prefetch],
[opal_cv_cc_supports___builtin_prefetch],
[AC_TRY_LINK([],
[int ptr;
__builtin_prefetch(&ptr,0,0);],
[opal_cv_cc_supports___builtin_prefetch="yes"],
[opal_cv_cc_supports___builtin_prefetch="no"])])
if test "$opal_cv_cc_supports___builtin_prefetch" = "yes" ; then
have_cc_builtin_prefetch=1
else
have_cc_builtin_prefetch=0
fi
AC_DEFINE_UNQUOTED([OPAL_C_HAVE_BUILTIN_PREFETCH], [$have_cc_builtin_prefetch],
[Whether C compiler supports __builtin_prefetch])
# see if the C compiler supports __builtin_clz
AC_CACHE_CHECK([if $CC supports __builtin_clz],
[opal_cv_cc_supports___builtin_clz],
[AC_TRY_LINK([],
[int value = 0xffff; /* we know we have 16 bits set */
if ((8*sizeof(int)-16) != __builtin_clz(value)) return 0;],
[opal_cv_cc_supports___builtin_clz="yes"],
[opal_cv_cc_supports___builtin_clz="no"])])
if test "$opal_cv_cc_supports___builtin_clz" = "yes" ; then
have_cc_builtin_clz=1
else
have_cc_builtin_clz=0
fi
AC_DEFINE_UNQUOTED([OPAL_C_HAVE_BUILTIN_CLZ], [$have_cc_builtin_clz],
[Whether C compiler supports __builtin_clz])
# Preload the optflags for the case where the user didn't specify
# any. If we're using GNU compilers, use -O3 (since it GNU
# doesn't require all compilation units to be compiled with the
# same level of optimization -- selecting a high level of
# optimization is not prohibitive). If we're using anything else,
# be conservative and just use -O.
#
# Note: gcc-impersonating compilers accept -O3
if test "$WANT_DEBUG" = "1"; then
OPTFLAGS=
else
if test "$GCC" = yes; then
OPTFLAGS="-O3"
else
OPTFLAGS="-O"
fi
fi
OPAL_ENSURE_CONTAINS_OPTFLAGS("$OPAL_CFLAGS_BEFORE_PICKY")
OPAL_CFLAGS_BEFORE_PICKY="$co_result"
AC_MSG_CHECKING([for C optimization flags])
OPAL_ENSURE_CONTAINS_OPTFLAGS(["$CFLAGS"])
AC_MSG_RESULT([$co_result])
CFLAGS="$co_result"
OPAL_VAR_SCOPE_POP
])
AC_DEFUN([_OPAL_START_SETUP_CC],[
opal_show_subtitle "C compiler and preprocessor"
# $%@#!@#% AIX!! This has to be called before anything invokes the C
# compiler.
dnl AC_AIX
])
AC_DEFUN([_OPAL_PROG_CC],[
#
# Check for the compiler
#
OPAL_VAR_SCOPE_PUSH([opal_cflags_save dummy opal_cc_arvgv0])
opal_cflags_save="$CFLAGS"
AC_PROG_CC
BASECC="`basename $CC`"
CFLAGS="$opal_cflags_save"
AC_DEFINE_UNQUOTED(OPAL_CC, "$CC", [OMPI underlying C compiler])
set dummy $CC
opal_cc_argv0=[$]2
OPAL_WHICH([$opal_cc_argv0], [OPAL_CC_ABSOLUTE])
AC_SUBST(OPAL_CC_ABSOLUTE)
OPAL_VAR_SCOPE_POP
])
Показать git blame Копировать постоянную ссылку