m4/threadlib.m4

   1 # threadlib.m4 serial 1 (gettext-0.18)
   2 dnl Copyright (C) 2005-2008 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 gl_THREADLIB
  10 dnl ------------
  11 dnl Tests for a multithreading library to be used.
  12 dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS,
  13 dnl USE_PTH_THREADS, USE_WIN32_THREADS
  14 dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
  15 dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
  16 dnl libtool).
  17 dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
  18 dnl programs that really need multithread functionality. The difference
  19 dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
  20 dnl symbols, typically LIBTHREAD="" whereas LIBMULTITHREAD="-lpthread".
  21 dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
  22 dnl multithread-safe programs.
  23
  24 AC_DEFUN([gl_THREADLIB_EARLY],
  25 [
  26   AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
  27 ])
  28
  29 dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
  30
  31 AC_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,
  49 AC_HELP_STRING([--enable-threads={posix|solaris|pth|win32}], [specify multithreading API])
  50 AC_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
  87 dnl The guts of gl_THREADLIB. Needs to be expanded only once.
  88
  89 AC_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, gl_have_pthread_h=yes, gl_have_pthread_h=no)
 108       if test "$gl_have_pthread_h" = yes; then
 109         # Other possible tests:
 110         #   -lpthreads (FSU threads, PCthreads)
 111         #   -lgthreads
 112         gl_have_pthread=
 113         # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
 114         # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
 115         # the second one only in libpthread, and lock.c needs it.
 116         AC_TRY_LINK([#include <pthread.h>],
 117           [pthread_mutex_lock((pthread_mutex_t*)0);
 118            pthread_mutexattr_init((pthread_mutexattr_t*)0);],
 119           [gl_have_pthread=yes])
 120         # Test for libpthread by looking for pthread_kill. (Not pthread_self,
 121         # since it is defined as a macro on OSF/1.)
 122         if test -n "$gl_have_pthread"; then
 123           # The program links fine without libpthread. But it may actually
 124           # need to link with libpthread in order to create multiple threads.
 125           AC_CHECK_LIB(pthread, pthread_kill,
 126             [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
 127              # On Solaris and HP-UX, most pthread functions exist also in libc.
 128              # Therefore pthread_in_use() needs to actually try to create a
 129              # thread: pthread_create from libc will fail, whereas
 130              # pthread_create will actually create a thread.
 131              case "$host_os" in
 132                solaris* | hpux*)
 133                  AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], 1,
 134                    [Define if the pthread_in_use() detection is hard.])
 135              esac
 136             ])
 137         else
 138           # Some library is needed. Try libpthread and libc_r.
 139           AC_CHECK_LIB(pthread, pthread_kill,
 140             [gl_have_pthread=yes
 141              LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
 142              LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
 143           if test -z "$gl_have_pthread"; then
 144             # For FreeBSD 4.
 145             AC_CHECK_LIB(c_r, pthread_kill,
 146               [gl_have_pthread=yes
 147                LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
 148                LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
 149           fi
 150         fi
 151         if test -n "$gl_have_pthread"; then
 152           gl_threads_api=posix
 153           AC_DEFINE([USE_POSIX_THREADS], 1,
 154             [Define if the POSIX multithreading library can be used.])
 155           if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
 156             if test $gl_have_weak = yes; then
 157               AC_DEFINE([USE_POSIX_THREADS_WEAK], 1,
 158                 [Define if references to the POSIX multithreading library should be made weak.])
 159               LIBTHREAD=
 160               LTLIBTHREAD=
 161             fi
 162           fi
 163         fi
 164       fi
 165     fi
 166     if test -z "$gl_have_pthread"; then
 167       if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
 168         gl_have_solaristhread=
 169         gl_save_LIBS="$LIBS"
 170         LIBS="$LIBS -lthread"
 171         AC_TRY_LINK([#include <thread.h>
 172 #include <synch.h>],
 173           [thr_self();],
 174           [gl_have_solaristhread=yes])
 175         LIBS="$gl_save_LIBS"
 176         if test -n "$gl_have_solaristhread"; then
 177           gl_threads_api=solaris
 178           LIBTHREAD=-lthread
 179           LTLIBTHREAD=-lthread
 180           LIBMULTITHREAD="$LIBTHREAD"
 181           LTLIBMULTITHREAD="$LTLIBTHREAD"
 182           AC_DEFINE([USE_SOLARIS_THREADS], 1,
 183             [Define if the old Solaris multithreading library can be used.])
 184           if test $gl_have_weak = yes; then
 185             AC_DEFINE([USE_SOLARIS_THREADS_WEAK], 1,
 186               [Define if references to the old Solaris multithreading library should be made weak.])
 187             LIBTHREAD=
 188             LTLIBTHREAD=
 189           fi
 190         fi
 191       fi
 192     fi
 193     if test "$gl_use_threads" = pth; then
 194       gl_save_CPPFLAGS="$CPPFLAGS"
 195       AC_LIB_LINKFLAGS(pth)
 196       gl_have_pth=
 197       gl_save_LIBS="$LIBS"
 198       LIBS="$LIBS -lpth"
 199       AC_TRY_LINK([#include <pth.h>], [pth_self();], gl_have_pth=yes)
 200       LIBS="$gl_save_LIBS"
 201       if test -n "$gl_have_pth"; then
 202         gl_threads_api=pth
 203         LIBTHREAD="$LIBPTH"
 204         LTLIBTHREAD="$LTLIBPTH"
 205         LIBMULTITHREAD="$LIBTHREAD"
 206         LTLIBMULTITHREAD="$LTLIBTHREAD"
 207         AC_DEFINE([USE_PTH_THREADS], 1,
 208           [Define if the GNU Pth multithreading library can be used.])
 209         if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
 210           if test $gl_have_weak = yes; then
 211             AC_DEFINE([USE_PTH_THREADS_WEAK], 1,
 212               [Define if references to the GNU Pth multithreading library should be made weak.])
 213             LIBTHREAD=
 214             LTLIBTHREAD=
 215           fi
 216         fi
 217       else
 218         CPPFLAGS="$gl_save_CPPFLAGS"
 219       fi
 220     fi
 221     if test -z "$gl_have_pthread"; then
 222       if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then
 223         if { case "$host_os" in
 224                mingw*) true;;
 225                *) false;;
 226              esac
 227            }; then
 228           gl_threads_api=win32
 229           AC_DEFINE([USE_WIN32_THREADS], 1,
 230             [Define if the Win32 multithreading API can be used.])
 231         fi
 232       fi
 233     fi
 234   fi
 235   AC_MSG_CHECKING([for multithread API to use])
 236   AC_MSG_RESULT([$gl_threads_api])
 237   AC_SUBST(LIBTHREAD)
 238   AC_SUBST(LTLIBTHREAD)
 239   AC_SUBST(LIBMULTITHREAD)
 240   AC_SUBST(LTLIBMULTITHREAD)
 241 ])
 242
 243 AC_DEFUN([gl_THREADLIB],
 244 [
 245   AC_REQUIRE([gl_THREADLIB_EARLY])
 246   AC_REQUIRE([gl_THREADLIB_BODY])
 247 ])
 248
 249
 250 dnl gl_DISABLE_THREADS
 251 dnl ------------------
 252 dnl Sets the gl_THREADLIB default so that threads are not used by default.
 253 dnl The user can still override it at installation time, by using the
 254 dnl configure option '--enable-threads'.
 255
 256 AC_DEFUN([gl_DISABLE_THREADS], [
 257   m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
 258 ])
 259
 260
 261 dnl Survey of platforms:
 262 dnl
 263 dnl Platform          Available   Compiler    Supports   test-lock
 264 dnl                   flavours    option      weak       result
 265 dnl ---------------   ---------   ---------   --------   ---------
 266 dnl Linux 2.4/glibc   posix       -lpthread       Y      OK
 267 dnl
 268 dnl GNU Hurd/glibc    posix
 269 dnl
 270 dnl FreeBSD 5.3       posix       -lc_r           Y
 271 dnl                   posix       -lkse ?         Y
 272 dnl                   posix       -lpthread ?     Y
 273 dnl                   posix       -lthr           Y
 274 dnl
 275 dnl FreeBSD 5.2       posix       -lc_r           Y
 276 dnl                   posix       -lkse           Y
 277 dnl                   posix       -lthr           Y
 278 dnl
 279 dnl FreeBSD 4.0,4.10  posix       -lc_r           Y      OK
 280 dnl
 281 dnl NetBSD 1.6        --
 282 dnl
 283 dnl OpenBSD 3.4       posix       -lpthread       Y      OK
 284 dnl
 285 dnl MacOS X 10.[123]  posix       -lpthread       Y      OK
 286 dnl
 287 dnl Solaris 7,8,9     posix       -lpthread       Y      Sol 7,8: 0.0; Sol 9: OK
 288 dnl                   solaris     -lthread        Y      Sol 7,8: 0.0; Sol 9: OK
 289 dnl
 290 dnl HP-UX 11          posix       -lpthread       N (cc) OK
 291 dnl                                               Y (gcc)
 292 dnl
 293 dnl IRIX 6.5          posix       -lpthread       Y      0.5
 294 dnl
 295 dnl AIX 4.3,5.1       posix       -lpthread       N      AIX 4: 0.5; AIX 5: OK
 296 dnl
 297 dnl OSF/1 4.0,5.1     posix       -pthread (cc)   N      OK
 298 dnl                               -lpthread (gcc) Y
 299 dnl
 300 dnl Cygwin            posix       -lpthread       Y      OK
 301 dnl
 302 dnl Any of the above  pth         -lpth                  0.0
 303 dnl
 304 dnl Mingw             win32                       N      OK
 305 dnl
 306 dnl BeOS 5            --
 307 dnl
 308 dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
 309 dnl turned off:
 310 dnl   OK if all three tests terminate OK,
 311 dnl   0.5 if the first test terminates OK but the second one loops endlessly,
 312 dnl   0.0 if the first test already loops endlessly.