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