home *** CD-ROM | disk | FTP | other *** search
/ Clickx 115 / Clickx 115.iso / software / tools / windows / tails-i386-0.16.iso / live / filesystem.squashfs / usr / share / aclocal / threadlib.m4 < prev    next >
Encoding:
M4 Source File  |  2010-09-19  |  13.2 KB  |  348 lines
  1. # threadlib.m4 serial 5 (gettext-0.18)
  2. dnl Copyright (C) 2005-2010 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. changequote(,)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
  72. changequote([,])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.  
  98. dnl The guts of gl_THREADLIB. Needs to be expanded only once.
  99.  
  100. AC_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
  122. int 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.  
  278. AC_DEFUN([gl_THREADLIB],
  279. [
  280.   AC_REQUIRE([gl_THREADLIB_EARLY])
  281.   AC_REQUIRE([gl_THREADLIB_BODY])
  282. ])
  283.  
  284.  
  285. dnl gl_DISABLE_THREADS
  286. dnl ------------------
  287. dnl Sets the gl_THREADLIB default so that threads are not used by default.
  288. dnl The user can still override it at installation time, by using the
  289. dnl configure option '--enable-threads'.
  290.  
  291. AC_DEFUN([gl_DISABLE_THREADS], [
  292.   m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
  293. ])
  294.  
  295.  
  296. dnl Survey of platforms:
  297. dnl
  298. dnl Platform          Available   Compiler    Supports   test-lock
  299. dnl                   flavours    option      weak       result
  300. dnl ---------------   ---------   ---------   --------   ---------
  301. dnl Linux 2.4/glibc   posix       -lpthread       Y      OK
  302. dnl
  303. dnl GNU Hurd/glibc    posix
  304. dnl
  305. dnl FreeBSD 5.3       posix       -lc_r           Y
  306. dnl                   posix       -lkse ?         Y
  307. dnl                   posix       -lpthread ?     Y
  308. dnl                   posix       -lthr           Y
  309. dnl
  310. dnl FreeBSD 5.2       posix       -lc_r           Y
  311. dnl                   posix       -lkse           Y
  312. dnl                   posix       -lthr           Y
  313. dnl
  314. dnl FreeBSD 4.0,4.10  posix       -lc_r           Y      OK
  315. dnl
  316. dnl NetBSD 1.6        --
  317. dnl
  318. dnl OpenBSD 3.4       posix       -lpthread       Y      OK
  319. dnl
  320. dnl MacOS X 10.[123]  posix       -lpthread       Y      OK
  321. dnl
  322. dnl Solaris 7,8,9     posix       -lpthread       Y      Sol 7,8: 0.0; Sol 9: OK
  323. dnl                   solaris     -lthread        Y      Sol 7,8: 0.0; Sol 9: OK
  324. dnl
  325. dnl HP-UX 11          posix       -lpthread       N (cc) OK
  326. dnl                                               Y (gcc)
  327. dnl
  328. dnl IRIX 6.5          posix       -lpthread       Y      0.5
  329. dnl
  330. dnl AIX 4.3,5.1       posix       -lpthread       N      AIX 4: 0.5; AIX 5: OK
  331. dnl
  332. dnl OSF/1 4.0,5.1     posix       -pthread (cc)   N      OK
  333. dnl                               -lpthread (gcc) Y
  334. dnl
  335. dnl Cygwin            posix       -lpthread       Y      OK
  336. dnl
  337. dnl Any of the above  pth         -lpth                  0.0
  338. dnl
  339. dnl Mingw             win32                       N      OK
  340. dnl
  341. dnl BeOS 5            --
  342. dnl
  343. dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
  344. dnl turned off:
  345. dnl   OK if all three tests terminate OK,
  346. dnl   0.5 if the first test terminates OK but the second one loops endlessly,
  347. dnl   0.0 if the first test already loops endlessly.
  348.