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