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