From 54df2afaa61c6a03cbb4a33c9b90fa572b6d07b8 Mon Sep 17 00:00:00 2001 From: Jesse Morgan Date: Sat, 17 Dec 2016 21:28:53 -0800 Subject: Berkeley DB 4.8 with rust build script for linux. --- db-4.8.30/dist/aclocal/mutex.m4 | 851 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 851 insertions(+) create mode 100644 db-4.8.30/dist/aclocal/mutex.m4 (limited to 'db-4.8.30/dist/aclocal/mutex.m4') diff --git a/db-4.8.30/dist/aclocal/mutex.m4 b/db-4.8.30/dist/aclocal/mutex.m4 new file mode 100644 index 0000000..e2fa95a --- /dev/null +++ b/db-4.8.30/dist/aclocal/mutex.m4 @@ -0,0 +1,851 @@ +# $Id$ + +# POSIX pthreads tests: inter-process safe and intra-process only. +AC_DEFUN(AM_PTHREADS_SHARED, [ +AC_TRY_RUN([ +#include +main() { + pthread_cond_t cond; + pthread_mutex_t mutex; + pthread_condattr_t condattr; + pthread_mutexattr_t mutexattr; + exit ( + pthread_condattr_init(&condattr) || + pthread_condattr_setpshared(&condattr, PTHREAD_PROCESS_SHARED) || + pthread_mutexattr_init(&mutexattr) || + pthread_mutexattr_setpshared(&mutexattr, PTHREAD_PROCESS_SHARED) || + pthread_cond_init(&cond, &condattr) || + pthread_mutex_init(&mutex, &mutexattr) || + pthread_mutex_lock(&mutex) || + pthread_mutex_unlock(&mutex) || + pthread_mutex_destroy(&mutex) || + pthread_cond_destroy(&cond) || + pthread_condattr_destroy(&condattr) || + pthread_mutexattr_destroy(&mutexattr)); +}], [db_cv_mutex="$1"],, +AC_TRY_LINK([ +#include ],[ + pthread_cond_t cond; + pthread_mutex_t mutex; + pthread_condattr_t condattr; + pthread_mutexattr_t mutexattr; + exit ( + pthread_condattr_init(&condattr) || + pthread_condattr_setpshared(&condattr, PTHREAD_PROCESS_SHARED) || + pthread_mutexattr_init(&mutexattr) || + pthread_mutexattr_setpshared(&mutexattr, PTHREAD_PROCESS_SHARED) || + pthread_cond_init(&cond, &condattr) || + pthread_mutex_init(&mutex, &mutexattr) || + pthread_mutex_lock(&mutex) || + pthread_mutex_unlock(&mutex) || + pthread_mutex_destroy(&mutex) || + pthread_cond_destroy(&cond) || + pthread_condattr_destroy(&condattr) || + pthread_mutexattr_destroy(&mutexattr)); +], [db_cv_mutex="$1"]))]) +AC_DEFUN(AM_PTHREADS_PRIVATE, [ +AC_TRY_RUN([ +#include +main() { + pthread_cond_t cond; + pthread_mutex_t mutex; + pthread_condattr_t condattr; + pthread_mutexattr_t mutexattr; + exit ( + pthread_condattr_init(&condattr) || + pthread_mutexattr_init(&mutexattr) || + pthread_cond_init(&cond, &condattr) || + pthread_mutex_init(&mutex, &mutexattr) || + pthread_mutex_lock(&mutex) || + pthread_mutex_unlock(&mutex) || + pthread_mutex_destroy(&mutex) || + pthread_cond_destroy(&cond) || + pthread_condattr_destroy(&condattr) || + pthread_mutexattr_destroy(&mutexattr)); +}], [db_cv_mutex="$1"],, +AC_TRY_LINK([ +#include ],[ + pthread_cond_t cond; + pthread_mutex_t mutex; + pthread_condattr_t condattr; + pthread_mutexattr_t mutexattr; + exit ( + pthread_condattr_init(&condattr) || + pthread_mutexattr_init(&mutexattr) || + pthread_cond_init(&cond, &condattr) || + pthread_mutex_init(&mutex, &mutexattr) || + pthread_mutex_lock(&mutex) || + pthread_mutex_unlock(&mutex) || + pthread_mutex_destroy(&mutex) || + pthread_cond_destroy(&cond) || + pthread_condattr_destroy(&condattr) || + pthread_mutexattr_destroy(&mutexattr)); +], [db_cv_mutex="$1"]))]) + +# Figure out mutexes for this compiler/architecture. +# +# There are 3 mutex groups in BDB: pthreads-style, test-and-set, or a hybrid +# combination of the two. We first test for the pthreads-style mutex, and +# then for a test-and-set mutex. +AC_DEFUN(AM_DEFINE_MUTEXES, [ + +# Mutexes we don't test for, but want the #defines to exist for other ports. +AH_TEMPLATE(HAVE_MUTEX_VMS, [Define to 1 to use VMS mutexes.]) +AH_TEMPLATE(HAVE_MUTEX_VXWORKS, [Define to 1 to use VxWorks mutexes.]) + +AC_CACHE_CHECK([for mutexes], db_cv_mutex, [ + +orig_libs=$LIBS + +db_cv_mutex=no + +# Mutexes can be disabled. +if test "$db_cv_build_mutexsupport" = no; then + db_cv_mutex=disabled; +fi + +# User-specified Win32 mutexes (MinGW build) +if test "$db_cv_mingw" = yes; then + db_cv_mutex=win32/gcc +fi + +if test "$db_cv_mutex" = no; then + # User-specified POSIX or UI mutexes. + # + # There are two different reasons to specify mutexes: First, the + # application is already using one type of mutex and doesn't want + # to mix-and-match (for example, on Solaris, which has POSIX, UI + # and LWP mutexes). Second, the application's POSIX pthreads + # mutexes don't support inter-process locking, but the application + # wants to use them anyway (for example, some Linux and *BSD systems). + # + # Test for POSIX threads before testing for UI/LWP threads, they are + # the Sun-recommended choice on Solaris. Also, there are Linux systems + # that support a UI compatibility mode, and applications are more + # likely to be written for POSIX threads than UI threads. + if test "$db_cv_posixmutexes" = yes; then + db_cv_mutex=posix_only; + fi + if test "$db_cv_uimutexes" = yes; then + db_cv_mutex=ui_only; + fi + + # POSIX.1 pthreads: pthread_XXX + # + # If the user specified we use POSIX pthreads mutexes, and we fail to + # find the full interface, try and configure for just intra-process + # support. + if test "$db_cv_mutex" = no -o "$db_cv_mutex" = posix_only; then + LIBS="$LIBS -lpthread" + AM_PTHREADS_SHARED(POSIX/pthreads/library) + LIBS="$orig_libs" + fi + if test "$db_cv_mutex" = no -o "$db_cv_mutex" = posix_only; then + AM_PTHREADS_SHARED(POSIX/pthreads) + fi + if test "$db_cv_mutex" = posix_only; then + AM_PTHREADS_PRIVATE(POSIX/pthreads/private) + fi + if test "$db_cv_mutex" = posix_only; then + LIBS="$LIBS -lpthread" + AM_PTHREADS_PRIVATE(POSIX/pthreads/library/private) + LIBS="$orig_libs" + fi + if test "$db_cv_mutex" = posix_only; then + AC_MSG_ERROR([unable to find POSIX 1003.1 mutex interfaces]) + fi + + # LWP threads: _lwp_XXX + if test "$db_cv_mutex" = no; then + AC_TRY_LINK([ + #include ],[ + static lwp_mutex_t mi = SHAREDMUTEX; + static lwp_cond_t ci = SHAREDCV; + lwp_mutex_t mutex = mi; + lwp_cond_t cond = ci; + exit ( + _lwp_mutex_lock(&mutex) || + _lwp_mutex_unlock(&mutex)); + ], [db_cv_mutex=Solaris/lwp]) + fi + + # UI threads: thr_XXX + if test "$db_cv_mutex" = no -o "$db_cv_mutex" = ui_only; then + LIBS="$LIBS -lthread" + AC_TRY_LINK([ + #include + #include ],[ + mutex_t mutex; + cond_t cond; + int type = USYNC_PROCESS; + exit ( + mutex_init(&mutex, type, NULL) || + cond_init(&cond, type, NULL) || + mutex_lock(&mutex) || + mutex_unlock(&mutex)); + ], [db_cv_mutex=UI/threads/library]) + LIBS="$orig_libs" + fi + if test "$db_cv_mutex" = no -o "$db_cv_mutex" = ui_only; then + AC_TRY_LINK([ + #include + #include ],[ + mutex_t mutex; + cond_t cond; + int type = USYNC_PROCESS; + exit ( + mutex_init(&mutex, type, NULL) || + cond_init(&cond, type, NULL) || + mutex_lock(&mutex) || + mutex_unlock(&mutex)); + ], [db_cv_mutex=UI/threads]) + fi + if test "$db_cv_mutex" = ui_only; then + AC_MSG_ERROR([unable to find UI mutex interfaces]) + fi + + # We're done testing for pthreads-style mutexes. Next, check for + # test-and-set mutexes. Check first for hybrid implementations, + # because we check for them even if we've already found a + # pthreads-style mutex and they're the most common architectures + # anyway. + # + # x86/gcc: FreeBSD, NetBSD, BSD/OS, Linux + AC_TRY_COMPILE(,[ + #if (defined(i386) || defined(__i386__)) && defined(__GNUC__) + exit(0); + #else + FAIL TO COMPILE/LINK + #endif + ], [db_cv_mutex="$db_cv_mutex/x86/gcc-assembly"]) + + # x86_64/gcc: FreeBSD, NetBSD, BSD/OS, Linux + AC_TRY_COMPILE(,[ + #if (defined(x86_64) || defined(__x86_64__)) && defined(__GNUC__) + exit(0); + #else + FAIL TO COMPILE/LINK + #endif + ], [db_cv_mutex="$db_cv_mutex/x86_64/gcc-assembly"]) + + # Solaris is one of the systems where we can configure hybrid mutexes. + # However, we require the membar_enter function for that, and only newer + # Solaris releases have it. Check to see if we can configure hybrids. + AC_TRY_LINK([ + #include + #include ],[ + typedef lock_t tsl_t; + lock_t x; + _lock_try(&x); + _lock_clear(&x); + membar_enter(); + ], [db_cv_mutex="$db_cv_mutex/Solaris/_lock_try/membar"]) + + # Sparc/gcc: SunOS, Solaris, ultrasparc assembler support + AC_TRY_COMPILE(,[ + #if defined(__sparc__) && defined(__GNUC__) + asm volatile ("membar #StoreStore|#StoreLoad|#LoadStore"); + exit(0); + #else + FAIL TO COMPILE/LINK + #endif + ], [db_cv_mutex="$db_cv_mutex/Sparc/gcc-assembly"]) + + # We're done testing for any hybrid mutex implementations. If we did + # not find a pthreads-style mutex, but did find a test-and-set mutex, + # we set db_cv_mutex to "no/XXX" -- clean that up. + db_cv_mutex=`echo $db_cv_mutex | sed 's/^no\///'` +fi + +# If we still don't have a mutex implementation yet, continue testing for a +# test-and-set mutex implementation. + +# _lock_try/_lock_clear: Solaris +# On Solaris systems without other mutex interfaces, DB uses the undocumented +# _lock_try _lock_clear function calls instead of either the sema_trywait(3T) +# or sema_wait(3T) function calls. This is because of problems in those +# interfaces in some releases of the Solaris C library. +if test "$db_cv_mutex" = no; then +AC_TRY_LINK([ +#include +#include ],[ + typedef lock_t tsl_t; + lock_t x; + _lock_try(&x); + _lock_clear(&x); +], [db_cv_mutex=Solaris/_lock_try]) +fi + +# msemaphore: HPPA only +# Try HPPA before general msem test, it needs special alignment. +if test "$db_cv_mutex" = no; then +AC_TRY_LINK([ +#include ],[ +#if defined(__hppa) + typedef msemaphore tsl_t; + msemaphore x; + msem_init(&x, 0); + msem_lock(&x, 0); + msem_unlock(&x, 0); + exit(0); +#else + FAIL TO COMPILE/LINK +#endif +], [db_cv_mutex=HP/msem_init]) +fi + +# msemaphore: AIX, OSF/1 +if test "$db_cv_mutex" = no; then +AC_TRY_LINK([ +#include +#include ],[ + typedef msemaphore tsl_t; + msemaphore x; + msem_init(&x, 0); + msem_lock(&x, 0); + msem_unlock(&x, 0); + exit(0); +], [db_cv_mutex=UNIX/msem_init]) +fi + +# ReliantUNIX +if test "$db_cv_mutex" = no; then +LIBS="$LIBS -lmproc" +AC_TRY_LINK([ +#include ],[ + typedef spinlock_t tsl_t; + spinlock_t x; + initspin(&x, 1); + cspinlock(&x); + spinunlock(&x); +], [db_cv_mutex=ReliantUNIX/initspin]) +LIBS="$orig_libs" +fi + +# SCO: UnixWare has threads in libthread, but OpenServer doesn't. +if test "$db_cv_mutex" = no; then +AC_TRY_COMPILE(,[ +#if defined(__USLC__) + exit(0); +#else + FAIL TO COMPILE/LINK +#endif +], [db_cv_mutex=SCO/x86/cc-assembly]) +fi + +# abilock_t: SGI +if test "$db_cv_mutex" = no; then +AC_TRY_LINK([ +#include ],[ + typedef abilock_t tsl_t; + abilock_t x; + init_lock(&x); + acquire_lock(&x); + release_lock(&x); +], [db_cv_mutex=SGI/init_lock]) +fi + +# sema_t: Solaris +# The sema_XXX calls do not work on Solaris 5.5. I see no reason to ever +# turn this test on, unless we find some other platform that uses the old +# POSIX.1 interfaces. +if test "$db_cv_mutex" = DOESNT_WORK; then +AC_TRY_LINK([ +#include ],[ + typedef sema_t tsl_t; + sema_t x; + sema_init(&x, 1, USYNC_PROCESS, NULL); + sema_wait(&x); + sema_post(&x); +], [db_cv_mutex=UNIX/sema_init]) +fi + +# _check_lock/_clear_lock: AIX +if test "$db_cv_mutex" = no; then +AC_TRY_LINK([ +#include ],[ + int x; + _check_lock(&x,0,1); + _clear_lock(&x,0); +], [db_cv_mutex=AIX/_check_lock]) +fi + +# _spin_lock_try/_spin_unlock: Apple/Darwin +if test "$db_cv_mutex" = no; then +AC_TRY_LINK(,[ + int x; + _spin_lock_try(&x); + _spin_unlock(&x); +], [db_cv_mutex=Darwin/_spin_lock_try]) +fi + +# Tru64/cc +if test "$db_cv_mutex" = no; then +AC_TRY_COMPILE(,[ +#if defined(__alpha) && defined(__DECC) + exit(0); +#else + FAIL TO COMPILE/LINK +#endif +], [db_cv_mutex=Tru64/cc-assembly]) +fi + +# Alpha/gcc +if test "$db_cv_mutex" = no; then +AC_TRY_COMPILE(,[ +#if defined(__alpha) && defined(__GNUC__) + exit(0); +#else + FAIL TO COMPILE/LINK +#endif +], [db_cv_mutex=ALPHA/gcc-assembly]) +fi + +# ARM/gcc: Linux +if test "$db_cv_mutex" = no; then +AC_TRY_COMPILE(,[ +#if defined(__arm__) && defined(__GNUC__) + exit(0); +#else + FAIL TO COMPILE/LINK +#endif +], [db_cv_mutex=ARM/gcc-assembly]) +fi + +# MIPS/gcc: Linux +if test "$db_cv_mutex" = no; then +AC_TRY_COMPILE(,[ +#if (defined(__mips) || defined(__mips__)) && defined(__GNUC__) + exit(0); +#else + FAIL TO COMPILE/LINK +#endif +], [db_cv_mutex=MIPS/gcc-assembly]) +fi + +# PaRisc/gcc: HP/UX +if test "$db_cv_mutex" = no; then +AC_TRY_COMPILE(,[ +#if (defined(__hppa) || defined(__hppa__)) && defined(__GNUC__) + exit(0); +#else + FAIL TO COMPILE/LINK +#endif +], [db_cv_mutex=HPPA/gcc-assembly]) +fi + +# PPC/gcc: +if test "$db_cv_mutex" = no; then +AC_TRY_COMPILE(,[ +#if (defined(__powerpc__) || defined(__ppc__)) && defined(__GNUC__) + exit(0); +#else + FAIL TO COMPILE/LINK +#endif +], [db_cv_mutex=PPC/gcc-assembly]) +fi + +# 68K/gcc: SunOS +if test "$db_cv_mutex" = no; then +AC_TRY_COMPILE(,[ +#if (defined(mc68020) || defined(sun3)) && defined(__GNUC__) + exit(0); +#else + FAIL TO COMPILE/LINK +#endif +], [db_cv_mutex=68K/gcc-assembly]) +fi + +# S390/cc: IBM OS/390 Unix +if test "$db_cv_mutex" = no; then +AC_TRY_COMPILE(,[ +#if defined(__MVS__) && defined(__IBMC__) + exit(0); +#else + FAIL TO COMPILE/LINK +#endif +], [db_cv_mutex=S390/cc-assembly]) +fi + +# S390/gcc: Linux +if test "$db_cv_mutex" = no; then +AC_TRY_COMPILE(,[ +#if defined(__s390__) && defined(__GNUC__) + exit(0); +#else + FAIL TO COMPILE/LINK +#endif +], [db_cv_mutex=S390/gcc-assembly]) +fi + +# ia64/gcc: Linux +if test "$db_cv_mutex" = no; then +AC_TRY_COMPILE(,[ +#if defined(__ia64) && defined(__GNUC__) + exit(0); +#else + FAIL TO COMPILE/LINK +#endif +], [db_cv_mutex=ia64/gcc-assembly]) +fi + +# uts/cc: UTS +if test "$db_cv_mutex" = no; then +AC_TRY_COMPILE(,[ +#if defined(_UTS) + exit(0); +#else + FAIL TO COMPILE/LINK +#endif +], [db_cv_mutex=UTS/cc-assembly]) +fi + +# UNIX fcntl system call mutexes. +# Note that fcntl mutexes are no longer supported in 4.8. This code has been +# left in place in case there is some system that we are not aware of that uses +# fcntl mutexes, in which case additional work will be required for DB 4.8 in +# order to support shared latches. +if test "$db_cv_mutex" = no; then + db_cv_mutex=UNIX/fcntl +AC_TRY_LINK([ +#include ],[ + struct flock l; + l.l_whence = SEEK_SET; + l.l_start = 10; + l.l_len = 1; + l.l_type = F_WRLCK; + fcntl(0, F_SETLK, &l); +], [db_cv_mutex=UNIX/fcntl]) +fi +]) + +# Configure a pthreads-style mutex implementation. +hybrid=pthread +case "$db_cv_mutex" in +POSIX/pthreads*) ADDITIONAL_OBJS="mut_pthread${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_PTHREADS) + AH_TEMPLATE(HAVE_MUTEX_PTHREADS, + [Define to 1 to use POSIX 1003.1 pthread_XXX mutexes.]);; +POSIX/pthreads/private*)ADDITIONAL_OBJS="mut_pthread${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_PTHREADS) + AC_DEFINE(HAVE_MUTEX_THREAD_ONLY) + AH_TEMPLATE(HAVE_MUTEX_THREAD_ONLY, + [Define to 1 to configure mutexes intra-process only.]);; +POSIX/pthreads/library*)ADDITIONAL_OBJS="mut_pthread${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_PTHREADS);; +POSIX/pthreads/library/private*) + ADDITIONAL_OBJS="mut_pthread${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_PTHREADS) + AC_DEFINE(HAVE_MUTEX_THREAD_ONLY);; +Solaris/lwp*) ADDITIONAL_OBJS="mut_pthread${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_SOLARIS_LWP) + AH_TEMPLATE(HAVE_MUTEX_SOLARIS_LWP, + [Define to 1 to use the Solaris lwp threads mutexes.]);; +UI/threads*) ADDITIONAL_OBJS="mut_pthread${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_UI_THREADS) + AH_TEMPLATE(HAVE_MUTEX_UI_THREADS, + [Define to 1 to use the UNIX International mutexes.]);; +UI/threads/library*) ADDITIONAL_OBJS="mut_pthread${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_UI_THREADS);; +*) hybrid=no;; +esac + +# Configure a test-and-set mutex implementation. +case "$db_cv_mutex" in +68K/gcc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_68K_GCC_ASSEMBLY) + AH_TEMPLATE(HAVE_MUTEX_68K_GCC_ASSEMBLY, + [Define to 1 to use the GCC compiler and 68K assembly language mutexes.]);; +AIX/_check_lock) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_AIX_CHECK_LOCK) + AH_TEMPLATE(HAVE_MUTEX_AIX_CHECK_LOCK, + [Define to 1 to use the AIX _check_lock mutexes.]);; +Darwin/_spin_lock_try) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_DARWIN_SPIN_LOCK_TRY) + AH_TEMPLATE(HAVE_MUTEX_DARWIN_SPIN_LOCK_TRY, + [Define to 1 to use the Apple/Darwin _spin_lock_try mutexes.]);; +ALPHA/gcc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_ALPHA_GCC_ASSEMBLY) + AH_TEMPLATE(HAVE_MUTEX_ALPHA_GCC_ASSEMBLY, + [Define to 1 to use the GCC compiler and Alpha assembly language mutexes.]);; +ARM/gcc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_ARM_GCC_ASSEMBLY) + AH_TEMPLATE(HAVE_MUTEX_ARM_GCC_ASSEMBLY, + [Define to 1 to use the GCC compiler and ARM assembly language mutexes.]);; +HP/msem_init) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_HPPA_MSEM_INIT) + AH_TEMPLATE(HAVE_MUTEX_HPPA_MSEM_INIT, + [Define to 1 to use the msem_XXX mutexes on HP-UX.]);; +HPPA/gcc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_HPPA_GCC_ASSEMBLY) + AH_TEMPLATE(HAVE_MUTEX_HPPA_GCC_ASSEMBLY, + [Define to 1 to use the GCC compiler and PaRisc assembly language mutexes.]);; +ia64/gcc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_IA64_GCC_ASSEMBLY) + AH_TEMPLATE(HAVE_MUTEX_IA64_GCC_ASSEMBLY, + [Define to 1 to use the GCC compiler and IA64 assembly language mutexes.]);; +MIPS/gcc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_MIPS_GCC_ASSEMBLY) + AH_TEMPLATE(HAVE_MUTEX_MIPS_GCC_ASSEMBLY, + [Define to 1 to use the GCC compiler and MIPS assembly language mutexes.]);; +PPC/gcc-assembly) + ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_PPC_GCC_ASSEMBLY) + AH_TEMPLATE(HAVE_MUTEX_PPC_GCC_ASSEMBLY, + [Define to 1 to use the GCC compiler and PowerPC assembly language mutexes.]);; +ReliantUNIX/initspin) LIBSO_LIBS="$LIBSO_LIBS -lmproc" + ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_RELIANTUNIX_INITSPIN) + AH_TEMPLATE(HAVE_MUTEX_RELIANTUNIX_INITSPIN, + [Define to 1 to use Reliant UNIX initspin mutexes.]);; +S390/cc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_S390_CC_ASSEMBLY) + AH_TEMPLATE(HAVE_MUTEX_S390_CC_ASSEMBLY, + [Define to 1 to use the IBM C compiler and S/390 assembly language mutexes.]);; +S390/gcc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_S390_GCC_ASSEMBLY) + AH_TEMPLATE(HAVE_MUTEX_S390_GCC_ASSEMBLY, + [Define to 1 to use the GCC compiler and S/390 assembly language mutexes.]);; +SCO/x86/cc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_SCO_X86_CC_ASSEMBLY) + AH_TEMPLATE(HAVE_MUTEX_SCO_X86_CC_ASSEMBLY, + [Define to 1 to use the SCO compiler and x86 assembly language mutexes.]);; +SGI/init_lock) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_SGI_INIT_LOCK) + AH_TEMPLATE(HAVE_MUTEX_SGI_INIT_LOCK, + [Define to 1 to use the SGI XXX_lock mutexes.]);; +Solaris/_lock_try) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_SOLARIS_LOCK_TRY) + AH_TEMPLATE(HAVE_MUTEX_SOLARIS_LOCK_TRY, + [Define to 1 to use the Solaris _lock_XXX mutexes.]);; +*Solaris/_lock_try/membar) + hybrid="$hybrid/tas" + ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_SOLARIS_LOCK_TRY) + AH_TEMPLATE(HAVE_MUTEX_SOLARIS_LOCK_TRY, + [Define to 1 to use the Solaris _lock_XXX mutexes.]);; +*Sparc/gcc-assembly) hybrid="$hybrid/tas" + ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_SPARC_GCC_ASSEMBLY) + AH_TEMPLATE(HAVE_MUTEX_SPARC_GCC_ASSEMBLY, + [Define to 1 to use the GCC compiler and Sparc assembly language mutexes.]);; +Tru64/cc-assembly) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_TRU64_CC_ASSEMBLY) + AH_TEMPLATE(HAVE_MUTEX_TRU64_CC_ASSEMBLY, + [Define to 1 to use the CC compiler and Tru64 assembly language mutexes.]);; +UNIX/msem_init) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_MSEM_INIT) + AH_TEMPLATE(HAVE_MUTEX_MSEM_INIT, + [Define to 1 to use the msem_XXX mutexes on systems other than HP-UX.]);; +UNIX/sema_init) ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_SEMA_INIT) + AH_TEMPLATE(HAVE_MUTEX_SEMA_INIT, + [Define to 1 to use the obsolete POSIX 1003.1 sema_XXX mutexes.]);; +UTS/cc-assembly) ADDITIONAL_OBJS="uts4.cc${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_UTS_CC_ASSEMBLY) + AH_TEMPLATE(HAVE_MUTEX_UTS_CC_ASSEMBLY, + [Define to 1 to use the UTS compiler and assembly language mutexes.]);; +*x86/gcc-assembly) hybrid="$hybrid/tas" + ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_X86_GCC_ASSEMBLY) + AH_TEMPLATE(HAVE_MUTEX_X86_GCC_ASSEMBLY, + [Define to 1 to use the GCC compiler and 32-bit x86 assembly language mutexes.]);; +*x86_64/gcc-assembly) hybrid="$hybrid/tas" + ADDITIONAL_OBJS="mut_tas${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_X86_64_GCC_ASSEMBLY) + AH_TEMPLATE(HAVE_MUTEX_X86_64_GCC_ASSEMBLY, + [Define to 1 to use the GCC compiler and 64-bit x86 assembly language mutexes.]);; +esac + +# Configure the remaining special cases. +case "$db_cv_mutex" in +UNIX/fcntl) AC_MSG_WARN( + [NO SHARED LATCH IMPLEMENTATION FOUND FOR THIS PLATFORM.]) + ADDITIONAL_OBJS="mut_fcntl${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_FCNTL) + AH_TEMPLATE(HAVE_MUTEX_FCNTL, + [Define to 1 to use the UNIX fcntl system call mutexes.]);; +win32) ADDITIONAL_OBJS="mut_win32${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_WIN32) + AH_TEMPLATE(HAVE_MUTEX_WIN32, [Define to 1 to use the MSVC compiler and Windows mutexes.]);; +win32/gcc) ADDITIONAL_OBJS="mut_win32${o} $ADDITIONAL_OBJS" + AC_DEFINE(HAVE_MUTEX_WIN32_GCC) + AH_TEMPLATE(HAVE_MUTEX_WIN32_GCC, [Define to 1 to use the GCC compiler and Windows mutexes.]);; +esac + +# Mutexes may not have been found, or may have been disabled. +case "$db_cv_mutex" in +disabled) + ;; +*) + # Test to see if mutexes have been found by checking the list of + # additional objects for a mutex implementation. + case "$ADDITIONAL_OBJS" in + *mut_pthread*|*mut_tas*|*mut_win32*) + AC_DEFINE(HAVE_MUTEX_SUPPORT) + AH_TEMPLATE(HAVE_MUTEX_SUPPORT, + [Define to 1 if the Berkeley DB library should support mutexes.]) + + # Shared latches are required in 4.8, and are implemented using + # mutexes if we don't have a native implementation. + # This macro may be removed in a future release. + AH_TEMPLATE(HAVE_SHARED_LATCHES, + [Define to 1 to configure Berkeley DB to use read/write latches.]) + AC_DEFINE(HAVE_SHARED_LATCHES);; + *) + AC_MSG_ERROR([Unable to find a mutex implementation]);; + esac +esac + +# We may have found both a pthreads-style mutex implementation as well as a +# test-and-set, in which case configure for the hybrid. +if test "$hybrid" = pthread/tas; then + AC_DEFINE(HAVE_MUTEX_HYBRID) + AH_TEMPLATE(HAVE_MUTEX_HYBRID, + [Define to 1 to use test-and-set mutexes with blocking mutexes.]) +fi + +# The mutex selection may require specific declarations -- we fill in most of +# them above, but here are the common ones. +# +# The mutex selection may tell us what kind of thread package we're using, +# which we use to figure out the thread type. +# +# If we're configured for the POSIX pthread API, then force the thread ID type +# and include function, regardless of the mutex selection. Ditto for the +# (default) Solaris lwp mutexes, because they don't have a way to return the +# thread ID. +# +# Try and link with a threads library if possible. The problem is the Solaris +# C library has UI/POSIX interface stubs, but they're broken, configuring them +# for inter-process mutexes doesn't return an error, but it doesn't work either. +# For that reason always add -lpthread if we're using pthread calls or mutexes +# and there's a pthread library. +# +# We can't depend on any specific call existing (pthread_create, for example), +# as it may be #defined in an include file -- OSF/1 (Tru64) has this problem. + +AC_SUBST(thread_h_decl) +AC_SUBST(db_threadid_t_decl) +db_threadid_t_decl=notset + +case "$db_cv_mutex" in +UI/threads*) + thread_h_decl="#include " + db_threadid_t_decl="typedef thread_t db_threadid_t;" + AC_HAVE_LIBRARY(thread, LIBSO_LIBS="$LIBSO_LIBS -lthread");; +*) + AC_CHECK_HEADER(pthread.h, [ac_cv_header_pthread_h=yes]) + if test "$ac_cv_header_pthread_h" = "yes" ; then + thread_h_decl="#include " + db_threadid_t_decl="typedef pthread_t db_threadid_t;" + fi + AC_HAVE_LIBRARY(pthread, LIBSO_LIBS="$LIBSO_LIBS -lpthread");; +esac + +# We need to know if the thread ID type will fit into an integral type and we +# can compare it for equality and generally treat it like an int, or if it's a +# non-integral type and we have to treat it like a structure or other untyped +# block of bytes. For example, MVS typedef's pthread_t to a structure. +AH_TEMPLATE(HAVE_SIMPLE_THREAD_TYPE, + [Define to 1 if thread identifier type db_threadid_t is integral.]) +if test "$db_threadid_t_decl" = notset; then + db_threadid_t_decl="typedef uintmax_t db_threadid_t;" + AC_DEFINE(HAVE_SIMPLE_THREAD_TYPE) +else + AC_TRY_COMPILE( + #include + $thread_h_decl, [ + $db_threadid_t_decl + db_threadid_t a; + a = 0; + ], AC_DEFINE(HAVE_SIMPLE_THREAD_TYPE)) +fi + +# There are 3 classes of mutexes: +# +# 1: Mutexes requiring no cleanup, for example, test-and-set mutexes. +# 2: Mutexes that must be destroyed, but which don't hold permanent system +# resources, for example, pthread mutexes on MVS aka OS/390 aka z/OS. +# 3: Mutexes that must be destroyed, even after the process is gone, for +# example, pthread mutexes on QNX and binary semaphores on VxWorks. +# +# DB cannot currently distinguish between #2 and #3 because DB does not know +# if the application is running environment recovery as part of startup and +# does not need to do cleanup, or if the environment is being removed and/or +# recovered in a loop in the application, and so does need to clean up. If +# we get it wrong, we're going to call the mutex destroy routine on a random +# piece of memory, which usually works, but just might drop core. For now, +# we group #2 and #3 into the HAVE_MUTEX_SYSTEM_RESOURCES define, until we +# have a better solution or reason to solve this in a general way -- so far, +# the places we've needed to handle this are few. +AH_TEMPLATE(HAVE_MUTEX_SYSTEM_RESOURCES, + [Define to 1 if mutexes hold system resources.]) + +case "$host_os$db_cv_mutex" in +*qnx*POSIX/pthread*|openedition*POSIX/pthread*) + AC_DEFINE(HAVE_MUTEX_SYSTEM_RESOURCES);; +esac]) + +AC_DEFUN(AM_DEFINE_ATOMIC, [ +# Probe for native atomic operations +# gcc/x86{,_64} inline asm +# solaris atomic_* library calls + +AH_TEMPLATE(HAVE_ATOMIC_SUPPORT, + [Define to 1 to use native atomic operations.]) +AH_TEMPLATE(HAVE_ATOMIC_X86_GCC_ASSEMBLY, + [Define to 1 to use GCC and x86 or x86_64 assemlby language atomic operations.]) +AH_TEMPLATE(HAVE_ATOMIC_SOLARIS, + [Define to 1 to use Solaris library routes for atomic operations.]) + +AC_CACHE_CHECK([for atomic operations], db_cv_atomic, [ +db_cv_atomic=no +# atomic operations can be disabled via --disable-atomicsupport +if test "$db_cv_build_atomicsupport" = no; then + db_cv_atomic=disabled +fi + +# The MinGW build uses the Windows API for atomic operations +if test "$db_cv_mingw" = yes; then + db_cv_atomic=mingw +fi + +if test "$db_cv_atomic" = no; then + AC_TRY_COMPILE(,[ + #if ((defined(i386) || defined(__i386__)) && defined(__GNUC__)) + exit(0); + #elif ((defined(x86_64) || defined(__x86_64__)) && defined(__GNUC__)) + exit(0); + #else + FAIL TO COMPILE/LINK + #endif + ], [db_cv_atomic="x86/gcc-assembly"]) +fi + +if test "$db_cv_atomic" = no; then +AC_TRY_LINK([ +#include ],[ + volatile unsigned val = 1; + exit (atomic_inc_uint_nv(&val) != 2 || + atomic_dec_uint_nv(&val) != 1 || + atomic_cas_32(&val, 1, 3) != 3); +], [db_cv_atomic="solaris/atomic"]) +fi +]) + +case "$db_cv_atomic" in + x86/gcc-assembly) + AC_DEFINE(HAVE_ATOMIC_SUPPORT) + AC_DEFINE(HAVE_ATOMIC_X86_GCC_ASSEMBLY) + ;; + + solaris/atomic) + AC_DEFINE(HAVE_ATOMIC_SUPPORT) + AC_DEFINE(HAVE_ATOMIC_SOLARIS) + ;; + mingw) + AC_DEFINE(HAVE_ATOMIC_SUPPORT) + ;; +esac +]) -- cgit v1.2.3