Annotation of embedaddon/libiconv/srcm4/threadlib.m4, revision 1.1
1.1 ! misho 1: # threadlib.m4 serial 3 (gettext-0.18)
! 2: dnl Copyright (C) 2005-2009 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],
! 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:
! 244: AC_DEFUN([gl_THREADLIB],
! 245: [
! 246: AC_REQUIRE([gl_THREADLIB_EARLY])
! 247: AC_REQUIRE([gl_THREADLIB_BODY])
! 248: ])
! 249:
! 250:
! 251: dnl gl_DISABLE_THREADS
! 252: dnl ------------------
! 253: dnl Sets the gl_THREADLIB default so that threads are not used by default.
! 254: dnl The user can still override it at installation time, by using the
! 255: dnl configure option '--enable-threads'.
! 256:
! 257: AC_DEFUN([gl_DISABLE_THREADS], [
! 258: m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
! 259: ])
! 260:
! 261:
! 262: dnl Survey of platforms:
! 263: dnl
! 264: dnl Platform Available Compiler Supports test-lock
! 265: dnl flavours option weak result
! 266: dnl --------------- --------- --------- -------- ---------
! 267: dnl Linux 2.4/glibc posix -lpthread Y OK
! 268: dnl
! 269: dnl GNU Hurd/glibc posix
! 270: dnl
! 271: dnl FreeBSD 5.3 posix -lc_r Y
! 272: dnl posix -lkse ? Y
! 273: dnl posix -lpthread ? Y
! 274: dnl posix -lthr Y
! 275: dnl
! 276: dnl FreeBSD 5.2 posix -lc_r Y
! 277: dnl posix -lkse Y
! 278: dnl posix -lthr Y
! 279: dnl
! 280: dnl FreeBSD 4.0,4.10 posix -lc_r Y OK
! 281: dnl
! 282: dnl NetBSD 1.6 --
! 283: dnl
! 284: dnl OpenBSD 3.4 posix -lpthread Y OK
! 285: dnl
! 286: dnl MacOS X 10.[123] posix -lpthread Y OK
! 287: dnl
! 288: dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK
! 289: dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK
! 290: dnl
! 291: dnl HP-UX 11 posix -lpthread N (cc) OK
! 292: dnl Y (gcc)
! 293: dnl
! 294: dnl IRIX 6.5 posix -lpthread Y 0.5
! 295: dnl
! 296: dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK
! 297: dnl
! 298: dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK
! 299: dnl -lpthread (gcc) Y
! 300: dnl
! 301: dnl Cygwin posix -lpthread Y OK
! 302: dnl
! 303: dnl Any of the above pth -lpth 0.0
! 304: dnl
! 305: dnl Mingw win32 N OK
! 306: dnl
! 307: dnl BeOS 5 --
! 308: dnl
! 309: dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
! 310: dnl turned off:
! 311: dnl OK if all three tests terminate OK,
! 312: dnl 0.5 if the first test terminates OK but the second one loops endlessly,
! 313: dnl 0.0 if the first test already loops endlessly.
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to threadlib.m4 CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libiconv / srcm4