1# lock.m4 serial 2 (gettext-0.15) 2dnl Copyright (C) 2005 Free Software Foundation, Inc. 3dnl This file is free software; the Free Software Foundation 4dnl gives unlimited permission to copy and/or distribute it, 5dnl with or without modifications, as long as this notice is preserved. 6 7dnl From Bruno Haible. 8 9dnl Tests for a multithreading library to be used. 10dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS, 11dnl USE_PTH_THREADS, USE_WIN32_THREADS 12dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use 13dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with 14dnl libtool). 15dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for 16dnl programs that really need multithread functionality. The difference 17dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak 18dnl symbols, typically LIBTHREAD="" whereas LIBMULTITHREAD="-lpthread". 19dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for 20dnl multithread-safe programs. 21 22AC_DEFUN([gl_LOCK], 23[ 24 AC_REQUIRE([gl_LOCK_BODY]) 25]) 26 27dnl The guts of gl_LOCK. Needs to be expanded only once. 28 29AC_DEFUN([gl_LOCK_BODY], 30[ 31 dnl Ordering constraints: This macro modifies CPPFLAGS in a way that 32 dnl influences the result of the autoconf tests that test for *_unlocked 33 dnl declarations, on AIX 5 at least. Therefore it must come early. 34 AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl 35 AC_BEFORE([$0], [gl_ARGP])dnl 36 37 AC_REQUIRE([AC_CANONICAL_HOST]) 38 AC_REQUIRE([AC_GNU_SOURCE]) dnl needed for pthread_rwlock_t on glibc systems 39 dnl Check for multithreading. 40 AC_ARG_ENABLE(threads, 41AC_HELP_STRING([--enable-threads={posix|solaris|pth|win32}], [specify multithreading API]) 42AC_HELP_STRING([--disable-threads], [build without multithread safety]), 43 gl_use_threads=$enableval, gl_use_threads=yes) 44 gl_threads_api=none 45 LIBTHREAD= 46 LTLIBTHREAD= 47 LIBMULTITHREAD= 48 LTLIBMULTITHREAD= 49 if test "$gl_use_threads" != no; then 50 dnl Check whether the compiler and linker support weak declarations. 51 AC_MSG_CHECKING([whether imported symbols can be declared weak]) 52 gl_have_weak=no 53 AC_TRY_LINK([extern void xyzzy (); 54#pragma weak xyzzy], [xyzzy();], [gl_have_weak=yes]) 55 AC_MSG_RESULT([$gl_have_weak]) 56 if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then 57 # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that 58 # it groks <pthread.h>. 59 gl_save_CPPFLAGS="$CPPFLAGS" 60 CPPFLAGS="$CPPFLAGS -D_REENTRANT" 61 AC_CHECK_HEADER(pthread.h, gl_have_pthread_h=yes, gl_have_pthread_h=no) 62 CPPFLAGS="$gl_save_CPPFLAGS" 63 if test "$gl_have_pthread_h" = yes; then 64 # Other possible tests: 65 # -lpthreads (FSU threads, PCthreads) 66 # -lgthreads 67 case "$host_os" in 68 osf*) 69 # On OSF/1, the compiler needs the flag -D_REENTRANT so that it 70 # groks <pthread.h>. cc also understands the flag -pthread, but 71 # we don't use it because 1. gcc-2.95 doesn't understand -pthread, 72 # 2. putting a flag into CPPFLAGS that has an effect on the linker 73 # causes the AC_TRY_LINK test below to succeed unexpectedly, 74 # leading to wrong values of LIBTHREAD and LTLIBTHREAD. 75 CPPFLAGS="$CPPFLAGS -D_REENTRANT" 76 ;; 77 esac 78 gl_have_pthread= 79 # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist 80 # in libc. IRIX 6.5 has the first one in both libc and libpthread, but 81 # the second one only in libpthread, and lock.c needs it. 82 AC_TRY_LINK([#include <pthread.h>], 83 [pthread_mutex_lock((pthread_mutex_t*)0); 84 pthread_mutexattr_init((pthread_mutexattr_t*)0);], 85 [gl_have_pthread=yes]) 86 # Test for libpthread by looking for pthread_kill. (Not pthread_self, 87 # since it is defined as a macro on OSF/1.) 88 if test -n "$gl_have_pthread"; then 89 # The program links fine without libpthread. But it may actually 90 # need to link with libpthread in order to create multiple threads. 91 AC_CHECK_LIB(pthread, pthread_kill, 92 [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread 93 # On Solaris and HP-UX, most pthread functions exist also in libc. 94 # Therefore pthread_in_use() needs to actually try to create a 95 # thread: pthread_create from libc will fail, whereas 96 # pthread_create will actually create a thread. 97 case "$host_os" in 98 solaris* | hpux*) 99 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], 1, 100 [Define if the pthread_in_use() detection is hard.]) 101 esac 102 ]) 103 else 104 # Some library is needed. Try libpthread and libc_r. 105 AC_CHECK_LIB(pthread, pthread_kill, 106 [gl_have_pthread=yes 107 LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread 108 LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread]) 109 if test -z "$gl_have_pthread"; then 110 # For FreeBSD 4. 111 AC_CHECK_LIB(c_r, pthread_kill, 112 [gl_have_pthread=yes 113 LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r 114 LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r]) 115 fi 116 fi 117 if test -n "$gl_have_pthread"; then 118 gl_threads_api=posix 119 AC_DEFINE([USE_POSIX_THREADS], 1, 120 [Define if the POSIX multithreading library can be used.]) 121 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then 122 if test $gl_have_weak = yes; then 123 AC_DEFINE([USE_POSIX_THREADS_WEAK], 1, 124 [Define if references to the POSIX multithreading library should be made weak.]) 125 LIBTHREAD= 126 LTLIBTHREAD= 127 fi 128 fi 129 # OSF/1 4.0 and MacOS X 10.1 lack the pthread_rwlock_t type and the 130 # pthread_rwlock_* functions. 131 AC_CHECK_TYPE([pthread_rwlock_t], 132 [AC_DEFINE([HAVE_PTHREAD_RWLOCK], 1, 133 [Define if the POSIX multithreading library has read/write locks.])], 134 [], 135 [#include <pthread.h>]) 136 # glibc defines PTHREAD_MUTEX_RECURSIVE as enum, not as a macro. 137 AC_TRY_COMPILE([#include <pthread.h>], 138 [#if __FreeBSD__ == 4 139error "No, in FreeBSD 4.0 recursive mutexes actually don't work." 140#else 141int x = (int)PTHREAD_MUTEX_RECURSIVE; 142#endif], 143 [AC_DEFINE([HAVE_PTHREAD_MUTEX_RECURSIVE], 1, 144 [Define if the <pthread.h> defines PTHREAD_MUTEX_RECURSIVE.])]) 145 # Some systems optimize for single-threaded programs by default, and 146 # need special flags to disable these optimizations. For example, the 147 # definition of 'errno' in <errno.h>. 148 case "$host_os" in 149 aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;; 150 solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;; 151 esac 152 fi 153 fi 154 fi 155 if test -z "$gl_have_pthread"; then 156 if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then 157 gl_have_solaristhread= 158 gl_save_LIBS="$LIBS" 159 LIBS="$LIBS -lthread" 160 AC_TRY_LINK([#include <thread.h> 161#include <synch.h>], 162 [thr_self();], 163 [gl_have_solaristhread=yes]) 164 LIBS="$gl_save_LIBS" 165 if test -n "$gl_have_solaristhread"; then 166 gl_threads_api=solaris 167 LIBTHREAD=-lthread 168 LTLIBTHREAD=-lthread 169 LIBMULTITHREAD="$LIBTHREAD" 170 LTLIBMULTITHREAD="$LTLIBTHREAD" 171 AC_DEFINE([USE_SOLARIS_THREADS], 1, 172 [Define if the old Solaris multithreading library can be used.]) 173 if test $gl_have_weak = yes; then 174 AC_DEFINE([USE_SOLARIS_THREADS_WEAK], 1, 175 [Define if references to the old Solaris multithreading library should be made weak.]) 176 LIBTHREAD= 177 LTLIBTHREAD= 178 fi 179 fi 180 fi 181 fi 182 if test "$gl_use_threads" = pth; then 183 gl_save_CPPFLAGS="$CPPFLAGS" 184 AC_LIB_LINKFLAGS(pth) 185 gl_have_pth= 186 gl_save_LIBS="$LIBS" 187 LIBS="$LIBS -lpth" 188 AC_TRY_LINK([#include <pth.h>], [pth_self();], gl_have_pth=yes) 189 LIBS="$gl_save_LIBS" 190 if test -n "$gl_have_pth"; then 191 gl_threads_api=pth 192 LIBTHREAD="$LIBPTH" 193 LTLIBTHREAD="$LTLIBPTH" 194 LIBMULTITHREAD="$LIBTHREAD" 195 LTLIBMULTITHREAD="$LTLIBTHREAD" 196 AC_DEFINE([USE_PTH_THREADS], 1, 197 [Define if the GNU Pth multithreading library can be used.]) 198 if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then 199 if test $gl_have_weak = yes; then 200 AC_DEFINE([USE_PTH_THREADS_WEAK], 1, 201 [Define if references to the GNU Pth multithreading library should be made weak.]) 202 LIBTHREAD= 203 LTLIBTHREAD= 204 fi 205 fi 206 else 207 CPPFLAGS="$gl_save_CPPFLAGS" 208 fi 209 fi 210 if test -z "$gl_have_pthread"; then 211 if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then 212 if { case "$host_os" in 213 mingw*) true;; 214 *) false;; 215 esac 216 }; then 217 gl_threads_api=win32 218 AC_DEFINE([USE_WIN32_THREADS], 1, 219 [Define if the Win32 multithreading API can be used.]) 220 fi 221 fi 222 fi 223 fi 224 AC_MSG_CHECKING([for multithread API to use]) 225 AC_MSG_RESULT([$gl_threads_api]) 226 AC_SUBST(LIBTHREAD) 227 AC_SUBST(LTLIBTHREAD) 228 AC_SUBST(LIBMULTITHREAD) 229 AC_SUBST(LTLIBMULTITHREAD) 230 gl_PREREQ_LOCK 231]) 232 233# Prerequisites of lib/lock.c. 234AC_DEFUN([gl_PREREQ_LOCK], [ 235 AC_REQUIRE([AC_C_INLINE]) 236]) 237 238dnl Survey of platforms: 239dnl 240dnl Platform Available Compiler Supports test-lock 241dnl flavours option weak result 242dnl --------------- --------- --------- -------- --------- 243dnl Linux 2.4/glibc posix -lpthread Y OK 244dnl 245dnl GNU Hurd/glibc posix 246dnl 247dnl FreeBSD 5.3 posix -lc_r Y 248dnl posix -lkse ? Y 249dnl posix -lpthread ? Y 250dnl posix -lthr Y 251dnl 252dnl FreeBSD 5.2 posix -lc_r Y 253dnl posix -lkse Y 254dnl posix -lthr Y 255dnl 256dnl FreeBSD 4.0,4.10 posix -lc_r Y OK 257dnl 258dnl NetBSD 1.6 -- 259dnl 260dnl OpenBSD 3.4 posix -lpthread Y OK 261dnl 262dnl MacOS X 10.[123] posix -lpthread Y OK 263dnl 264dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK 265dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK 266dnl 267dnl HP-UX 11 posix -lpthread N (cc) OK 268dnl Y (gcc) 269dnl 270dnl IRIX 6.5 posix -lpthread Y 0.5 271dnl 272dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK 273dnl 274dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK 275dnl -lpthread (gcc) Y 276dnl 277dnl Cygwin posix -lpthread Y OK 278dnl 279dnl Any of the above pth -lpth 0.0 280dnl 281dnl Mingw win32 N OK 282dnl 283dnl BeOS 5 -- 284dnl 285dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is 286dnl turned off: 287dnl OK if all three tests terminate OK, 288dnl 0.5 if the first test terminates OK but the second one loops endlessly, 289dnl 0.0 if the first test already loops endlessly. 290