~ubuntu-branches/ubuntu/precise/wget/precise-proposed

« back to all changes in this revision

Viewing changes to m4/threadlib.m4

  • Committer: Bazaar Package Importer
  • Author(s): Steve Langasek
  • Date: 2011-10-19 00:00:09 UTC
  • mfrom: (2.1.13 sid)
  • Revision ID: james.westby@ubuntu.com-20111019000009-8p33w3wz4b1rdri0
Tags: 1.13-1ubuntu1
* Merge from Debian unstable, remaining changes:
  - Add wget-udeb to ship wget.gnu as alternative to busybox wget
    implementation.
  - Depend on libssl-dev 0.9.8k-7ubuntu4 (LP: #503339)
* Dropped changes, superseded in Debian:
  - Keep build dependencies in main:
    + debian/control: remove info2man build-dep
    + debian/patches/series: disable wget-infopod_generated_manpage
  - Mark wget Multi-Arch: foreign, so packages that aren't of the same arch
    can depend on it.
* Pass --with-ssl=openssl; we don't want to use gnutls, there's no udeb for
  it.
* Add a second build pass for the udeb, so we can build without libidn.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# threadlib.m4 serial 8 (gettext-0.18.2)
 
2
dnl Copyright (C) 2005-2011 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 If the configure.ac contains a definition of the gl_THREADLIB_DEFAULT_NO
 
13
dnl (it must be placed before the invocation of gl_THREADLIB_EARLY!), then the
 
14
dnl default is 'no', otherwise it is system dependent. In both cases, the user
 
15
dnl can change the choice through the options --enable-threads=choice or
 
16
dnl --disable-threads.
 
17
dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS,
 
18
dnl USE_PTH_THREADS, USE_WIN32_THREADS
 
19
dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
 
20
dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
 
21
dnl libtool).
 
22
dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
 
23
dnl programs that really need multithread functionality. The difference
 
24
dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
 
25
dnl symbols, typically LIBTHREAD="" whereas LIBMULTITHREAD="-lpthread".
 
26
dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
 
27
dnl multithread-safe programs.
 
28
 
 
29
AC_DEFUN([gl_THREADLIB_EARLY],
 
30
[
 
31
  AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
 
32
])
 
33
 
 
34
dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
 
35
 
 
36
AC_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],
 
56
AC_HELP_STRING([--enable-threads={posix|solaris|pth|win32}], [specify multithreading API])m4_ifdef([gl_THREADLIB_DEFAULT_NO], [], [
 
57
AC_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
 
62
changequote(,)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
 
79
changequote([,])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
 
 
105
dnl The guts of gl_THREADLIB. Needs to be expanded only once.
 
106
 
 
107
AC_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
 
134
int 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
 
 
300
AC_DEFUN([gl_THREADLIB],
 
301
[
 
302
  AC_REQUIRE([gl_THREADLIB_EARLY])
 
303
  AC_REQUIRE([gl_THREADLIB_BODY])
 
304
])
 
305
 
 
306
 
 
307
dnl gl_DISABLE_THREADS
 
308
dnl ------------------
 
309
dnl Sets the gl_THREADLIB default so that threads are not used by default.
 
310
dnl The user can still override it at installation time, by using the
 
311
dnl configure option '--enable-threads'.
 
312
 
 
313
AC_DEFUN([gl_DISABLE_THREADS], [
 
314
  m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
 
315
])
 
316
 
 
317
 
 
318
dnl Survey of platforms:
 
319
dnl
 
320
dnl Platform          Available   Compiler    Supports   test-lock
 
321
dnl                   flavours    option      weak       result
 
322
dnl ---------------   ---------   ---------   --------   ---------
 
323
dnl Linux 2.4/glibc   posix       -lpthread       Y      OK
 
324
dnl
 
325
dnl GNU Hurd/glibc    posix
 
326
dnl
 
327
dnl FreeBSD 5.3       posix       -lc_r           Y
 
328
dnl                   posix       -lkse ?         Y
 
329
dnl                   posix       -lpthread ?     Y
 
330
dnl                   posix       -lthr           Y
 
331
dnl
 
332
dnl FreeBSD 5.2       posix       -lc_r           Y
 
333
dnl                   posix       -lkse           Y
 
334
dnl                   posix       -lthr           Y
 
335
dnl
 
336
dnl FreeBSD 4.0,4.10  posix       -lc_r           Y      OK
 
337
dnl
 
338
dnl NetBSD 1.6        --
 
339
dnl
 
340
dnl OpenBSD 3.4       posix       -lpthread       Y      OK
 
341
dnl
 
342
dnl MacOS X 10.[123]  posix       -lpthread       Y      OK
 
343
dnl
 
344
dnl Solaris 7,8,9     posix       -lpthread       Y      Sol 7,8: 0.0; Sol 9: OK
 
345
dnl                   solaris     -lthread        Y      Sol 7,8: 0.0; Sol 9: OK
 
346
dnl
 
347
dnl HP-UX 11          posix       -lpthread       N (cc) OK
 
348
dnl                                               Y (gcc)
 
349
dnl
 
350
dnl IRIX 6.5          posix       -lpthread       Y      0.5
 
351
dnl
 
352
dnl AIX 4.3,5.1       posix       -lpthread       N      AIX 4: 0.5; AIX 5: OK
 
353
dnl
 
354
dnl OSF/1 4.0,5.1     posix       -pthread (cc)   N      OK
 
355
dnl                               -lpthread (gcc) Y
 
356
dnl
 
357
dnl Cygwin            posix       -lpthread       Y      OK
 
358
dnl
 
359
dnl Any of the above  pth         -lpth                  0.0
 
360
dnl
 
361
dnl Mingw             win32                       N      OK
 
362
dnl
 
363
dnl BeOS 5            --
 
364
dnl
 
365
dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
 
366
dnl turned off:
 
367
dnl   OK if all three tests terminate OK,
 
368
dnl   0.5 if the first test terminates OK but the second one loops endlessly,
 
369
dnl   0.0 if the first test already loops endlessly.