ports/openmpi
ports/openmpi
1
1
Fork 0
Code Releases Activity

This is a very large change to rename several #define values from

Browse Source 
OMPI_* to OPAL_*.  This allows opal layer to be used more independent
from the whole of ompi.

NOTE: 9 "svn mv" operations immediately follow this commit.

This commit was SVN r21180.
This commit is contained in:
Greg Koenig 2009-05-06 20:11:28 +00:00
parent 64585600fc
commit 60485ff95f
843 changed files with 2841 additions and 2841 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
NEWS
View File

@ -160,7 +160,7 @@ Trunk (not on release branches yet)
set the MCA parameter orte_forward_job_control to 1.
- Allow the sm BTL to allocate larger amounts of shared memory if
desired (helpful for very large multi-core boxen).
- Fix a few places where we used PATH_MAX instead of OMPI_PATH_MAX,
- Fix a few places where we used PATH_MAX instead of OPAL_PATH_MAX,
leading to compile problems on some platforms. Thanks to Andrea Iob
for the bug report.
- Fix mca_btl_openib_warn_no_device_params_found MCA parameter; it

2
README.WINDOWS
View File

@ -70,7 +70,7 @@ Step 3: Add the following to ompi/tools/ompi_info/ompi_info.h and
#define OMPI_BUILD_FCFLAGS ""
#define OMPI_BUILD_LDFLAGS " "
#define OMPI_BUILD_LIBS " "
#define OMPI_CC_ABSOLUTE "cl"
#define OPAL_CC_ABSOLUTE "cl"
#define OMPI_CXX_ABSOLUTE "cl"
#define OMPI_F77_ABSOLUTE "none"
#define OMPI_F90_ABSOLUTE "none"

2
config/c_weak_symbols.m4
View File

@ -66,5 +66,5 @@ AC_DEFUN([OMPI_C_WEAK_SYMBOLS],[
[ompi_cv_c_weak_symbols="no"])])
AS_IF([test "$ompi_cv_c_weak_symbols" = "yes"],
[OMPI_C_HAVE_WEAK_SYMBOLS=1], [OMPI_C_HAVE_WEAK_SYMBOLS=0])
[OPAL_C_HAVE_WEAK_SYMBOLS=1], [OPAL_C_HAVE_WEAK_SYMBOLS=0])
]) dnl

4
config/mca_acinclude.m4
View File

@ -22,14 +22,14 @@ dnl Tests provided by OMPI
dnl General tests
dnl
sinclude(@M4DIR@/ompi_functions.m4)
sinclude(@M4DIR@/opal_functions.m4)
sinclude(@M4DIR@/ompi_get_version.m4)
dnl
dnl C compiler tests
dnl
sinclude(@M4DIR@/ompi_setup_cc.m4)
sinclude(@M4DIR@/opal_setup_cc.m4)
sinclude(@M4DIR@/ompi_check_optflags.m4)
sinclude(@M4DIR@/ompi_check_vendor.m4)

118
config/ompi_check_attributes.m4
View File

@ -29,7 +29,7 @@ AC_DEFUN([_OMPI_ATTRIBUTE_FAIL_SEARCH],[
for i in ignore skip ; do
$GREP -iq $i conftest.err
if test "$?" = "0" ; then
ompi_cv___attribute__[$1]=0
opal_cv___attribute__[$1]=0
break;
fi
done
@ -51,7 +51,7 @@ AC_DEFUN([_OMPI_ATTRIBUTE_FAIL_SEARCH],[
#
AC_DEFUN([_OMPI_CHECK_SPECIFIC_ATTRIBUTE], [
AC_MSG_CHECKING([for __attribute__([$1])])
AC_CACHE_VAL(ompi_cv___attribute__[$1], [
AC_CACHE_VAL(opal_cv___attribute__[$1], [
#
# Try to compile using the C compiler, then C++
#
@ -62,20 +62,20 @@ AC_DEFUN([_OMPI_CHECK_SPECIFIC_ATTRIBUTE], [
# attribute being ignored/skipped? Grep for IgNoRe/skip in conftest.err
# and if found, reset the ompi_cv__attribute__var=0
#
ompi_cv___attribute__[$1]=1
opal_cv___attribute__[$1]=1
_OMPI_ATTRIBUTE_FAIL_SEARCH([$1])
],
[ompi_cv___attribute__[$1]=0])
if test "$ompi_cv___attribute__[$1]" = "1" ; then
[opal_cv___attribute__[$1]=0])
if test "$opal_cv___attribute__[$1]" = "1" ; then
AC_LANG_PUSH(C++)
AC_TRY_COMPILE([
extern "C" {
$2
}],[],
[
ompi_cv___attribute__[$1]=1
opal_cv___attribute__[$1]=1
_OMPI_ATTRIBUTE_FAIL_SEARCH([$1])
],[ompi_cv___attribute__[$1]=0])
],[opal_cv___attribute__[$1]=0])
AC_LANG_POP(C++)
fi
@ -83,7 +83,7 @@ AC_DEFUN([_OMPI_CHECK_SPECIFIC_ATTRIBUTE], [
# If the attribute is supported by both compilers,
# try to recompile a *cross-check*, IFF defined.
#
if test '(' "$ompi_cv___attribute__[$1]" = "1" -a "[$3]" != "" ')' ; then
if test '(' "$opal_cv___attribute__[$1]" = "1" -a "[$3]" != "" ')' ; then
ac_c_werror_flag_safe=$ac_c_werror_flag
ac_c_werror_flag="yes"
CFLAGS_safe=$CFLAGS
@ -94,14 +94,14 @@ AC_DEFUN([_OMPI_CHECK_SPECIFIC_ATTRIBUTE], [
int i=4711;
i=usage(&i);
],
[ompi_cv___attribute__[$1]=0],
[opal_cv___attribute__[$1]=0],
[
#
# In case we did NOT succeed: Fine, but was this due to the
# attribute being ignored? Grep for IgNoRe in conftest.err
# and if found, reset the ompi_cv__attribute__var=0
#
ompi_cv___attribute__[$1]=1
opal_cv___attribute__[$1]=1
_OMPI_ATTRIBUTE_FAIL_SEARCH([$1])
])
@ -110,7 +110,7 @@ AC_DEFUN([_OMPI_CHECK_SPECIFIC_ATTRIBUTE], [
fi
])
if test "$ompi_cv___attribute__[$1]" = "1" ; then
if test "$opal_cv___attribute__[$1]" = "1" ; then
AC_MSG_RESULT([yes])
else
AC_MSG_RESULT([no])
@ -127,11 +127,11 @@ AC_DEFUN([_OMPI_CHECK_SPECIFIC_ATTRIBUTE], [
# The compilers output is parsed in _OMPI_ATTRIBUTE_FAIL_SEARCH
#
# To add a new attributes __NAME__ add the
# ompi_cv___attribute__NAME
# opal_cv___attribute__NAME
# add a new check with _OMPI_CHECK_SPECIFIC_ATTRIBUTE (possibly with a cross-check)
# _OMPI_CHECK_SPECIFIC_ATTRIBUTE([name], [int foo (int arg) __attribute__ ((__name__));], [], [])
# and define the corresponding
# AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_NAME, [$ompi_cv___attribute__NAME],
# AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_NAME, [$opal_cv___attribute__NAME],
# [Whether your compiler has __attribute__ NAME or not])
# and decide on a correct macro (in opal/include/opal_config_bottom.h):
# # define __opal_attribute_NAME(x) __attribute__(__NAME__)
@ -145,7 +145,7 @@ AC_DEFUN([_OMPI_CHECK_SPECIFIC_ATTRIBUTE], [
AC_DEFUN([OMPI_CHECK_ATTRIBUTES], [
AC_MSG_CHECKING(for __attribute__)
AC_CACHE_VAL(ompi_cv___attribute__, [
AC_CACHE_VAL(opal_cv___attribute__, [
AC_TRY_COMPILE(
[#include <stdlib.h>
/* Check for the longest available __attribute__ (since gcc-2.3) */
@ -155,11 +155,11 @@ AC_DEFUN([OMPI_CHECK_ATTRIBUTES], [
};
],
[],
[ompi_cv___attribute__=1],
[ompi_cv___attribute__=0],
[opal_cv___attribute__=1],
[opal_cv___attribute__=0],
)
if test "$ompi_cv___attribute__" = "1" ; then
if test "$opal_cv___attribute__" = "1" ; then
AC_TRY_COMPILE(
[#include <stdlib.h>
/* Check for the longest available __attribute__ (since gcc-2.3) */
@ -169,39 +169,39 @@ AC_DEFUN([OMPI_CHECK_ATTRIBUTES], [
};
],
[],
[ompi_cv___attribute__=1],
[ompi_cv___attribute__=0],
[opal_cv___attribute__=1],
[opal_cv___attribute__=0],
)
fi
])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE, [$ompi_cv___attribute__],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE, [$opal_cv___attribute__],
[Whether your compiler has __attribute__ or not])
#
# Now that we know the compiler support __attribute__ let's check which kind of
# attributed are supported.
#
if test "$ompi_cv___attribute__" = "0" ; then
if test "$opal_cv___attribute__" = "0" ; then
AC_MSG_RESULT([no])
ompi_cv___attribute__aligned=0
ompi_cv___attribute__always_inline=0
ompi_cv___attribute__cold=0
ompi_cv___attribute__const=0
ompi_cv___attribute__deprecated=0
ompi_cv___attribute__format=0
ompi_cv___attribute__hot=0
ompi_cv___attribute__malloc=0
ompi_cv___attribute__may_alias=0
ompi_cv___attribute__no_instrument_function=0
ompi_cv___attribute__nonnull=0
ompi_cv___attribute__noreturn=0
ompi_cv___attribute__packed=0
ompi_cv___attribute__pure=0
ompi_cv___attribute__sentinel=0
ompi_cv___attribute__unused=0
ompi_cv___attribute__visibility=0
ompi_cv___attribute__warn_unused_result=0
ompi_cv___attribute__weak_alias=0
opal_cv___attribute__aligned=0
opal_cv___attribute__always_inline=0
opal_cv___attribute__cold=0
opal_cv___attribute__const=0
opal_cv___attribute__deprecated=0
opal_cv___attribute__format=0
opal_cv___attribute__hot=0
opal_cv___attribute__malloc=0
opal_cv___attribute__may_alias=0
opal_cv___attribute__no_instrument_function=0
opal_cv___attribute__nonnull=0
opal_cv___attribute__noreturn=0
opal_cv___attribute__packed=0
opal_cv___attribute__pure=0
opal_cv___attribute__sentinel=0
opal_cv___attribute__unused=0
opal_cv___attribute__visibility=0
opal_cv___attribute__warn_unused_result=0
opal_cv___attribute__weak_alias=0
else
AC_MSG_RESULT([yes])
@ -476,42 +476,42 @@ AC_DEFUN([OMPI_CHECK_ATTRIBUTES], [
# Now that all the values are set, define them
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_ALIGNED, [$ompi_cv___attribute__aligned],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_ALIGNED, [$opal_cv___attribute__aligned],
[Whether your compiler has __attribute__ aligned or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_ALWAYS_INLINE, [$ompi_cv___attribute__always_inline],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_ALWAYS_INLINE, [$opal_cv___attribute__always_inline],
[Whether your compiler has __attribute__ always_inline or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_COLD, [$ompi_cv___attribute__cold],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_COLD, [$opal_cv___attribute__cold],
[Whether your compiler has __attribute__ cold or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_CONST, [$ompi_cv___attribute__const],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_CONST, [$opal_cv___attribute__const],
[Whether your compiler has __attribute__ const or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_DEPRECATED, [$ompi_cv___attribute__deprecated],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_DEPRECATED, [$opal_cv___attribute__deprecated],
[Whether your compiler has __attribute__ deprecated or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_FORMAT, [$ompi_cv___attribute__format],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_FORMAT, [$opal_cv___attribute__format],
[Whether your compiler has __attribute__ format or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_HOT, [$ompi_cv___attribute__hot],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_HOT, [$opal_cv___attribute__hot],
[Whether your compiler has __attribute__ hot or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_MALLOC, [$ompi_cv___attribute__malloc],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_MALLOC, [$opal_cv___attribute__malloc],
[Whether your compiler has __attribute__ malloc or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_MAY_ALIAS, [$ompi_cv___attribute__may_alias],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_MAY_ALIAS, [$opal_cv___attribute__may_alias],
[Whether your compiler has __attribute__ may_alias or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_NO_INSTRUMENT_FUNCTION, [$ompi_cv___attribute__no_instrument_function],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_NO_INSTRUMENT_FUNCTION, [$opal_cv___attribute__no_instrument_function],
[Whether your compiler has __attribute__ no_instrument_function or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_NONNULL, [$ompi_cv___attribute__nonnull],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_NONNULL, [$opal_cv___attribute__nonnull],
[Whether your compiler has __attribute__ nonnull or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_NORETURN, [$ompi_cv___attribute__noreturn],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_NORETURN, [$opal_cv___attribute__noreturn],
[Whether your compiler has __attribute__ noreturn or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_PACKED, [$ompi_cv___attribute__packed],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_PACKED, [$opal_cv___attribute__packed],
[Whether your compiler has __attribute__ packed or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_PURE, [$ompi_cv___attribute__pure],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_PURE, [$opal_cv___attribute__pure],
[Whether your compiler has __attribute__ pure or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_SENTINEL, [$ompi_cv___attribute__sentinel],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_SENTINEL, [$opal_cv___attribute__sentinel],
[Whether your compiler has __attribute__ sentinel or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_UNUSED, [$ompi_cv___attribute__unused],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_UNUSED, [$opal_cv___attribute__unused],
[Whether your compiler has __attribute__ unused or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_VISIBILITY, [$ompi_cv___attribute__visibility],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_VISIBILITY, [$opal_cv___attribute__visibility],
[Whether your compiler has __attribute__ visibility or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_WARN_UNUSED_RESULT, [$ompi_cv___attribute__warn_unused_result],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_WARN_UNUSED_RESULT, [$opal_cv___attribute__warn_unused_result],
[Whether your compiler has __attribute__ warn unused result or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_WEAK_ALIAS, [$ompi_cv___attribute__weak_alias],
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_WEAK_ALIAS, [$opal_cv___attribute__weak_alias],
[Whether your compiler has __attribute__ weak alias or not])
])

2
config/ompi_check_broken_qsort.m4
View File

@ -48,6 +48,6 @@ AC_DEFUN([OMPI_CHECK_BROKEN_QSORT],[
define_result=0
fi
AC_MSG_RESULT([$result])
AC_DEFINE_UNQUOTED([OMPI_HAVE_BROKEN_QSORT], [$define_result],
AC_DEFINE_UNQUOTED([OPAL_HAVE_BROKEN_QSORT], [$define_result],
[whether qsort is broken or not])
])

38
config/ompi_check_ident.m4
View File

@ -8,9 +8,9 @@ dnl
dnl $HEADER$
dnl
dnl defines:
dnl OMPI_$1_USE_PRAGMA_IDENT
dnl OMPI_$1_USE_IDENT
dnl OMPI_$1_USE_CONST_CHAR_IDENT
dnl OPAL_$1_USE_PRAGMA_IDENT
dnl OPAL_$1_USE_IDENT
dnl OPAL_$1_USE_CONST_CHAR_IDENT
dnl
# OMPI_CHECK_IDENT(compiler-env, compiler-flags,
@ -21,39 +21,39 @@ dnl
AC_DEFUN([OMPI_CHECK_IDENT], [
AC_MSG_CHECKING([for $4 ident string support])
ompi_pragma_ident_happy=0
ompi_ident_happy=0
ompi_static_const_char_happy=0
opal_pragma_ident_happy=0
opal_ident_happy=0
opal_static_const_char_happy=0
_OMPI_CHECK_IDENT(
[$1], [$2], [$3],
[[#]pragma ident], [],
[ompi_pragma_ident_happy=1
[opal_pragma_ident_happy=1
ompi_message="[#]pragma ident"],
_OMPI_CHECK_IDENT(
[$1], [$2], [$3],
[[#]ident], [],
[ompi_ident_happy=1
[opal_ident_happy=1
ompi_message="[#]ident"],
_OMPI_CHECK_IDENT(
[$1], [$2], [$3],
[[#]pragma comment(exestr, ], [)],
[ompi_pragma_comment_happy=1
[opal_pragma_comment_happy=1
ompi_message="[#]pragma comment"],
[ompi_static_const_char_happy=1
[opal_static_const_char_happy=1
ompi_message="static const char[[]]"])))
AC_DEFINE_UNQUOTED([OMPI_$1_USE_PRAGMA_IDENT],
[$ompi_pragma_ident_happy], [Use #pragma ident strings for $4 files])
AC_DEFINE_UNQUOTED([OMPI_$1_USE_IDENT],
[$ompi_ident_happy], [Use #ident strings for $4 files])
AC_DEFINE_UNQUOTED([OMPI_$1_USE_PRAGMA_COMMENT],
[$ompi_pragma_comment_happy], [Use #pragma comment for $4 files])
AC_DEFINE_UNQUOTED([OMPI_$1_USE_CONST_CHAR_IDENT],
[$ompi_static_const_char_happy], [Use static const char[] strings for $4 files])
AC_DEFINE_UNQUOTED([OPAL_$1_USE_PRAGMA_IDENT],
[$opal_pragma_ident_happy], [Use #pragma ident strings for $4 files])
AC_DEFINE_UNQUOTED([OPAL_$1_USE_IDENT],
[$opal_ident_happy], [Use #ident strings for $4 files])
AC_DEFINE_UNQUOTED([OPAL_$1_USE_PRAGMA_COMMENT],
[$opal_pragma_comment_happy], [Use #pragma comment for $4 files])
AC_DEFINE_UNQUOTED([OPAL_$1_USE_CONST_CHAR_IDENT],
[$opal_static_const_char_happy], [Use static const char[] strings for $4 files])
AC_MSG_RESULT([$ompi_message])
unset ompi_pragma_ident_happy ompi_ident_happy ompi_static_const_char_happy ompi_message
unset opal_pragma_ident_happy opal_ident_happy opal_static_const_char_happy ompi_message
])
# _OMPI_CHECK_IDENT(compiler-env, compiler-flags,

12
config/ompi_check_pthread_pids.m4
View File

@ -24,7 +24,7 @@ AC_DEFUN([OMPI_CHECK_PTHREAD_PIDS],[
# Dependencies: None
#
# Sets:
# OMPI_THREADS_HAVE_DIFFERENT_PIDS (variable)
# OPAL_THREADS_HAVE_DIFFERENT_PIDS (variable)
#
# Test for Linux-like threads in the system. We will need to handle things like
# getpid() differently in the case of a Linux-like threads model.
@ -61,16 +61,16 @@ void *checkpid(void *arg) {
ret = 1;
pthread_exit((void *) &ret);
}],
[MSG=no OMPI_THREADS_HAVE_DIFFERENT_PIDS=0],
[MSG=yes OMPI_THREADS_HAVE_DIFFERENT_PIDS=1],
[MSG=no OPAL_THREADS_HAVE_DIFFERENT_PIDS=0],
[MSG=yes OPAL_THREADS_HAVE_DIFFERENT_PIDS=1],
[case $host in
*-linux*)
MSG="cross compiling - assuming yes"
OMPI_THREADS_HAVE_DIFFERENT_PIDS=1
OPAL_THREADS_HAVE_DIFFERENT_PIDS=1
;;
*)
MSG="cross compiling - assuming no"
OMPI_THREADS_HAVE_DIFFERENT_PIDS=0
OPAL_THREADS_HAVE_DIFFERENT_PIDS=0
;;
esac
])
@ -81,7 +81,7 @@ LDFLAGS="$LDFLAGS_save"
LIBS="$LIBS_save"
AC_MSG_RESULT([$MSG])
AC_DEFINE_UNQUOTED(OMPI_THREADS_HAVE_DIFFERENT_PIDS, $OMPI_THREADS_HAVE_DIFFERENT_PIDS)
AC_DEFINE_UNQUOTED(OPAL_THREADS_HAVE_DIFFERENT_PIDS, $OPAL_THREADS_HAVE_DIFFERENT_PIDS)
#
# if pthreads is not available, then the system does not have an insane threads

4
config/ompi_check_visibility.m4
View File

@ -29,7 +29,7 @@ AC_DEFUN([OMPI_CHECK_VISIBILITY],[
AC_ARG_ENABLE(visibility,
AC_HELP_STRING([--enable-visibility],
[enable visibility feature of certain compilers/linkers (default: enabled)]))
if test "$enable_visibility" = "no" -o "$ompi_cv___attribute__visibility" = "0"; then
if test "$enable_visibility" = "no" -o "$opal_cv___attribute__visibility" = "0"; then
AC_MSG_CHECKING([enable symbol visibility])
AC_MSG_RESULT([no])
have_visibility=0
@ -103,7 +103,7 @@ AC_DEFUN([OMPI_CHECK_VISIBILITY],[
CFLAGS="$CFLAGS_orig$add"
unset add
fi
AC_DEFINE_UNQUOTED([OMPI_C_HAVE_VISIBILITY], [$have_visibility],
AC_DEFINE_UNQUOTED([OPAL_C_HAVE_VISIBILITY], [$have_visibility],
[Whether C compiler supports -fvisibility])
])

230
config/ompi_config_asm.m4
View File

@ -27,26 +27,26 @@ dnl
dnl #################################################################
AC_DEFUN([OMPI_CHECK_ASM_TEXT],[
AC_MSG_CHECKING([directive for setting text section])
ompi_cv_asm_text=""
opal_cv_asm_text=""
if test "$ompi_cv_c_compiler_vendor" = "microsoft" ; then
# text section will be brought in with the rest of
# header for MS - leave blank for now
ompi_cv_asm_text=""
opal_cv_asm_text=""
else
case $host in
*-aix*)
ompi_cv_asm_text=[".csect .text[PR]"]
opal_cv_asm_text=[".csect .text[PR]"]
;;
*)
ompi_cv_asm_text=".text"
opal_cv_asm_text=".text"
;;
esac
fi
AC_MSG_RESULT([$ompi_cv_asm_text])
AC_DEFINE_UNQUOTED([OMPI_ASM_TEXT], ["$ompi_cv_asm_text"],
AC_MSG_RESULT([$opal_cv_asm_text])
AC_DEFINE_UNQUOTED([OPAL_ASM_TEXT], ["$opal_cv_asm_text"],
[Assembly directive for setting text section])
OMPI_ASM_TEXT="$ompi_cv_asm_text"
AC_SUBST(OMPI_ASM_TEXT)
OPAL_ASM_TEXT="$opal_cv_asm_text"
AC_SUBST(OPAL_ASM_TEXT)
])dnl
@ -54,7 +54,7 @@ dnl #################################################################
dnl
dnl OMPI_CHECK_ASM_GLOBAL
dnl
dnl Sets OMPI_ASM_GLOBAL to the value to prefix global values
dnl Sets OPAL_ASM_GLOBAL to the value to prefix global values
dnl
dnl I'm sure if I don't have a test for this, there will be some
dnl dumb platform that uses something else
@ -62,20 +62,20 @@ dnl
dnl #################################################################
AC_DEFUN([OMPI_CHECK_ASM_GLOBAL],[
AC_MSG_CHECKING([directive for exporting symbols])
ompi_cv_asm_global=""
opal_cv_asm_global=""
if test "$ompi_cv_c_compiler_vendor" = "microsoft" ; then
ompi_cv_asm_global="PUBLIC"
opal_cv_asm_global="PUBLIC"
else
case $host in
*)
ompi_cv_asm_global=".globl"
opal_cv_asm_global=".globl"
;;
esac
fi
AC_MSG_RESULT([$ompi_cv_asm_global])
AC_DEFINE_UNQUOTED([OMPI_ASM_GLOBAL], ["$ompi_cv_asm_global"],
AC_MSG_RESULT([$opal_cv_asm_global])
AC_DEFINE_UNQUOTED([OPAL_ASM_GLOBAL], ["$opal_cv_asm_global"],
[Assembly directive for exporting symbols])
OMPI_ASM_GLOBAL="$ompi_cv_asm_global"
OPAL_ASM_GLOBAL="$opal_cv_asm_global"
AC_SUBST(OMPI_AS_GLOBAL)
])dnl
@ -84,7 +84,7 @@ dnl #################################################################
dnl
dnl OMPI_CHECK_ASM_LSYM
dnl
dnl Sets OMPI_ASM_LSYM to the prefix value on a symbol to make it
dnl Sets OPAL_ASM_LSYM to the prefix value on a symbol to make it
dnl an internal label (jump target and whatnot)
dnl
dnl We look for L .L $ L$ (in that order) for something that both
@ -103,8 +103,8 @@ AC_DEFUN([_OMPI_CHECK_ASM_LSYM],[
for sym in L .L $ L$ ; do
asm_result=0
echo "configure: trying $sym" >&AC_FD_CC
OMPI_TRY_ASSEMBLE([foobar$ompi_cv_asm_label_suffix
${sym}mytestlabel$ompi_cv_asm_label_suffix],
OMPI_TRY_ASSEMBLE([foobar$opal_cv_asm_label_suffix
${sym}mytestlabel$opal_cv_asm_label_suffix],
[# ok, we succeeded at assembling. see if we can nm,
# throwing the results in a file
if $NM conftest.$OBJEXT > conftest.out 2>&AC_FD_CC ; then
@ -138,12 +138,12 @@ AC_DEFUN([OMPI_CHECK_ASM_LSYM],[
AC_REQUIRE([AC_PROG_NM])
AC_CACHE_CHECK([prefix for lsym labels],
[ompi_cv_asm_lsym],
[_OMPI_CHECK_ASM_LSYM([ompi_cv_asm_lsym])])
AC_DEFINE_UNQUOTED([OMPI_ASM_LSYM], ["$ompi_cv_asm_lsym"],
[opal_cv_asm_lsym],
[_OMPI_CHECK_ASM_LSYM([opal_cv_asm_lsym])])
AC_DEFINE_UNQUOTED([OPAL_ASM_LSYM], ["$opal_cv_asm_lsym"],
[Assembly prefix for lsym labels])
OMPI_ASM_LSYM="$ompi_cv_asm_lsym"
AC_SUBST(OMPI_ASM_LSYM)
OPAL_ASM_LSYM="$opal_cv_asm_lsym"
AC_SUBST(OPAL_ASM_LSYM)
])dnl
dnl #################################################################
@ -179,28 +179,28 @@ dnl #################################################################
dnl
dnl OMPI_CHECK_ASM_GSYM
dnl
dnl Sets OMPI_ASM_GSYM to the prefix value on a symbol to make it
dnl Sets OPAL_ASM_GSYM to the prefix value on a symbol to make it
dnl a global linkable from C. Basically, an _ or not.
dnl
dnl #################################################################
AC_DEFUN([OMPI_CHECK_ASM_GSYM],[
AC_CACHE_CHECK([prefix for global symbol labels],
[ompi_cv_asm_gsym],
[opal_cv_asm_gsym],
[_OMPI_CHECK_ASM_GSYM])
if test "$ompi_cv_asm_gsym" = "none" ; then
if test "$opal_cv_asm_gsym" = "none" ; then
AC_MSG_ERROR([Could not determine global symbol label prefix])
fi
AC_DEFINE_UNQUOTED([OMPI_ASM_GSYM], ["$ompi_cv_asm_gsym"],
AC_DEFINE_UNQUOTED([OPAL_ASM_GSYM], ["$opal_cv_asm_gsym"],
[Assembly prefix for gsym labels])
OMPI_ASM_GSYM="$ompi_cv_asm_gsym"
AC_SUBST(OMPI_ASM_GSYM)
OPAL_ASM_GSYM="$opal_cv_asm_gsym"
AC_SUBST(OPAL_ASM_GSYM)
])
AC_DEFUN([_OMPI_CHECK_ASM_GSYM],[
ompi_cv_asm_gsym="none"
opal_cv_asm_gsym="none"
for sym in "_" "" "." ; do
asm_result=0
@ -221,10 +221,10 @@ main()
}
EOF
OMPI_TRY_ASSEMBLE([
$ompi_cv_asm_text
$opal_cv_asm_text
$ompi_cv_asm_proc ${sym}gsym_test_func
$ompi_cv_asm_global ${sym}gsym_test_func
${sym}gsym_test_func${ompi_cv_asm_label_suffix}
$opal_cv_asm_global ${sym}gsym_test_func
${sym}gsym_test_func${opal_cv_asm_label_suffix}
$ompi_cv_asm_endproc ${sym}gsym_test_func
],
[ompi_compile="$CC $CFLAGS -I. conftest_c.c -c > conftest.cmpl 2>&1"
@ -253,7 +253,7 @@ $ompi_cv_asm_endproc ${sym}gsym_test_func
fi],
[asm_result=0])
if test "$asm_result" = "1" ; then
ompi_cv_asm_gsym="$sym"
opal_cv_asm_gsym="$sym"
break
fi
done
@ -265,7 +265,7 @@ dnl #################################################################
dnl
dnl OMPI_CHECK_ASM_LABEL_SUFFIX
dnl
dnl Sets OMPI_ASM_LABEL_SUFFIX to the value to suffix for labels
dnl Sets OPAL_ASM_LABEL_SUFFIX to the value to suffix for labels
dnl
dnl I'm sure if I don't have a test for this, there will be some
dnl dumb platform that uses something else
@ -273,16 +273,16 @@ dnl
dnl #################################################################
AC_DEFUN([OMPI_CHECK_ASM_LABEL_SUFFIX],[
AC_MSG_CHECKING([suffix for labels])
ompi_cv_asm_label_suffix=""
opal_cv_asm_label_suffix=""
case $host in
*)
ompi_cv_asm_label_suffix=":"
opal_cv_asm_label_suffix=":"
;;
esac
AC_MSG_RESULT([$ompi_cv_asm_label_suffix])
AC_DEFINE_UNQUOTED([OMPI_ASM_LABEL_SUFFIX], ["$ompi_cv_asm_label_suffix"],
AC_MSG_RESULT([$opal_cv_asm_label_suffix])
AC_DEFINE_UNQUOTED([OPAL_ASM_LABEL_SUFFIX], ["$opal_cv_asm_label_suffix"],
[Assembly suffix for labels])
OMPI_ASM_LABEL_SUFFIX="$ompi_cv_asm_label_suffix"
OPAL_ASM_LABEL_SUFFIX="$opal_cv_asm_label_suffix"
AC_SUBST(OMPI_AS_LABEL_SUFFIX)
])dnl
@ -291,7 +291,7 @@ dnl #################################################################
dnl
dnl OMPI_CHECK_ASM_ALIGN_LOG
dnl
dnl Sets OMPI_ASM_ALIGN_LOG to 1 if align is specified
dnl Sets OPAL_ASM_ALIGN_LOG to 1 if align is specified
dnl logarithmically, 0 otherwise
dnl
dnl #################################################################
@ -301,12 +301,12 @@ AC_DEFUN([OMPI_CHECK_ASM_ALIGN_LOG],[
AC_CACHE_CHECK([if .align directive takes logarithmic value],
[ompi_cv_asm_align_log],
[ OMPI_TRY_ASSEMBLE([ $ompi_cv_asm_text
[ OMPI_TRY_ASSEMBLE([ $opal_cv_asm_text
.align 4
$ompi_cv_asm_global foo
$opal_cv_asm_global foo
.byte 1
.align 4
foo$ompi_cv_asm_label_suffix
foo$opal_cv_asm_label_suffix
.byte 2],
[ompi_asm_addr=[`$NM conftest.$OBJEXT | $GREP foo | sed -e 's/.*\([0-9a-fA-F][0-9a-fA-F]\).*foo.*/\1/'`]],
[ompi_asm_addr=""])
@ -324,7 +324,7 @@ foo$ompi_cv_asm_label_suffix
ompi_asm_align_log_result=0
fi
AC_DEFINE_UNQUOTED([OMPI_ASM_ALIGN_LOG],
AC_DEFINE_UNQUOTED([OPAL_ASM_ALIGN_LOG],
[$asm_align_log_result],
[Assembly align directive expects logarithmic value])
@ -336,9 +336,9 @@ dnl #################################################################
dnl
dnl OMPI_CHECK_ASM_TYPE
dnl
dnl Sets OMPI_ASM_TYPE to the prefix for the function type to
dnl Sets OPAL_ASM_TYPE to the prefix for the function type to
dnl set a symbol's type as function (needed on ELF for shared
dnl libaries). If no .type directive is needed, sets OMPI_ASM_TYPE
dnl libaries). If no .type directive is needed, sets OPAL_ASM_TYPE
dnl to an empty string
dnl
dnl We look for @ \# %
@ -346,24 +346,24 @@ dnl
dnl #################################################################
AC_DEFUN([OMPI_CHECK_ASM_TYPE],[
AC_CACHE_CHECK([prefix for function in .type],
[ompi_cv_asm_type],
[opal_cv_asm_type],
[_OMPI_CHECK_ASM_TYPE])
AC_DEFINE_UNQUOTED([OMPI_ASM_TYPE], ["$ompi_cv_asm_type"],
AC_DEFINE_UNQUOTED([OPAL_ASM_TYPE], ["$opal_cv_asm_type"],
[How to set function type in .type directive])
OMPI_ASM_TYPE="$ompi_cv_asm_type"
AC_SUBST(OMPI_ASM_TYPE)
OPAL_ASM_TYPE="$opal_cv_asm_type"
AC_SUBST(OPAL_ASM_TYPE)
])
AC_DEFUN([_OMPI_CHECK_ASM_TYPE],[
ompi_cv_asm_type=""
opal_cv_asm_type=""
case "${host}" in
*-sun-solaris*)
# GCC on solaris seems to accept just about anything, not
# that what it defines actually works... So just hardwire
# to the right answer
ompi_cv_asm_type="#"
opal_cv_asm_type="#"
;;
*)
for type in @ \# % ; do
@ -371,7 +371,7 @@ AC_DEFUN([_OMPI_CHECK_ASM_TYPE],[
echo "configure: trying $type" >&AC_FD_CC
OMPI_TRY_ASSEMBLE([ .type mysym, ${type}function
mysym:],
[ompi_cv_asm_type="${type}"
[opal_cv_asm_type="${type}"
asm_result=1])
if test "$asm_result" = "1" ; then
break
@ -389,7 +389,7 @@ dnl #################################################################
dnl
dnl OMPI_CHECK_ASM_SIZE
dnl
dnl Sets OMPI_ASM_SIZE to 1 if we should set .size directives for
dnl Sets OPAL_ASM_SIZE to 1 if we should set .size directives for
dnl each function, 0 otherwise.
dnl
dnl #################################################################
@ -402,15 +402,15 @@ AC_DEFUN([OMPI_CHECK_ASM_SIZE],[
rm -f conftest.out])
if test "$ompi_cv_asm_need_size" = "yes" ; then
ompi_asm_size=1
opal_asm_size=1
else
ompi_asm_size=0
opal_asm_size=0
fi
AC_DEFINE_UNQUOTED([OMPI_ASM_SIZE], ["$ompi_asm_size"],
AC_DEFINE_UNQUOTED([OPAL_ASM_SIZE], ["$opal_asm_size"],
[Do we need to give a .size directive])
OMPI_ASM_SIZE="$ompi_asm_size"
AC_SUBST(OMPI_ASM_TYPE)
OPAL_ASM_SIZE="$opal_asm_size"
AC_SUBST(OPAL_ASM_TYPE)
unset asm_result
])dnl
@ -458,21 +458,21 @@ dnl
dnl #################################################################
AC_DEFUN([OMPI_CHECK_POWERPC_REG],[
AC_MSG_CHECKING([if PowerPC registers have r prefix])
OMPI_TRY_ASSEMBLE([$ompi_cv_asm_text
OMPI_TRY_ASSEMBLE([$opal_cv_asm_text
addi 1,1,0],
[ompi_cv_asm_powerpc_r_reg=0],
[OMPI_TRY_ASSEMBLE([$ompi_cv_asm_text
[opal_cv_asm_powerpc_r_reg=0],
[OMPI_TRY_ASSEMBLE([$opal_cv_asm_text
addi r1,r1,0],
[ompi_cv_asm_powerpc_r_reg=1],
[opal_cv_asm_powerpc_r_reg=1],
[AC_MSG_ERROR([Can not determine how to use PPC registers])])])
if test "$ompi_cv_asm_powerpc_r_reg" = "1" ; then
if test "$opal_cv_asm_powerpc_r_reg" = "1" ; then
AC_MSG_RESULT([yes])
else
AC_MSG_RESULT([no])
fi
AC_DEFINE_UNQUOTED([OMPI_POWERPC_R_REGISTERS],
[$ompi_cv_asm_powerpc_r_reg],
AC_DEFINE_UNQUOTED([OPAL_POWERPC_R_REGISTERS],
[$opal_cv_asm_powerpc_r_reg],
[Whether r notation is used for ppc registers])
])dnl
@ -496,12 +496,12 @@ AC_DEFUN([OMPI_CHECK_POWERPC_64BIT],[
case $host in
*-darwin*)
ppc64_result=0
if test "$ompi_cv_asm_powerpc_r_reg" = "1" ; then
if test "$opal_cv_asm_powerpc_r_reg" = "1" ; then
ldarx_asm=" ldarx r1,r1,r1";
else
ldarx_asm=" ldarx 1,1,1";
fi
OMPI_TRY_ASSEMBLE([$ompi_cv_asm_text
OMPI_TRY_ASSEMBLE([$opal_cv_asm_text
$ldarx_asm],
[ppc64_result=1],
[ppc64_result=0])
@ -531,7 +531,7 @@ dnl #################################################################
AC_DEFUN([OMPI_CHECK_SPARCV8PLUS],[
AC_MSG_CHECKING([if have Sparc v8+/v9 support])
sparc_result=0
OMPI_TRY_ASSEMBLE([$ompi_cv_asm_text
OMPI_TRY_ASSEMBLE([$opal_cv_asm_text
casa [%o0] 0x80, %o1, %o2],
[sparc_result=1],
[sparc_result=0])
@ -612,16 +612,16 @@ return ret;]]),
AC_MSG_RESULT([$asm_result])
if test "$asm_result" = "yes" ; then
OMPI_C_GCC_INLINE_ASSEMBLY=1
OPAL_C_GCC_INLINE_ASSEMBLY=1
else
OMPI_C_GCC_INLINE_ASSEMBLY=0
OPAL_C_GCC_INLINE_ASSEMBLY=0
fi
AC_DEFINE_UNQUOTED([OMPI_C_GCC_INLINE_ASSEMBLY],
[$OMPI_C_GCC_INLINE_ASSEMBLY],
AC_DEFINE_UNQUOTED([OPAL_C_GCC_INLINE_ASSEMBLY],
[$OPAL_C_GCC_INLINE_ASSEMBLY],
[Whether C compiler supports GCC style inline assembly])
unset OMPI_C_GCC_INLINE_ASSEMBLY assembly asm_result
unset OPAL_C_GCC_INLINE_ASSEMBLY assembly asm_result
])dnl
AC_DEFUN([OMPI_CHECK_INLINE_CXX_GCC],[
@ -700,16 +700,16 @@ return 0;]]),
AC_MSG_RESULT([$asm_result])
if test "$asm_result" = "yes" ; then
OMPI_C_DEC_INLINE_ASSEMBLY=1
OPAL_C_DEC_INLINE_ASSEMBLY=1
else
OMPI_C_DEC_INLINE_ASSEMBLY=0
OPAL_C_DEC_INLINE_ASSEMBLY=0
fi
AC_DEFINE_UNQUOTED([OMPI_C_DEC_INLINE_ASSEMBLY],
[$OMPI_C_DEC_INLINE_ASSEMBLY],
AC_DEFINE_UNQUOTED([OPAL_C_DEC_INLINE_ASSEMBLY],
[$OPAL_C_DEC_INLINE_ASSEMBLY],
[Whether C compiler supports DEC style inline assembly])
unset OMPI_C_DEC_INLINE_ASSEMBLY asm_result
unset OPAL_C_DEC_INLINE_ASSEMBLY asm_result
])dnl
AC_DEFUN([OMPI_CHECK_INLINE_CXX_DEC],[
@ -753,7 +753,7 @@ AC_DEFUN([OMPI_CHECK_INLINE_C_XLC],[
AC_MSG_CHECKING([if $CC supports XLC inline assembly])
OMPI_C_XLC_INLINE_ASSEMBLY=0
OPAL_C_XLC_INLINE_ASSEMBLY=0
asm_result="no"
if test "$CC" = "xlc" ; then
OMPI_XLC_INLINE_ASSEMBLY=1
@ -761,11 +761,11 @@ AC_DEFUN([OMPI_CHECK_INLINE_C_XLC],[
fi
AC_MSG_RESULT([$asm_result])
AC_DEFINE_UNQUOTED([OMPI_C_XLC_INLINE_ASSEMBLY],
[$OMPI_C_XLC_INLINE_ASSEMBLY],
AC_DEFINE_UNQUOTED([OPAL_C_XLC_INLINE_ASSEMBLY],
[$OPAL_C_XLC_INLINE_ASSEMBLY],
[Whether C compiler supports XLC style inline assembly])
unset OMPI_C_XLC_INLINE_ASSEMBLY
unset OPAL_C_XLC_INLINE_ASSEMBLY
])dnl
AC_DEFUN([OMPI_CHECK_INLINE_CXX_XLC],[
@ -792,10 +792,10 @@ dnl #################################################################
dnl
dnl OMPI_CONFIG_ASM
dnl
dnl DEFINE OMPI_ASSEMBLY_ARCH to something in sys/architecture.h
dnl DEFINE OMPI_ASSEMBLY_FORMAT to string containing correct
dnl DEFINE OPAL_ASSEMBLY_ARCH to something in sys/architecture.h
dnl DEFINE OPAL_ASSEMBLY_FORMAT to string containing correct
dnl format for assembly (not user friendly)
dnl SUBST OMPI_ASSEMBLY_FORMAT to string containing correct
dnl SUBST OPAL_ASSEMBLY_FORMAT to string containing correct
dnl format for assembly (not user friendly)
dnl
dnl #################################################################
@ -843,7 +843,7 @@ AC_DEFUN([OMPI_CONFIG_ASM],[
AC_MSG_RESULT([no])
want_smp_locks=0
fi
AC_DEFINE_UNQUOTED([OMPI_WANT_SMP_LOCKS], [$want_smp_locks],
AC_DEFINE_UNQUOTED([OPAL_WANT_SMP_LOCKS], [$want_smp_locks],
[whether we want to have smp locks in atomic ops or not])
if test "$ompi_cv_c_compiler_vendor" = "microsoft" ; then
@ -863,7 +863,7 @@ AC_DEFUN([OMPI_CONFIG_ASM],[
# find our architecture for purposes of assembly stuff
ompi_cv_asm_arch="UNSUPPORTED"
OMPI_GCC_INLINE_ASSIGN=""
OMPI_ASM_SUPPORT_64BIT=0
OPAL_ASM_SUPPORT_64BIT=0
case "${host}" in
i?86-*|x86_64*)
if test "$ac_cv_sizeof_long" = "4" ; then
@ -871,19 +871,19 @@ AC_DEFUN([OMPI_CONFIG_ASM],[
else
ompi_cv_asm_arch="AMD64"
fi
OMPI_ASM_SUPPORT_64BIT=1
OPAL_ASM_SUPPORT_64BIT=1
OMPI_GCC_INLINE_ASSIGN='"movl [$]0, %0" : "=&r"(ret)'
;;
ia64-*)
ompi_cv_asm_arch="IA64"
OMPI_ASM_SUPPORT_64BIT=1
OPAL_ASM_SUPPORT_64BIT=1
OMPI_GCC_INLINE_ASSIGN='"mov %0=r0\n;;\n" : "=&r"(ret)'
;;
alpha-*|alphaev[[4-8]]-*|alphaev56-*|alphaev6[[78]]-*)
ompi_cv_asm_arch="ALPHA"
OMPI_ASM_SUPPORT_64BIT=1
OPAL_ASM_SUPPORT_64BIT=1
OMPI_GCC_INLINE_ASSIGN='"bis [$]31,[$]31,%0" : "=&r"(ret)'
;;
@ -891,7 +891,7 @@ AC_DEFUN([OMPI_CONFIG_ASM],[
# Should really find some way to make sure that we are on
# a MIPS III machine (r4000 and later)
ompi_cv_asm_arch="MIPS"
OMPI_ASM_SUPPORT_64BIT=1
OPAL_ASM_SUPPORT_64BIT=1
OMPI_GCC_INLINE_ASSIGN='"or %0,[$]0,[$]0" : "=&r"(ret)'
;;
@ -904,9 +904,9 @@ AC_DEFUN([OMPI_CONFIG_ASM],[
# compiling in 32 bit mode (and therefore should assume
# sizeof(long) == 4), we can use the 64 bit test and set
# operations.
OMPI_CHECK_POWERPC_64BIT(OMPI_ASM_SUPPORT_64BIT=1)
OMPI_CHECK_POWERPC_64BIT(OPAL_ASM_SUPPORT_64BIT=1)
elif test "$ac_cv_sizeof_long" = "8" ; then
OMPI_ASM_SUPPORT_64BIT=1
OPAL_ASM_SUPPORT_64BIT=1
ompi_cv_asm_arch="POWERPC64"
else
AC_MSG_ERROR([Could not determine PowerPC word size: $ac_cv_sizeof_long])
@ -922,7 +922,7 @@ AC_DEFUN([OMPI_CONFIG_ASM],[
have_v8plus=0
OMPI_CHECK_SPARCV8PLUS([have_v8plus=1])
if test "$have_v8plus" = "0" ; then
OMPI_ASM_SUPPORT_64BIT=0
OPAL_ASM_SUPPORT_64BIT=0
ompi_cv_asm_arch="SPARC"
AC_MSG_WARN([Sparc v8 target is not supported in this release of Open MPI.])
AC_MSG_WARN([You must specify the target architecture v8plus])
@ -931,12 +931,12 @@ AC_MSG_WARN([FFLAGS, and FCFLAGS to compile Open MPI in 32 bit mode on])
AC_MSG_WARN([Sparc processors])
AC_MSG_ERROR([Can not continue.])
else
OMPI_ASM_SUPPORT_64BIT=1
OPAL_ASM_SUPPORT_64BIT=1
ompi_cv_asm_arch="SPARCV9_32"
fi
elif test "$ac_cv_sizeof_long" = "8" ; then
OMPI_ASM_SUPPORT_64BIT=1
OPAL_ASM_SUPPORT_64BIT=1
ompi_cv_asm_arch="SPARCV9_64"
else
AC_MSG_ERROR([Could not determine Sparc word size: $ac_cv_sizeof_long])
@ -949,10 +949,10 @@ AC_MSG_ERROR([Can not continue.])
;;
esac
AC_DEFINE_UNQUOTED([OMPI_ASM_SUPPORT_64BIT],
[$OMPI_ASM_SUPPORT_64BIT],
AC_DEFINE_UNQUOTED([OPAL_ASM_SUPPORT_64BIT],
[$OPAL_ASM_SUPPORT_64BIT],
[Whether we can do 64bit assembly operations or not. Should not be used outside of the assembly header files])
AC_SUBST([OMPI_ASM_SUPPORT_64BIT])
AC_SUBST([OPAL_ASM_SUPPORT_64BIT])
#
# figure out if we need any special function start / stop code
@ -977,37 +977,37 @@ AC_MSG_ERROR([Can not continue.])
# format:
# config_file-text-global-label_suffix-gsym-lsym-type-size-align_log-ppc_r_reg-64_bit-gnu_stack
asm_format="${ompi_asm_arch_config}"
asm_format="${asm_format}-${ompi_cv_asm_text}-${ompi_cv_asm_global}"
asm_format="${asm_format}-${ompi_cv_asm_label_suffix}-${ompi_cv_asm_gsym}"
asm_format="${asm_format}-${ompi_cv_asm_lsym}"
asm_format="${asm_format}-${ompi_cv_asm_type}-${ompi_asm_size}"
asm_format="${asm_format}-${opal_cv_asm_text}-${opal_cv_asm_global}"
asm_format="${asm_format}-${opal_cv_asm_label_suffix}-${opal_cv_asm_gsym}"
asm_format="${asm_format}-${opal_cv_asm_lsym}"
asm_format="${asm_format}-${opal_cv_asm_type}-${opal_asm_size}"
asm_format="${asm_format}-${ompi_asm_align_log_result}"
if test "$ompi_cv_asm_arch" = "POWERPC32" -o "$ompi_cv_asm_arch" = "POWERPC64" ; then
asm_format="${asm_format}-${ompi_cv_asm_powerpc_r_reg}"
asm_format="${asm_format}-${opal_cv_asm_powerpc_r_reg}"
else
asm_format="${asm_format}-1"
fi
asm_format="${asm_format}-${OMPI_ASM_SUPPORT_64BIT}"
asm_format="${asm_format}-${OPAL_ASM_SUPPORT_64BIT}"
ompi_cv_asm_format="${asm_format}-${ompi_cv_asm_gnu_stack}"
# For the Makefile, need to escape the $ as $$. Don't display
# this version, but make sure the Makefile gives the right thing
# when regenerating the files because the base has been touched.
OMPI_ASSEMBLY_FORMAT=`echo "$ompi_cv_asm_format" | sed -e 's/\\\$/\\\$\\\$/'`
OPAL_ASSEMBLY_FORMAT=`echo "$ompi_cv_asm_format" | sed -e 's/\\\$/\\\$\\\$/'`
AC_MSG_CHECKING([for assembly format])
AC_MSG_RESULT([$ompi_cv_asm_format])
AC_DEFINE_UNQUOTED([OMPI_ASSEMBLY_FORMAT], ["$OMPI_ASSEMBLY_FORMAT"],
AC_DEFINE_UNQUOTED([OPAL_ASSEMBLY_FORMAT], ["$OPAL_ASSEMBLY_FORMAT"],
[Format of assembly file])
AC_SUBST([OMPI_ASSEMBLY_FORMAT])
AC_SUBST([OPAL_ASSEMBLY_FORMAT])
fi # if cv_c_compiler_vendor = microsoft
result="OMPI_$ompi_cv_asm_arch"
OMPI_ASSEMBLY_ARCH="$ompi_cv_asm_arch"
OPAL_ASSEMBLY_ARCH="$ompi_cv_asm_arch"
AC_MSG_CHECKING([for asssembly architecture])
AC_MSG_RESULT([$ompi_cv_asm_arch])
AC_DEFINE_UNQUOTED([OMPI_ASSEMBLY_ARCH], [$result],
AC_DEFINE_UNQUOTED([OPAL_ASSEMBLY_ARCH], [$result],
[Architecture type of assembly to use for atomic operations])
AC_SUBST([OMPI_ASSEMBLY_ARCH])
AC_SUBST([OPAL_ASSEMBLY_ARCH])
OMPI_ASM_FIND_FILE
@ -1089,9 +1089,9 @@ fi
result=1
fi
AC_DEFINE_UNQUOTED([OMPI_HAVE_ASM_FILE], [$result],
AC_DEFINE_UNQUOTED([OPAL_HAVE_ASM_FILE], [$result],
[Whether there is an atomic assembly file available])
AM_CONDITIONAL([OMPI_HAVE_ASM_FILE], [test "$result" = "1"])
AM_CONDITIONAL([OPAL_HAVE_ASM_FILE], [test "$result" = "1"])
OMPI_ASM_FILE=$ompi_cv_asm_file
AC_SUBST(OMPI_ASM_FILE)

46
config/ompi_config_threads.m4
View File

@ -30,9 +30,9 @@ AC_DEFUN([OMPI_CONFIG_THREADS],[
#
# create templates
AH_TEMPLATE([OMPI_HAVE_SOLARIS_THREADS],
AH_TEMPLATE([OPAL_HAVE_SOLARIS_THREADS],
[Do we have native Solaris threads])
AH_TEMPLATE([OMPI_HAVE_POSIX_THREADS],
AH_TEMPLATE([OPAL_HAVE_POSIX_THREADS],
[Do we have POSIX threads])
#
@ -117,13 +117,13 @@ AC_MSG_RESULT($THREAD_TYPE)
#
# Blah - this should be made better, but I don't know how...
#
AH_TEMPLATE([OMPI_THREADS_HAVE_DIFFERENT_PIDS],
AH_TEMPLATE([OPAL_THREADS_HAVE_DIFFERENT_PIDS],
[Do threads have different pids (pthreads on linux)])
if test "$THREAD_TYPE" = "solaris"; then
AC_DEFINE(OMPI_HAVE_SOLARIS_THREADS, 1)
AC_DEFINE(OMPI_HAVE_POSIX_THREADS, 0)
AC_DEFINE(OMPI_THREADS_HAVE_DIFFERENT_PIDS, 0)
AC_DEFINE(OPAL_HAVE_SOLARIS_THREADS, 1)
AC_DEFINE(OPAL_HAVE_POSIX_THREADS, 0)
AC_DEFINE(OPAL_THREADS_HAVE_DIFFERENT_PIDS, 0)
THREAD_CFLAGS="$STHREAD_CFLAGS"
THREAD_FFLAGS="$STHREAD_FFLAGS"
@ -133,8 +133,8 @@ if test "$THREAD_TYPE" = "solaris"; then
THREAD_LDFLAGS="$STHREAD_LDFLAGS"
THREAD_LIBS="$STHREAD_LIBS"
elif test "$THREAD_TYPE" = "posix"; then
AC_DEFINE(OMPI_HAVE_SOLARIS_THREADS, 0)
AC_DEFINE(OMPI_HAVE_POSIX_THREADS, 1)
AC_DEFINE(OPAL_HAVE_SOLARIS_THREADS, 0)
AC_DEFINE(OPAL_HAVE_POSIX_THREADS, 1)
THREAD_CFLAGS="$PTHREAD_CFLAGS"
THREAD_FFLAGS="$PTHREAD_FFLAGS"
@ -146,9 +146,9 @@ elif test "$THREAD_TYPE" = "posix"; then
OMPI_CHECK_PTHREAD_PIDS
else
AC_DEFINE(OMPI_HAVE_SOLARIS_THREADS, 0)
AC_DEFINE(OMPI_HAVE_POSIX_THREADS, 0)
AC_DEFINE(OMPI_THREADS_HAVE_DIFFERENT_PIDS, 0)
AC_DEFINE(OPAL_HAVE_SOLARIS_THREADS, 0)
AC_DEFINE(OPAL_HAVE_POSIX_THREADS, 0)
AC_DEFINE(OPAL_THREADS_HAVE_DIFFERENT_PIDS, 0)
TRHEAD_CFLAGS=
THREAD_FFLAGS=
@ -175,8 +175,8 @@ EOF
fi
fi
AM_CONDITIONAL(OMPI_HAVE_POSIX_THREADS, test "$THREAD_TYPE" = "posix")
AM_CONDITIONAL(OMPI_HAVE_SOLARIS_THREADS, test "$THREAD_TYPE" = "solaris")
AM_CONDITIONAL(OPAL_HAVE_POSIX_THREADS, test "$THREAD_TYPE" = "posix")
AM_CONDITIONAL(OPAL_HAVE_SOLARIS_THREADS, test "$THREAD_TYPE" = "solaris")
#
# Now configure the whole MPI and progress thread gorp
@ -191,27 +191,27 @@ if test "$enable_mpi_threads" = "" ; then
dnl # no argument given either way. Default to whether
dnl # we have threads or not
dnl if test "$THREAD_TYPE" != "none" ; then
dnl OMPI_ENABLE_MPI_THREADS=1
dnl OPAL_ENABLE_MPI_THREADS=1
dnl enable_mpi_threads="yes"
dnl else
dnl OMPI_ENABLE_MPI_THREADS=0
dnl OPAL_ENABLE_MPI_THREADS=0
dnl enable_mpi_threads="no"
dnl fi
# no argument - default to no
OMPI_ENABLE_MPI_THREADS=0
OPAL_ENABLE_MPI_THREADS=0
enable_mpi_threads="no"
elif test "$enable_mpi_threads" = "no" ; then
OMPI_ENABLE_MPI_THREADS=0
OPAL_ENABLE_MPI_THREADS=0
else
# they want MPI threads. Make sure we have threads
if test "$THREAD_TYPE" != "none" ; then
OMPI_ENABLE_MPI_THREADS=1
OPAL_ENABLE_MPI_THREADS=1
enable_mpi_threads="yes"
else
AC_MSG_ERROR([User requested MPI threads, but no threading model supported])
fi
fi
AC_DEFINE_UNQUOTED([OMPI_ENABLE_MPI_THREADS], [$OMPI_ENABLE_MPI_THREADS],
AC_DEFINE_UNQUOTED([OPAL_ENABLE_MPI_THREADS], [$OPAL_ENABLE_MPI_THREADS],
[Whether we should enable support for multiple user threads])
AC_MSG_RESULT([$enable_mpi_threads])
@ -224,21 +224,21 @@ AC_ARG_ENABLE([progress-threads],
if test "$enable_progress_threads" = "" ; then
# no argument given either way. Default to no.
OMPI_ENABLE_PROGRESS_THREADS=0
OPAL_ENABLE_PROGRESS_THREADS=0
enable_progress_threads="no"
elif test "$enable_progress_threads" = "no" ; then
OMPI_ENABLE_PROGRESS_THREADS=0
OPAL_ENABLE_PROGRESS_THREADS=0
enable_progress_threads="no"
else
# they want threaded progress
if test "$THREAD_TYPE" != "none" ; then
OMPI_ENABLE_PROGRESS_THREADS=1
OPAL_ENABLE_PROGRESS_THREADS=1
enable_progress_threads="yes"
else
AC_MSG_ERROR([User requested progress threads, but no threading model supported])
fi
fi
AC_DEFINE_UNQUOTED([OMPI_ENABLE_PROGRESS_THREADS], [$OMPI_ENABLE_PROGRESS_THREADS],
AC_DEFINE_UNQUOTED([OPAL_ENABLE_PROGRESS_THREADS], [$OPAL_ENABLE_PROGRESS_THREADS],
[Whether we should use progress threads rather than polling])
AC_MSG_RESULT([$enable_progress_threads])

22
config/ompi_configure_options.m4
View File

@ -95,7 +95,7 @@ if test "$WANT_MEM_DEBUG" = "0" -a -z "$enable_mem_debug" -a "$OMPI_DEVEL" = 1;
echo "--> developer override: enable mem profiling by default"
fi
#################### Early development override ####################
AC_DEFINE_UNQUOTED(OMPI_ENABLE_MEM_DEBUG, $WANT_MEM_DEBUG,
AC_DEFINE_UNQUOTED(OPAL_ENABLE_MEM_DEBUG, $WANT_MEM_DEBUG,
[Whether we want the memory profiling or not])
#
@ -119,7 +119,7 @@ if test "$WANT_MEM_PROFILE" = "0" -a -z "$enable_mem_profile" -a "$OMPI_DEVEL" =
echo "--> developer override: enable mem profiling by default"
fi
#################### Early development override ####################
AC_DEFINE_UNQUOTED(OMPI_ENABLE_MEM_PROFILE, $WANT_MEM_PROFILE,
AC_DEFINE_UNQUOTED(OPAL_ENABLE_MEM_PROFILE, $WANT_MEM_PROFILE,
[Whether we want the memory profiling or not])
#
@ -169,7 +169,7 @@ if test "$WANT_DEBUG" = "0"; then
CFLAGS="-DNDEBUG $CFLAGS"
CXXFLAGS="-DNDEBUG $CXXFLAGS"
fi
AC_DEFINE_UNQUOTED(OMPI_ENABLE_DEBUG, $WANT_DEBUG,
AC_DEFINE_UNQUOTED(OPAL_ENABLE_DEBUG, $WANT_DEBUG,
[Whether we want developer-level debugging code or not])
AC_ARG_ENABLE(debug-symbols,
@ -399,7 +399,7 @@ else
AC_MSG_RESULT([yes])
WANT_PRETTY_PRINT_STACKTRACE=1
fi
AC_DEFINE_UNQUOTED([OMPI_WANT_PRETTY_PRINT_STACKTRACE],
AC_DEFINE_UNQUOTED([OPAL_WANT_PRETTY_PRINT_STACKTRACE],
[$WANT_PRETTY_PRINT_STACKTRACE],
[if want pretty-print stack trace feature])
@ -457,12 +457,12 @@ AC_ARG_ENABLE(pty-support,
[Enable/disable PTY support for STDIO forwarding. (default: enabled)]))
if test "$enable_pty_support" = "no" ; then
AC_MSG_RESULT([no])
OMPI_ENABLE_PTY_SUPPORT=0
OPAL_ENABLE_PTY_SUPPORT=0
else
AC_MSG_RESULT([yes])
OMPI_ENABLE_PTY_SUPPORT=1
OPAL_ENABLE_PTY_SUPPORT=1
fi
AC_DEFINE_UNQUOTED([OMPI_ENABLE_PTY_SUPPORT], [$OMPI_ENABLE_PTY_SUPPORT],
AC_DEFINE_UNQUOTED([OPAL_ENABLE_PTY_SUPPORT], [$OPAL_ENABLE_PTY_SUPPORT],
[Whether user wants PTY support or not])
#
@ -478,10 +478,10 @@ AC_ARG_ENABLE([dlopen],
if test "$enable_dlopen" = "no" ; then
enable_mca_dso="no"
enable_mca_static="yes"
OMPI_ENABLE_DLOPEN_SUPPORT=0
OPAL_ENABLE_DLOPEN_SUPPORT=0
AC_MSG_RESULT([no])
else
OMPI_ENABLE_DLOPEN_SUPPORT=1
OPAL_ENABLE_DLOPEN_SUPPORT=1
AC_MSG_RESULT([yes])
fi
@ -501,7 +501,7 @@ else
AC_MSG_RESULT([no])
ompi_want_heterogeneous=0
fi
AC_DEFINE_UNQUOTED([OMPI_ENABLE_HETEROGENEOUS_SUPPORT],
AC_DEFINE_UNQUOTED([OPAL_ENABLE_HETEROGENEOUS_SUPPORT],
[$ompi_want_heterogeneous],
[Enable features required for heterogeneous support])
@ -655,7 +655,7 @@ if test "$enable_per_user_config_files" = "no" ; then
else
result=1
fi
AC_DEFINE_UNQUOTED([OMPI_WANT_HOME_CONFIG_FILES], [$result],
AC_DEFINE_UNQUOTED([OPAL_WANT_HOME_CONFIG_FILES], [$result],
[Enable per-user config files])
#

2
config/ompi_functions.m4
View File

@ -96,7 +96,7 @@ AC_SUBST(CLEANFILES)
#
AC_CANONICAL_HOST
AC_DEFINE_UNQUOTED(OMPI_ARCH, "$host", [OMPI architecture string])
AC_DEFINE_UNQUOTED(OPAL_ARCH, "$host", [OMPI architecture string])
#
# See if we can find an old installation of OMPI to overwrite

10
config/ompi_setup_cc.m4
View File

@ -228,7 +228,7 @@ AC_DEFUN([OMPI_SETUP_CC],[
else
have_builtin_expect=0
fi
AC_DEFINE_UNQUOTED([OMPI_C_HAVE_BUILTIN_EXPECT], [$have_builtin_expect],
AC_DEFINE_UNQUOTED([OPAL_C_HAVE_BUILTIN_EXPECT], [$have_builtin_expect],
[Whether C compiler supports __builtin_expect])
# see if the C compiler supports __builtin_prefetch
@ -244,7 +244,7 @@ AC_DEFUN([OMPI_SETUP_CC],[
else
have_builtin_prefetch=0
fi
AC_DEFINE_UNQUOTED([OMPI_C_HAVE_BUILTIN_PREFETCH], [$have_builtin_prefetch],
AC_DEFINE_UNQUOTED([OPAL_C_HAVE_BUILTIN_PREFETCH], [$have_builtin_prefetch],
[Whether C compiler supports __builtin_prefetch])
# Preload the optflags for the case where the user didn't specify
@ -320,9 +320,9 @@ AC_DEFUN([_OMPI_PROG_CC],[
AC_PROG_CC
BASECC="`basename $CC`"
CFLAGS="$ompi_cflags_save"
AC_DEFINE_UNQUOTED(OMPI_CC, "$CC", [OMPI underlying C compiler])
AC_DEFINE_UNQUOTED(OPAL_CC, "$CC", [OMPI underlying C compiler])
set dummy $CC
ompi_cc_argv0=[$]2
OMPI_WHICH([$ompi_cc_argv0], [OMPI_CC_ABSOLUTE])
AC_SUBST(OMPI_CC_ABSOLUTE)
OMPI_WHICH([$ompi_cc_argv0], [OPAL_CC_ABSOLUTE])
AC_SUBST(OPAL_CC_ABSOLUTE)
])

68
configure.ac
View File

@ -266,18 +266,18 @@ fi
# Check for type alignments
#
OMPI_C_GET_ALIGNMENT(char, OMPI_ALIGNMENT_CHAR)
OMPI_C_GET_ALIGNMENT(short, OMPI_ALIGNMENT_SHORT)
OMPI_C_GET_ALIGNMENT(char, OPAL_ALIGNMENT_CHAR)
OMPI_C_GET_ALIGNMENT(short, OPAL_ALIGNMENT_SHORT)
OMPI_C_GET_ALIGNMENT(wchar_t, OMPI_ALIGNMENT_WCHAR)
OMPI_C_GET_ALIGNMENT(int, OMPI_ALIGNMENT_INT)
OMPI_C_GET_ALIGNMENT(long, OMPI_ALIGNMENT_LONG)
OMPI_C_GET_ALIGNMENT(int, OPAL_ALIGNMENT_INT)
OMPI_C_GET_ALIGNMENT(long, OPAL_ALIGNMENT_LONG)
if test $ac_cv_type_long_long = yes; then
OMPI_C_GET_ALIGNMENT(long long, OMPI_ALIGNMENT_LONG_LONG)
OMPI_C_GET_ALIGNMENT(long long, OPAL_ALIGNMENT_LONG_LONG)
fi
OMPI_C_GET_ALIGNMENT(float, OMPI_ALIGNMENT_FLOAT)
OMPI_C_GET_ALIGNMENT(double, OMPI_ALIGNMENT_DOUBLE)
if test $ac_cv_type_long_double = yes; then
OMPI_C_GET_ALIGNMENT(long double, OMPI_ALIGNMENT_LONG_DOUBLE)
OMPI_C_GET_ALIGNMENT(long double, OPAL_ALIGNMENT_LONG_DOUBLE)
fi
OMPI_C_GET_ALIGNMENT(void *, OMPI_ALIGNMENT_VOID_P)
@ -290,8 +290,8 @@ AC_MSG_CHECKING(for C bool type)
AC_COMPILE_IFELSE(AC_LANG_PROGRAM([[
AC_INCLUDES_DEFAULT]],
[[bool bar, foo = true; bar = foo;]]),
[OMPI_NEED_C_BOOL=0 MSG=yes],[OMPI_NEED_C_BOOL=1 MSG=no])
AC_DEFINE_UNQUOTED(OMPI_NEED_C_BOOL, $OMPI_NEED_C_BOOL,
[OPAL_NEED_C_BOOL=0 MSG=yes],[OPAL_NEED_C_BOOL=1 MSG=no])
AC_DEFINE_UNQUOTED(OPAL_NEED_C_BOOL, $OPAL_NEED_C_BOOL,
[Whether the C compiler supports "bool" without any other help (such as <stdbool.h>)])
AC_MSG_RESULT([$MSG])
@ -344,10 +344,10 @@ fi
# separate directory.
if test "$WANT_WEAK_SYMBOLS" = "0"; then
OMPI_C_HAVE_WEAK_SYMBOLS=0
OPAL_C_HAVE_WEAK_SYMBOLS=0
fi
if test "$WANT_MPI_PROFILING" = "1"; then
if test "$OMPI_C_HAVE_WEAK_SYMBOLS" = "1"; then
if test "$OPAL_C_HAVE_WEAK_SYMBOLS" = "1"; then
OMPI_PROFILING_COMPILE_SEPARATELY=0
else
OMPI_PROFILING_COMPILE_SEPARATELY=1
@ -379,7 +379,7 @@ AM_CONDITIONAL(COMPILE_PROFILING_SEPARATELY,
test "$OMPI_PROFILING_COMPILE_SEPARATELY" = 1)
AC_DEFINE_UNQUOTED(OMPI_ENABLE_MPI_PROFILING, $WANT_MPI_PROFILING,
[Whether we want MPI profiling or not])
AC_DEFINE_UNQUOTED(OMPI_HAVE_WEAK_SYMBOLS, $OMPI_C_HAVE_WEAK_SYMBOLS,
AC_DEFINE_UNQUOTED(OPAL_HAVE_WEAK_SYMBOLS, $OPAL_C_HAVE_WEAK_SYMBOLS,
[Whether we have weak symbols or not])
@ -676,7 +676,7 @@ AC_CHECK_HEADERS([net/if.h], [], [],
# So first figure out if we have <stdbool.h> (i.e., check the value of
# the macro HAVE_STDBOOL_H from the result of AC_CHECK_HEADERS,
# above). If we do have it, then check to see if it actually works.
# Define OMPI_USE_STDBOOL_H as approrpaite.
# Define OPAL_USE_STDBOOL_H as approrpaite.
AC_CHECK_HEADERS([stdbool.h], [have_stdbool_h=1], [have_stdbool_h=0])
AC_MSG_CHECKING([if <stdbool.h> works])
if test "$have_stdbool_h" = "1"; then
@ -686,12 +686,12 @@ AC_INCLUDES_DEFAULT
#include <stdbool.h>
#endif]],
[[bool bar, foo = true; bar = foo;]]),
[OMPI_USE_STDBOOL_H=1 MSG=yes],[OMPI_USE_STDBOOL_H=0 MSG=no])
[OPAL_USE_STDBOOL_H=1 MSG=yes],[OPAL_USE_STDBOOL_H=0 MSG=no])
else
OMPI_USE_STDBOOL_H=0
OPAL_USE_STDBOOL_H=0
MSG="no (don't have <stdbool.h>)"
fi
AC_DEFINE_UNQUOTED(OMPI_USE_STDBOOL_H, $OMPI_USE_STDBOOL_H,
AC_DEFINE_UNQUOTED(OPAL_USE_STDBOOL_H, $OPAL_USE_STDBOOL_H,
[Whether to use <stdbool.h> or not])
AC_MSG_RESULT([$MSG])
@ -734,7 +734,7 @@ AC_EGREP_CPP(yes, [
#ifdef SA_RESTART
yes
#endif ], [MSG=yes VALUE=1], [MSG=no VALUE=0])
AC_DEFINE_UNQUOTED(OMPI_HAVE_SA_RESTART, $VALUE,
AC_DEFINE_UNQUOTED(OPAL_HAVE_SA_RESTART, $VALUE,
[Whether we have SA_RESTART in <signal.h> or not])
AC_MSG_RESULT([$MSG])
@ -809,14 +809,14 @@ AS_IF([test "$ompi_cv_htonl_define" = "yes" -o "$ompi_have_htonl" = "yes"],
# Make sure we can copy va_lists (need check declared, not linkable)
#
AC_CHECK_DECL(va_copy, OMPI_HAVE_VA_COPY=1, OMPI_HAVE_VA_COPY=0,
AC_CHECK_DECL(va_copy, OPAL_HAVE_VA_COPY=1, OPAL_HAVE_VA_COPY=0,
[#include <stdarg.h>])
AC_DEFINE_UNQUOTED(OMPI_HAVE_VA_COPY, $OMPI_HAVE_VA_COPY,
AC_DEFINE_UNQUOTED(OPAL_HAVE_VA_COPY, $OPAL_HAVE_VA_COPY,
[Whether we have va_copy or not])
AC_CHECK_DECL(__va_copy, OMPI_HAVE_UNDERSCORE_VA_COPY=1,
OMPI_HAVE_UNDERSCORE_VA_COPY=0, [#include <stdarg.h>])
AC_DEFINE_UNQUOTED(OMPI_HAVE_UNDERSCORE_VA_COPY, $OMPI_HAVE_UNDERSCORE_VA_COPY,
AC_CHECK_DECL(__va_copy, OPAL_HAVE_UNDERSCORE_VA_COPY=1,
OPAL_HAVE_UNDERSCORE_VA_COPY=0, [#include <stdarg.h>])
AC_DEFINE_UNQUOTED(OPAL_HAVE_UNDERSCORE_VA_COPY, $OPAL_HAVE_UNDERSCORE_VA_COPY,
[Whether we have __va_copy or not])
AC_CHECK_DECLS(__func__)
@ -876,15 +876,15 @@ AC_DEFINE_UNQUOTED(OMPI_MPI_OFFSET_TYPE, $MPI_OFFSET_TYPE, [Type of MPI_Offset -
# sizeof(void*) != sizeof(long) (64 bit Windows, apparently).
#
if test $ac_cv_type_ptrdiff_t = yes ; then
ompi_ptrdiff_t="ptrdiff_t"
opal_ptrdiff_t="ptrdiff_t"
elif test $ac_cv_sizeof_void_p -eq $ac_cv_sizeof_long ; then
ompi_ptrdiff_t="long"
opal_ptrdiff_t="long"
elif test $ac_cv_type_long_long = yes -a $ac_cv_sizeof_void_p -eq $ac_cv_sizeof_long_long ; then
ompi_ptrdiff_t="long long"
opal_ptrdiff_t="long long"
else
AC_MSG_ERROR([Could not find datatype to emulate ptrdiff_t. Cannot continue])
fi
AC_DEFINE_UNQUOTED([OMPI_PTRDIFF_TYPE], [$ompi_ptrdiff_t],
AC_DEFINE_UNQUOTED([OPAL_PTRDIFF_TYPE], [$opal_ptrdiff_t],
[type to use for ptrdiff_t])
#