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