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