58e4e0bc4 · cryptotaxi247/netdata-1

@@ -1,5 +1,5 @@

1 # ===========================================================================

2 -# http://www.gnu.org/software/autoconf-archive/ax_pthread.html

2 +# https://www.gnu.org/software/autoconf-archive/ax_pthread.html

3 # ===========================================================================

4 #

5 # SYNOPSIS

@@ -14,24 +14,28 @@

14 # flags that are needed. (The user can also force certain compiler

15 # flags/libs to be tested by setting these environment variables.)

16 #

17 -# Also sets PTHREAD_CC to any special C compiler that is needed for

18 -# multi-threaded programs (defaults to the value of CC otherwise). (This

19 -# is necessary on AIX to use the special cc_r compiler alias.)

17 +# Also sets PTHREAD_CC and PTHREAD_CXX to any special C compiler that is

18 +# needed for multi-threaded programs (defaults to the value of CC

19 +# respectively CXX otherwise). (This is necessary on e.g. AIX to use the

20 +# special cc_r/CC_r compiler alias.)

21 #

22 # NOTE: You are assumed to not only compile your program with these flags,

22 -# but also link it with them as well. e.g. you should link with

23 +# but also to link with them as well. For example, you might link with

24 # $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS

25 +# $PTHREAD_CXX $CXXFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS

26 #

25 -# If you are only building threads programs, you may wish to use these

27 +# If you are only building threaded programs, you may wish to use these

28 # variables in your default LIBS, CFLAGS, and CC:

29 #

30 # LIBS="$PTHREAD_LIBS $LIBS"

31 # CFLAGS="$CFLAGS $PTHREAD_CFLAGS"

32 +# CXXFLAGS="$CXXFLAGS $PTHREAD_CFLAGS"

33 # CC="$PTHREAD_CC"

34 +# CXX="$PTHREAD_CXX"

35 #

36 # In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute constant

33 -# has a nonstandard name, defines PTHREAD_CREATE_JOINABLE to that name

34 -# (e.g. PTHREAD_CREATE_UNDETACHED on AIX).

37 +# has a nonstandard name, this macro defines PTHREAD_CREATE_JOINABLE to

38 +# that name (e.g. PTHREAD_CREATE_UNDETACHED on AIX).

39 #

40 # Also HAVE_PTHREAD_PRIO_INHERIT is defined if pthread is found and the

41 # PTHREAD_PRIO_INHERIT symbol is defined when compiling with

@@ -55,38 +59,69 @@

59 #

63 #

59 -# SPDX-License-Identifier: GPL-3.0-or-later

64 +# This program is free software: you can redistribute it and/or modify it

65 +# under the terms of the GNU General Public License as published by the

66 +# Free Software Foundation, either version 3 of the License, or (at your

67 +# option) any later version.

68 +#

69 +# This program is distributed in the hope that it will be useful, but

70 +# WITHOUT ANY WARRANTY; without even the implied warranty of

71 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General

72 +# Public License for more details.

73 +#

74 +# You should have received a copy of the GNU General Public License along

75 +# with this program. If not, see <https://www.gnu.org/licenses/>.

76 +#

77 +# As a special exception, the respective Autoconf Macro's copyright owner

78 +# gives unlimited permission to copy, distribute and modify the configure

79 +# scripts that are the output of Autoconf when processing the Macro. You

80 +# need not follow the terms of the GNU General Public License when using

81 +# or distributing such scripts, even though portions of the text of the

82 +# Macro appear in them. The GNU General Public License (GPL) does govern

83 +# all other use of the material that constitutes the Autoconf Macro.

84 +#

85 +# This special exception to the GPL applies to versions of the Autoconf

86 +# Macro released by the Autoconf Archive. When you make and distribute a

87 +# modified version of the Autoconf Macro, you may extend this special

88 +# exception to the GPL to apply to your modified version as well.

89

61 -#serial 21

90 +#serial 31

91

92 AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD])

93 AC_DEFUN([AX_PTHREAD], [

94 AC_REQUIRE([AC_CANONICAL_HOST])

95 +AC_REQUIRE([AC_PROG_CC])

96 +AC_REQUIRE([AC_PROG_SED])

97 AC_LANG_PUSH([C])

98 ax_pthread_ok=no

99

100 # We used to check for pthread.h first, but this fails if pthread.h

70 -# requires special compiler flags (e.g. on True64 or Sequent).

101 +# requires special compiler flags (e.g. on Tru64 or Sequent).

102 # It gets checked for in the link test anyway.

103

104 # First of all, check if the user has set any of the PTHREAD_LIBS,

105 # etcetera environment variables, and if threads linking works using

106 # them:

76 -if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then

77 - save_CFLAGS="$CFLAGS"

107 +if test "x$PTHREAD_CFLAGS$PTHREAD_LIBS" != "x"; then

108 + ax_pthread_save_CC="$CC"

109 + ax_pthread_save_CFLAGS="$CFLAGS"

110 + ax_pthread_save_LIBS="$LIBS"

111 + AS_IF([test "x$PTHREAD_CC" != "x"], [CC="$PTHREAD_CC"])

112 + AS_IF([test "x$PTHREAD_CXX" != "x"], [CXX="$PTHREAD_CXX"])

113 CFLAGS="$CFLAGS $PTHREAD_CFLAGS"

79 - save_LIBS="$LIBS"

114 LIBS="$PTHREAD_LIBS $LIBS"

81 - AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS])

82 - AC_TRY_LINK_FUNC([pthread_join], [ax_pthread_ok=yes])

115 + AC_MSG_CHECKING([for pthread_join using $CC $PTHREAD_CFLAGS $PTHREAD_LIBS])

116 + AC_LINK_IFELSE([AC_LANG_CALL([], [pthread_join])], [ax_pthread_ok=yes])

117 AC_MSG_RESULT([$ax_pthread_ok])

84 - if test x"$ax_pthread_ok" = xno; then

118 + if test "x$ax_pthread_ok" = "xno"; then

119 PTHREAD_LIBS=""

120 PTHREAD_CFLAGS=""

121 fi

88 - LIBS="$save_LIBS"

89 - CFLAGS="$save_CFLAGS"

122 + CC="$ax_pthread_save_CC"

123 + CFLAGS="$ax_pthread_save_CFLAGS"

124 + LIBS="$ax_pthread_save_LIBS"

125 fi

126

127 # We must check for the threads library under a number of different

@@ -94,12 +129,14 @@ fi

129 # (e.g. DEC) have both -lpthread and -lpthreads, where one of the

130 # libraries is broken (non-POSIX).

131

97 -# Create a list of thread flags to try. Items starting with a "-" are

98 -# C compiler flags, and other items are library names, except for "none"

99 -# which indicates that we try without any flags at all, and "pthread-config"

100 -# which is a program returning the flags for the Pth emulation library.

132 +# Create a list of thread flags to try. Items with a "," contain both

133 +# C compiler flags (before ",") and linker flags (after ","). Other items

134 +# starting with a "-" are C compiler flags, and remaining items are

135 +# library names, except for "none" which indicates that we try without

136 +# any flags at all, and "pthread-config" which is a program returning

137 +# the flags for the Pth emulation library.

138

102 -ax_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"

139 +ax_pthread_flags="pthreads none -Kthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"

140

141 # The ordering *is* (sometimes) important. Some notes on the

142 # individual items follow:

@@ -108,82 +145,163 @@ ax_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mt

145 # none: in case threads are in libc; should be tried before -Kthread and

146 # other compiler flags to prevent continual compiler warnings

147 # -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)

111 -# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)

112 -# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)

113 -# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)

114 -# -pthreads: Solaris/gcc

115 -# -mthreads: Mingw32/gcc, Lynx/gcc

148 +# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads), Tru64

149 +# (Note: HP C rejects this with "bad form for `-t' option")

150 +# -pthreads: Solaris/gcc (Note: HP C also rejects)

151 # -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it

117 -# doesn't hurt to check since this sometimes defines pthreads too;

118 -# also defines -D_REENTRANT)

119 -# ... -mt is also the pthreads flag for HP/aCC

152 +# doesn't hurt to check since this sometimes defines pthreads and

153 +# -D_REENTRANT too), HP C (must be checked before -lpthread, which

154 +# is present but should not be used directly; and before -mthreads,

155 +# because the compiler interprets this as "-mt" + "-hreads")

156 +# -mthreads: Mingw32/gcc, Lynx/gcc

157 # pthread: Linux, etcetera

158 # --thread-safe: KAI C++

159 # pthread-config: use pthread-config program (for GNU Pth library)

160

124 -case ${host_os} in

161 +case $host_os in

162 +

163 + freebsd*)

164 +

165 + # -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)

166 + # lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)

167 +

168 + ax_pthread_flags="-kthread lthread $ax_pthread_flags"

169 + ;;

170 +

171 + hpux*)

172 +

173 + # From the cc(1) man page: "[-mt] Sets various -D flags to enable

174 + # multi-threading and also sets -lpthread."

175 +

176 + ax_pthread_flags="-mt -pthread pthread $ax_pthread_flags"

177 + ;;

178 +

179 + openedition*)

180 +

181 + # IBM z/OS requires a feature-test macro to be defined in order to

182 + # enable POSIX threads at all, so give the user a hint if this is

183 + # not set. (We don't define these ourselves, as they can affect

184 + # other portions of the system API in unpredictable ways.)

185 +

186 + AC_EGREP_CPP([AX_PTHREAD_ZOS_MISSING],

187 + [

188 +# if !defined(_OPEN_THREADS) && !defined(_UNIX03_THREADS)

189 + AX_PTHREAD_ZOS_MISSING

190 +# endif

191 + ],

192 + [AC_MSG_WARN([IBM z/OS requires -D_OPEN_THREADS or -D_UNIX03_THREADS to enable pthreads support.])])

193 + ;;

194 +

195 solaris*)

196

197 # On Solaris (at least, for some versions), libc contains stubbed

198 # (non-functional) versions of the pthreads routines, so link-based

129 - # tests will erroneously succeed. (We need to link with -pthreads/-mt/

130 - # -lpthread.) (The stubs are missing pthread_cleanup_push, or rather

131 - # a function called by this macro, so we could check for that, but

132 - # who knows whether they'll stub that too in a future libc.) So,

133 - # we'll just look for -pthreads and -lpthread first:

199 + # tests will erroneously succeed. (N.B.: The stubs are missing

200 + # pthread_cleanup_push, or rather a function called by this macro,

201 + # so we could check for that, but who knows whether they'll stub

202 + # that too in a future libc.) So we'll check first for the

203 + # standard Solaris way of linking pthreads (-mt -lpthread).

204 +

205 + ax_pthread_flags="-mt,-lpthread pthread $ax_pthread_flags"

206 + ;;

207 +esac

208 +

209 +# Are we compiling with Clang?

210 +

211 +AC_CACHE_CHECK([whether $CC is Clang],

212 + [ax_cv_PTHREAD_CLANG],

213 + [ax_cv_PTHREAD_CLANG=no

214 + # Note that Autoconf sets GCC=yes for Clang as well as GCC

215 + if test "x$GCC" = "xyes"; then

216 + AC_EGREP_CPP([AX_PTHREAD_CC_IS_CLANG],

217 + [/* Note: Clang 2.7 lacks __clang_[a-z]+__ */

218 +# if defined(__clang__) && defined(__llvm__)

219 + AX_PTHREAD_CC_IS_CLANG

220 +# endif

221 + ],

222 + [ax_cv_PTHREAD_CLANG=yes])

223 + fi

224 + ])

225 +ax_pthread_clang="$ax_cv_PTHREAD_CLANG"

226 +

227 +

228 +# GCC generally uses -pthread, or -pthreads on some platforms (e.g. SPARC)

229 +

230 +# Note that for GCC and Clang -pthread generally implies -lpthread,

231 +# except when -nostdlib is passed.

232 +# This is problematic using libtool to build C++ shared libraries with pthread:

233 +# [1] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=25460

234 +# [2] https://bugzilla.redhat.com/show_bug.cgi?id=661333

235 +# [3] https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=468555

236 +# To solve this, first try -pthread together with -lpthread for GCC

237 +

238 +AS_IF([test "x$GCC" = "xyes"],

239 + [ax_pthread_flags="-pthread,-lpthread -pthread -pthreads $ax_pthread_flags"])

240

135 - ax_pthread_flags="-pthreads pthread -mt -pthread $ax_pthread_flags"

241 +# Clang takes -pthread (never supported any other flag), but we'll try with -lpthread first

242 +

243 +AS_IF([test "x$ax_pthread_clang" = "xyes"],

244 + [ax_pthread_flags="-pthread,-lpthread -pthread"])

245 +

246 +

247 +# The presence of a feature test macro requesting re-entrant function

248 +# definitions is, on some systems, a strong hint that pthreads support is

249 +# correctly enabled

250 +

251 +case $host_os in

252 + darwin* | hpux* | linux* | osf* | solaris*)

253 + ax_pthread_check_macro="_REENTRANT"

254 ;;

255

138 - darwin*)

139 - ax_pthread_flags="-pthread $ax_pthread_flags"

256 + aix*)

257 + ax_pthread_check_macro="_THREAD_SAFE"

258 ;;

141 -esac

259

143 -# Clang doesn't consider unrecognized options an error unless we specify

144 -# -Werror. We throw in some extra Clang-specific options to ensure that

145 -# this doesn't happen for GCC, which also accepts -Werror.

260 + *)

261 + ax_pthread_check_macro="--"

262 + ;;

263 +esac

264 +AS_IF([test "x$ax_pthread_check_macro" = "x--"],

265 + [ax_pthread_check_cond=0],

266 + [ax_pthread_check_cond="!defined($ax_pthread_check_macro)"])

267

147 -AC_MSG_CHECKING([if compiler needs -Werror to reject unknown flags])

148 -save_CFLAGS="$CFLAGS"

149 -ax_pthread_extra_flags="-Werror"

150 -CFLAGS="$CFLAGS $ax_pthread_extra_flags -Wunknown-warning-option -Wsizeof-array-argument"

151 -AC_COMPILE_IFELSE([AC_LANG_PROGRAM([int foo(void);],[foo()])],

152 - [AC_MSG_RESULT([yes])],

153 - [ax_pthread_extra_flags=

154 - AC_MSG_RESULT([no])])

155 -CFLAGS="$save_CFLAGS"

268

157 -if test x"$ax_pthread_ok" = xno; then

158 -for flag in $ax_pthread_flags; do

269 +if test "x$ax_pthread_ok" = "xno"; then

270 +for ax_pthread_try_flag in $ax_pthread_flags; do

271

160 - case $flag in

272 + case $ax_pthread_try_flag in

273 none)

274 AC_MSG_CHECKING([whether pthreads work without any flags])

275 ;;

276

277 + *,*)

278 + PTHREAD_CFLAGS=`echo $ax_pthread_try_flag | sed "s/^$.*$,$.*$$/\1/"`

279 + PTHREAD_LIBS=`echo $ax_pthread_try_flag | sed "s/^$.*$,$.*$$/\2/"`

280 + AC_MSG_CHECKING([whether pthreads work with "$PTHREAD_CFLAGS" and "$PTHREAD_LIBS"])

281 + ;;

282 +

283 -*)

166 - AC_MSG_CHECKING([whether pthreads work with $flag])

167 - PTHREAD_CFLAGS="$flag"

284 + AC_MSG_CHECKING([whether pthreads work with $ax_pthread_try_flag])

285 + PTHREAD_CFLAGS="$ax_pthread_try_flag"

286 ;;

287

288 pthread-config)

289 AC_CHECK_PROG([ax_pthread_config], [pthread-config], [yes], [no])

172 - if test x"$ax_pthread_config" = xno; then continue; fi

290 + AS_IF([test "x$ax_pthread_config" = "xno"], [continue])

291 PTHREAD_CFLAGS="`pthread-config --cflags`"

292 PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"

293 ;;

294

295 *)

178 - AC_MSG_CHECKING([for the pthreads library -l$flag])

179 - PTHREAD_LIBS="-l$flag"

296 + AC_MSG_CHECKING([for the pthreads library -l$ax_pthread_try_flag])

297 + PTHREAD_LIBS="-l$ax_pthread_try_flag"

298 ;;

299 esac

300

183 - save_LIBS="$LIBS"

184 - save_CFLAGS="$CFLAGS"

301 + ax_pthread_save_CFLAGS="$CFLAGS"

302 + ax_pthread_save_LIBS="$LIBS"

303 + CFLAGS="$CFLAGS $PTHREAD_CFLAGS"

304 LIBS="$PTHREAD_LIBS $LIBS"

186 - CFLAGS="$CFLAGS $PTHREAD_CFLAGS $ax_pthread_extra_flags"

305

306 # Check for various functions. We must include pthread.h,

307 # since some functions may be macros. (On the Sequent, we

@@ -194,8 +312,18 @@ for flag in $ax_pthread_flags; do

312 # pthread_cleanup_push because it is one of the few pthread

313 # functions on Solaris that doesn't have a non-functional libc stub.

314 # We try pthread_create on general principles.

315 +

316 AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>

198 - static void routine(void *a) { a = 0; }

317 +# if $ax_pthread_check_cond

318 +# error "$ax_pthread_check_macro must be defined"

319 +# endif

320 + static void *some_global = NULL;

321 + static void routine(void *a)

322 + {

323 + /* To avoid any unused-parameter or

324 + unused-but-set-parameter warning. */

325 + some_global = a;

326 + }

327 static void *start_routine(void *a) { return a; }],

328 [pthread_t th; pthread_attr_t attr;

329 pthread_create(&th, 0, start_routine, 0);

@@ -203,101 +331,187 @@ for flag in $ax_pthread_flags; do

331 pthread_attr_init(&attr);

332 pthread_cleanup_push(routine, 0);

333 pthread_cleanup_pop(0) /* ; */])],

206 - [ax_pthread_ok=yes],

207 - [])

334 + [ax_pthread_ok=yes],

335 + [])

336

209 - LIBS="$save_LIBS"

210 - CFLAGS="$save_CFLAGS"

337 + CFLAGS="$ax_pthread_save_CFLAGS"

338 + LIBS="$ax_pthread_save_LIBS"

339

340 AC_MSG_RESULT([$ax_pthread_ok])

213 - if test "x$ax_pthread_ok" = xyes; then

214 - break;

215 - fi

341 + AS_IF([test "x$ax_pthread_ok" = "xyes"], [break])

342

343 PTHREAD_LIBS=""

344 PTHREAD_CFLAGS=""

345 done

346 fi

347

348 +

349 +# Clang needs special handling, because older versions handle the -pthread

350 +# option in a rather... idiosyncratic way

351 +

352 +if test "x$ax_pthread_clang" = "xyes"; then

353 +

354 + # Clang takes -pthread; it has never supported any other flag

355 +

356 + # (Note 1: This will need to be revisited if a system that Clang

357 + # supports has POSIX threads in a separate library. This tends not

358 + # to be the way of modern systems, but it's conceivable.)

359 +

360 + # (Note 2: On some systems, notably Darwin, -pthread is not needed

361 + # to get POSIX threads support; the API is always present and

362 + # active. We could reasonably leave PTHREAD_CFLAGS empty. But

363 + # -pthread does define _REENTRANT, and while the Darwin headers

364 + # ignore this macro, third-party headers might not.)

365 +

366 + # However, older versions of Clang make a point of warning the user

367 + # that, in an invocation where only linking and no compilation is

368 + # taking place, the -pthread option has no effect ("argument unused

369 + # during compilation"). They expect -pthread to be passed in only

370 + # when source code is being compiled.

371 + #

372 + # Problem is, this is at odds with the way Automake and most other

373 + # C build frameworks function, which is that the same flags used in

374 + # compilation (CFLAGS) are also used in linking. Many systems

375 + # supported by AX_PTHREAD require exactly this for POSIX threads

376 + # support, and in fact it is often not straightforward to specify a

377 + # flag that is used only in the compilation phase and not in

378 + # linking. Such a scenario is extremely rare in practice.

379 + #

380 + # Even though use of the -pthread flag in linking would only print

381 + # a warning, this can be a nuisance for well-run software projects

382 + # that build with -Werror. So if the active version of Clang has

383 + # this misfeature, we search for an option to squash it.

384 +

385 + AC_CACHE_CHECK([whether Clang needs flag to prevent "argument unused" warning when linking with -pthread],

386 + [ax_cv_PTHREAD_CLANG_NO_WARN_FLAG],

387 + [ax_cv_PTHREAD_CLANG_NO_WARN_FLAG=unknown

388 + # Create an alternate version of $ac_link that compiles and

389 + # links in two steps (.c -> .o, .o -> exe) instead of one

390 + # (.c -> exe), because the warning occurs only in the second

391 + # step

392 + ax_pthread_save_ac_link="$ac_link"

393 + ax_pthread_sed='s/conftest\.\$ac_ext/conftest.$ac_objext/g'

394 + ax_pthread_link_step=`AS_ECHO(["$ac_link"]) | sed "$ax_pthread_sed"`

395 + ax_pthread_2step_ac_link="($ac_compile) && (echo ==== >&5) && ($ax_pthread_link_step)"

396 + ax_pthread_save_CFLAGS="$CFLAGS"

397 + for ax_pthread_try in '' -Qunused-arguments -Wno-unused-command-line-argument unknown; do

398 + AS_IF([test "x$ax_pthread_try" = "xunknown"], [break])

399 + CFLAGS="-Werror -Wunknown-warning-option $ax_pthread_try -pthread $ax_pthread_save_CFLAGS"

400 + ac_link="$ax_pthread_save_ac_link"

401 + AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void){return 0;}]])],

402 + [ac_link="$ax_pthread_2step_ac_link"

403 + AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void){return 0;}]])],

404 + [break])

405 + ])

406 + done

407 + ac_link="$ax_pthread_save_ac_link"

408 + CFLAGS="$ax_pthread_save_CFLAGS"

409 + AS_IF([test "x$ax_pthread_try" = "x"], [ax_pthread_try=no])

410 + ax_cv_PTHREAD_CLANG_NO_WARN_FLAG="$ax_pthread_try"

411 + ])

412 +

413 + case "$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG" in

414 + no | unknown) ;;

415 + *) PTHREAD_CFLAGS="$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG $PTHREAD_CFLAGS" ;;

416 + esac

417 +

418 +fi # $ax_pthread_clang = yes

419 +

420 +

421 +

422 # Various other checks:

223 -if test "x$ax_pthread_ok" = xyes; then

224 - save_LIBS="$LIBS"

225 - LIBS="$PTHREAD_LIBS $LIBS"

226 - save_CFLAGS="$CFLAGS"

423 +if test "x$ax_pthread_ok" = "xyes"; then

424 + ax_pthread_save_CFLAGS="$CFLAGS"

425 + ax_pthread_save_LIBS="$LIBS"

426 CFLAGS="$CFLAGS $PTHREAD_CFLAGS"

427 + LIBS="$PTHREAD_LIBS $LIBS"

428

429 # Detect AIX lossage: JOINABLE attribute is called UNDETACHED.

230 - AC_MSG_CHECKING([for joinable pthread attribute])

231 - attr_name=unknown

232 - for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do

233 - AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>],

234 - [int attr = $attr; return attr /* ; */])],

235 - [attr_name=$attr; break],

236 - [])

237 - done

238 - AC_MSG_RESULT([$attr_name])

239 - if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then

240 - AC_DEFINE_UNQUOTED([PTHREAD_CREATE_JOINABLE], [$attr_name],

241 - [Define to necessary symbol if this constant

242 - uses a non-standard name on your system.])

243 - fi

244 -

245 - AC_MSG_CHECKING([if more special flags are required for pthreads])

246 - flag=no

247 - case ${host_os} in

248 - aix* | freebsd* | darwin*) flag="-D_THREAD_SAFE";;

249 - osf* | hpux*) flag="-D_REENTRANT";;

250 - solaris*)

251 - if test "$GCC" = "yes"; then

252 - flag="-D_REENTRANT"

253 - else

254 - # TODO: What about Clang on Solaris?

255 - flag="-mt -D_REENTRANT"

256 - fi

257 - ;;

258 - esac

259 - AC_MSG_RESULT([$flag])

260 - if test "x$flag" != xno; then

261 - PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"

262 - fi

430 + AC_CACHE_CHECK([for joinable pthread attribute],

431 + [ax_cv_PTHREAD_JOINABLE_ATTR],

432 + [ax_cv_PTHREAD_JOINABLE_ATTR=unknown

433 + for ax_pthread_attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do

434 + AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>],

435 + [int attr = $ax_pthread_attr; return attr /* ; */])],

436 + [ax_cv_PTHREAD_JOINABLE_ATTR=$ax_pthread_attr; break],

437 + [])

438 + done

439 + ])

440 + AS_IF([test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xunknown" && \

441 + test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xPTHREAD_CREATE_JOINABLE" && \

442 + test "x$ax_pthread_joinable_attr_defined" != "xyes"],

443 + [AC_DEFINE_UNQUOTED([PTHREAD_CREATE_JOINABLE],

444 + [$ax_cv_PTHREAD_JOINABLE_ATTR],

445 + [Define to necessary symbol if this constant

446 + uses a non-standard name on your system.])

447 + ax_pthread_joinable_attr_defined=yes

448 + ])

449 +

450 + AC_CACHE_CHECK([whether more special flags are required for pthreads],

451 + [ax_cv_PTHREAD_SPECIAL_FLAGS],

452 + [ax_cv_PTHREAD_SPECIAL_FLAGS=no

453 + case $host_os in

454 + solaris*)

455 + ax_cv_PTHREAD_SPECIAL_FLAGS="-D_POSIX_PTHREAD_SEMANTICS"

456 + ;;

457 + esac

458 + ])

459 + AS_IF([test "x$ax_cv_PTHREAD_SPECIAL_FLAGS" != "xno" && \

460 + test "x$ax_pthread_special_flags_added" != "xyes"],

461 + [PTHREAD_CFLAGS="$ax_cv_PTHREAD_SPECIAL_FLAGS $PTHREAD_CFLAGS"

462 + ax_pthread_special_flags_added=yes])

463

464 AC_CACHE_CHECK([for PTHREAD_PRIO_INHERIT],

265 - [ax_cv_PTHREAD_PRIO_INHERIT], [

266 - AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <pthread.h>]],

267 - [[int i = PTHREAD_PRIO_INHERIT;]])],

268 - [ax_cv_PTHREAD_PRIO_INHERIT=yes],

269 - [ax_cv_PTHREAD_PRIO_INHERIT=no])

465 + [ax_cv_PTHREAD_PRIO_INHERIT],

466 + [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <pthread.h>]],

467 + [[int i = PTHREAD_PRIO_INHERIT;

468 + return i;]])],

469 + [ax_cv_PTHREAD_PRIO_INHERIT=yes],

470 + [ax_cv_PTHREAD_PRIO_INHERIT=no])

471 ])

271 - AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes"],

272 - [AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], [1], [Have PTHREAD_PRIO_INHERIT.])])

472 + AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes" && \

473 + test "x$ax_pthread_prio_inherit_defined" != "xyes"],

474 + [AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], [1], [Have PTHREAD_PRIO_INHERIT.])

475 + ax_pthread_prio_inherit_defined=yes

476 + ])

477

274 - LIBS="$save_LIBS"

275 - CFLAGS="$save_CFLAGS"

478 + CFLAGS="$ax_pthread_save_CFLAGS"

479 + LIBS="$ax_pthread_save_LIBS"

480

481 # More AIX lossage: compile with *_r variant

278 - if test "x$GCC" != xyes; then

482 + if test "x$GCC" != "xyes"; then

483 case $host_os in

484 aix*)

485 AS_CASE(["x/$CC"],

282 - [x*/c89|x*/c89_128|x*/c99|x*/c99_128|x*/cc|x*/cc128|x*/xlc|x*/xlc_v6|x*/xlc128|x*/xlc128_v6],

283 - [#handle absolute path differently from PATH based program lookup

284 - AS_CASE(["x$CC"],

285 - [x/*],

286 - [AS_IF([AS_EXECUTABLE_P([${CC}_r])],[PTHREAD_CC="${CC}_r"])],

287 - [AC_CHECK_PROGS([PTHREAD_CC],[${CC}_r],[$CC])])])

486 + [x*/c89|x*/c89_128|x*/c99|x*/c99_128|x*/cc|x*/cc128|x*/xlc|x*/xlc_v6|x*/xlc128|x*/xlc128_v6],

487 + [#handle absolute path differently from PATH based program lookup

488 + AS_CASE(["x$CC"],

489 + [x/*],

490 + [

491 + AS_IF([AS_EXECUTABLE_P([${CC}_r])],[PTHREAD_CC="${CC}_r"])

492 + AS_IF([test "x${CXX}" != "x"], [AS_IF([AS_EXECUTABLE_P([${CXX}_r])],[PTHREAD_CXX="${CXX}_r"])])

493 + ],

494 + [

495 + AC_CHECK_PROGS([PTHREAD_CC],[${CC}_r],[$CC])

496 + AS_IF([test "x${CXX}" != "x"], [AC_CHECK_PROGS([PTHREAD_CXX],[${CXX}_r],[$CXX])])

497 + ]

498 + )

499 + ])

500 ;;

501 esac

502 fi

503 fi

504

505 test -n "$PTHREAD_CC" || PTHREAD_CC="$CC"

506 +test -n "$PTHREAD_CXX" || PTHREAD_CXX="$CXX"

507

508 AC_SUBST([PTHREAD_LIBS])

509 AC_SUBST([PTHREAD_CFLAGS])

510 AC_SUBST([PTHREAD_CC])

511 +AC_SUBST([PTHREAD_CXX])

512

513 # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:

300 -if test x"$ax_pthread_ok" = xyes; then

514 +if test "x$ax_pthread_ok" = "xyes"; then

515 ifelse([$1],,[AC_DEFINE([HAVE_PTHREAD],[1],[Define if you have POSIX threads libraries and header files.])],[$1])

516 :

517 else

Update build/m4/ax_pthread.m4 (#12390)