| blob | 69efc5bb10a4e74870846e15a3d1ce42e211802c |
1 # Macros to detect C compiler features
2 # config/c-compiler.m4
5 # PGAC_PRINTF_ARCHETYPE
6 # ---------------------
7 # Select the format archetype to be used by gcc to check printf-type functions.
8 # We prefer "gnu_printf", as that most closely matches the features supported
9 # by src/port/snprintf.c (particularly the %m conversion spec). However,
10 # on some NetBSD versions, that doesn't work while "__syslog__" does.
11 # If all else fails, use "printf".
12 AC_DEFUN([PGAC_PRINTF_ARCHETYPE],
13 [AC_CACHE_CHECK([for printf format archetype], pgac_cv_printf_archetype,
14 [pgac_cv_printf_archetype=gnu_printf
15 PGAC_TEST_PRINTF_ARCHETYPE
16 if [[ "$ac_archetype_ok" = no ]]; then
17 pgac_cv_printf_archetype=__syslog__
18 PGAC_TEST_PRINTF_ARCHETYPE
19 if [[ "$ac_archetype_ok" = no ]]; then
20 pgac_cv_printf_archetype=printf
21 fi
22 fi])
23 AC_DEFINE_UNQUOTED([PG_PRINTF_ATTRIBUTE], [$pgac_cv_printf_archetype],
24 [Define to best printf format archetype, usually gnu_printf if available.])
25 ])# PGAC_PRINTF_ARCHETYPE
27 # Subroutine: test $pgac_cv_printf_archetype, set $ac_archetype_ok to yes or no
28 AC_DEFUN([PGAC_TEST_PRINTF_ARCHETYPE],
29 [ac_save_c_werror_flag=$ac_c_werror_flag
30 ac_c_werror_flag=yes
31 AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
32 [extern void pgac_write(int ignore, const char *fmt,...)
33 __attribute__((format($pgac_cv_printf_archetype, 2, 3)));],
34 [pgac_write(0, "error %s: %m", "foo");])],
35 [ac_archetype_ok=yes],
36 [ac_archetype_ok=no])
37 ac_c_werror_flag=$ac_save_c_werror_flag
38 ])# PGAC_TEST_PRINTF_ARCHETYPE
41 # PGAC_TYPE_64BIT_INT(TYPE)
42 # -------------------------
43 # Check if TYPE is a working 64 bit integer type. Set HAVE_TYPE_64 to
44 # yes or no respectively, and define HAVE_TYPE_64 if yes.
45 AC_DEFUN([PGAC_TYPE_64BIT_INT],
46 [define([Ac_define], [translit([have_$1_64], [a-z *], [A-Z_P])])dnl
47 define([Ac_cachevar], [translit([pgac_cv_type_$1_64], [ *], [_p])])dnl
48 AC_CACHE_CHECK([whether $1 is 64 bits], [Ac_cachevar],
49 [AC_RUN_IFELSE([AC_LANG_SOURCE(
50 [typedef $1 ac_int64;
52 /*
53 * These are globals to discourage the compiler from folding all the
54 * arithmetic tests down to compile-time constants.
55 */
56 ac_int64 a = 20000001;
57 ac_int64 b = 40000005;
59 int does_int64_work()
60 {
61 ac_int64 c,d;
63 if (sizeof(ac_int64) != 8)
64 return 0; /* definitely not the right size */
66 /* Do perfunctory checks to see if 64-bit arithmetic seems to work */
67 c = a * b;
68 d = (c + b) / b;
69 if (d != a+1)
70 return 0;
71 return 1;
72 }
74 int
75 main() {
76 return (! does_int64_work());
77 }])],
78 [Ac_cachevar=yes],
79 [Ac_cachevar=no],
80 [# If cross-compiling, check the size reported by the compiler and
81 # trust that the arithmetic works.
82 AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([], [sizeof($1) == 8])],
83 Ac_cachevar=yes,
84 Ac_cachevar=no)])])
86 Ac_define=$Ac_cachevar
87 if test x"$Ac_cachevar" = xyes ; then
88 AC_DEFINE(Ac_define, 1, [Define to 1 if `]$1[' works and is 64 bits.])
89 fi
90 undefine([Ac_define])dnl
91 undefine([Ac_cachevar])dnl
92 ])# PGAC_TYPE_64BIT_INT
95 # PGAC_TYPE_128BIT_INT
96 # --------------------
97 # Check if __int128 is a working 128 bit integer type, and if so
98 # define PG_INT128_TYPE to that typename, and define ALIGNOF_PG_INT128_TYPE
99 # as its alignment requirement.
100 #
101 # This currently only detects a GCC/clang extension, but support for other
102 # environments may be added in the future.
103 #
104 # For the moment we only test for support for 128bit math; support for
105 # 128bit literals and snprintf is not required.
106 AC_DEFUN([PGAC_TYPE_128BIT_INT],
107 [AC_CACHE_CHECK([for __int128], [pgac_cv__128bit_int],
108 [AC_LINK_IFELSE([AC_LANG_PROGRAM([
109 /*
110 * We don't actually run this test, just link it to verify that any support
111 * functions needed for __int128 are present.
112 *
113 * These are globals to discourage the compiler from folding all the
114 * arithmetic tests down to compile-time constants. We do not have
115 * convenient support for 128bit literals at this point...
116 */
117 __int128 a = 48828125;
118 __int128 b = 97656250;
119 ],[
120 __int128 c,d;
121 a = (a << 12) + 1; /* 200000000001 */
122 b = (b << 12) + 5; /* 400000000005 */
123 /* try the most relevant arithmetic ops */
124 c = a * b;
125 d = (c + b) / b;
126 /* must use the results, else compiler may optimize arithmetic away */
127 if (d != a+1)
128 return 1;
129 ])],
130 [pgac_cv__128bit_int=yes],
131 [pgac_cv__128bit_int=no])])
132 if test x"$pgac_cv__128bit_int" = xyes ; then
133 # Use of non-default alignment with __int128 tickles bugs in some compilers.
134 # If not cross-compiling, we can test for bugs and disable use of __int128
135 # with buggy compilers. If cross-compiling, hope for the best.
136 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83925
137 AC_CACHE_CHECK([for __int128 alignment bug], [pgac_cv__128bit_int_bug],
138 [AC_RUN_IFELSE([AC_LANG_PROGRAM([
139 /* This must match the corresponding code in c.h: */
140 #if defined(__GNUC__) || defined(__SUNPRO_C) || defined(__IBMC__)
141 #define pg_attribute_aligned(a) __attribute__((aligned(a)))
142 #endif
143 typedef __int128 int128a
144 #if defined(pg_attribute_aligned)
145 pg_attribute_aligned(8)
146 #endif
147 ;
148 int128a holder;
149 void pass_by_val(void *buffer, int128a par) { holder = par; }
150 ],[
151 long int i64 = 97656225L << 12;
152 int128a q;
153 pass_by_val(main, (int128a) i64);
154 q = (int128a) i64;
155 if (q != holder)
156 return 1;
157 ])],
158 [pgac_cv__128bit_int_bug=ok],
159 [pgac_cv__128bit_int_bug=broken],
160 [pgac_cv__128bit_int_bug="assuming ok"])])
161 if test x"$pgac_cv__128bit_int_bug" != xbroken ; then
162 AC_DEFINE(PG_INT128_TYPE, __int128, [Define to the name of a signed 128-bit integer type.])
163 AC_CHECK_ALIGNOF(PG_INT128_TYPE)
164 fi
165 fi])# PGAC_TYPE_128BIT_INT
169 # PGAC_C_STATIC_ASSERT
170 # --------------------
171 # Check if the C compiler understands _Static_assert(),
172 # and define HAVE__STATIC_ASSERT if so.
173 #
174 # We actually check the syntax ({ _Static_assert(...) }), because we need
175 # gcc-style compound expressions to be able to wrap the thing into macros.
176 AC_DEFUN([PGAC_C_STATIC_ASSERT],
177 [AC_CACHE_CHECK(for _Static_assert, pgac_cv__static_assert,
178 [AC_LINK_IFELSE([AC_LANG_PROGRAM([],
179 [({ _Static_assert(1, "foo"); })])],
180 [pgac_cv__static_assert=yes],
181 [pgac_cv__static_assert=no])])
182 if test x"$pgac_cv__static_assert" = xyes ; then
183 AC_DEFINE(HAVE__STATIC_ASSERT, 1,
184 [Define to 1 if your compiler understands _Static_assert.])
185 fi])# PGAC_C_STATIC_ASSERT
189 # PGAC_C_TYPEOF
190 # -------------
191 # Check if the C compiler understands typeof or a variant. Define
192 # HAVE_TYPEOF if so, and define 'typeof' to the actual key word.
193 #
194 AC_DEFUN([PGAC_C_TYPEOF],
195 [AC_CACHE_CHECK(for typeof, pgac_cv_c_typeof,
196 [pgac_cv_c_typeof=no
197 for pgac_kw in typeof __typeof__ decltype; do
198 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
199 [int x = 0;
200 $pgac_kw(x) y;
201 y = x;
202 return y;])],
203 [pgac_cv_c_typeof=$pgac_kw])
204 test "$pgac_cv_c_typeof" != no && break
205 done])
206 if test "$pgac_cv_c_typeof" != no; then
207 AC_DEFINE(HAVE_TYPEOF, 1,
208 [Define to 1 if your compiler understands `typeof' or something similar.])
209 if test "$pgac_cv_c_typeof" != typeof; then
210 AC_DEFINE_UNQUOTED(typeof, $pgac_cv_c_typeof, [Define to how the compiler spells `typeof'.])
211 fi
212 fi])# PGAC_C_TYPEOF
216 # PGAC_C_TYPES_COMPATIBLE
217 # -----------------------
218 # Check if the C compiler understands __builtin_types_compatible_p,
219 # and define HAVE__BUILTIN_TYPES_COMPATIBLE_P if so.
220 #
221 # We check usage with __typeof__, though it's unlikely any compiler would
222 # have the former and not the latter.
223 AC_DEFUN([PGAC_C_TYPES_COMPATIBLE],
224 [AC_CACHE_CHECK(for __builtin_types_compatible_p, pgac_cv__types_compatible,
225 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
226 [[ int x; static int y[__builtin_types_compatible_p(__typeof__(x), int)]; ]])],
227 [pgac_cv__types_compatible=yes],
228 [pgac_cv__types_compatible=no])])
229 if test x"$pgac_cv__types_compatible" = xyes ; then
230 AC_DEFINE(HAVE__BUILTIN_TYPES_COMPATIBLE_P, 1,
231 [Define to 1 if your compiler understands __builtin_types_compatible_p.])
232 fi])# PGAC_C_TYPES_COMPATIBLE
235 # PGAC_C_BUILTIN_CONSTANT_P
236 # -------------------------
237 # Check if the C compiler understands __builtin_constant_p(),
238 # and define HAVE__BUILTIN_CONSTANT_P if so.
239 # We need __builtin_constant_p("string literal") to be true, but some older
240 # compilers don't think that, so test for that case explicitly.
241 AC_DEFUN([PGAC_C_BUILTIN_CONSTANT_P],
242 [AC_CACHE_CHECK(for __builtin_constant_p, pgac_cv__builtin_constant_p,
243 [AC_COMPILE_IFELSE([AC_LANG_SOURCE(
244 [[static int x;
245 static int y[__builtin_constant_p(x) ? x : 1];
246 static int z[__builtin_constant_p("string literal") ? 1 : x];
247 ]]
248 )],
249 [pgac_cv__builtin_constant_p=yes],
250 [pgac_cv__builtin_constant_p=no])])
251 if test x"$pgac_cv__builtin_constant_p" = xyes ; then
252 AC_DEFINE(HAVE__BUILTIN_CONSTANT_P, 1,
253 [Define to 1 if your compiler understands __builtin_constant_p.])
254 fi])# PGAC_C_BUILTIN_CONSTANT_P
258 # PGAC_C_BUILTIN_OP_OVERFLOW
259 # --------------------------
260 # Check if the C compiler understands __builtin_$op_overflow(),
261 # and define HAVE__BUILTIN_OP_OVERFLOW if so.
262 #
263 # Check for the most complicated case, 64 bit multiplication, as a
264 # proxy for all of the operations. To detect the case where the compiler
265 # knows the function but library support is missing, we must link not just
266 # compile, and store the results in global variables so the compiler doesn't
267 # optimize away the call.
268 AC_DEFUN([PGAC_C_BUILTIN_OP_OVERFLOW],
269 [AC_CACHE_CHECK(for __builtin_mul_overflow, pgac_cv__builtin_op_overflow,
270 [AC_LINK_IFELSE([AC_LANG_PROGRAM([
271 PG_INT64_TYPE a = 1;
272 PG_INT64_TYPE b = 1;
273 PG_INT64_TYPE result;
274 int oflo;
275 ],
276 [oflo = __builtin_mul_overflow(a, b, &result);])],
277 [pgac_cv__builtin_op_overflow=yes],
278 [pgac_cv__builtin_op_overflow=no])])
279 if test x"$pgac_cv__builtin_op_overflow" = xyes ; then
280 AC_DEFINE(HAVE__BUILTIN_OP_OVERFLOW, 1,
281 [Define to 1 if your compiler understands __builtin_$op_overflow.])
282 fi])# PGAC_C_BUILTIN_OP_OVERFLOW
286 # PGAC_C_BUILTIN_UNREACHABLE
287 # --------------------------
288 # Check if the C compiler understands __builtin_unreachable(),
289 # and define HAVE__BUILTIN_UNREACHABLE if so.
290 #
291 # NB: Don't get the idea of putting a for(;;); or such before the
292 # __builtin_unreachable() call. Some compilers would remove it before linking
293 # and only a warning instead of an error would be produced.
294 AC_DEFUN([PGAC_C_BUILTIN_UNREACHABLE],
295 [AC_CACHE_CHECK(for __builtin_unreachable, pgac_cv__builtin_unreachable,
296 [AC_LINK_IFELSE([AC_LANG_PROGRAM([],
297 [__builtin_unreachable();])],
298 [pgac_cv__builtin_unreachable=yes],
299 [pgac_cv__builtin_unreachable=no])])
300 if test x"$pgac_cv__builtin_unreachable" = xyes ; then
301 AC_DEFINE(HAVE__BUILTIN_UNREACHABLE, 1,
302 [Define to 1 if your compiler understands __builtin_unreachable.])
303 fi])# PGAC_C_BUILTIN_UNREACHABLE
307 # PGAC_C_COMPUTED_GOTO
308 # --------------------
309 # Check if the C compiler knows computed gotos (gcc extension, also
310 # available in at least clang). If so, define HAVE_COMPUTED_GOTO.
311 #
312 # Checking whether computed gotos are supported syntax-wise ought to
313 # be enough, as the syntax is otherwise illegal.
314 AC_DEFUN([PGAC_C_COMPUTED_GOTO],
315 [AC_CACHE_CHECK(for computed goto support, pgac_cv_computed_goto,
316 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
317 [[void *labeladdrs[] = {&&my_label};
318 goto *labeladdrs[0];
319 my_label:
320 return 1;
321 ]])],
322 [pgac_cv_computed_goto=yes],
323 [pgac_cv_computed_goto=no])])
324 if test x"$pgac_cv_computed_goto" = xyes ; then
325 AC_DEFINE(HAVE_COMPUTED_GOTO, 1,
326 [Define to 1 if your compiler handles computed gotos.])
327 fi])# PGAC_C_COMPUTED_GOTO
331 # PGAC_CHECK_BUILTIN_FUNC
332 # -----------------------
333 # This is similar to AC_CHECK_FUNCS(), except that it will work for compiler
334 # builtin functions, as that usually fails to.
335 # The first argument is the function name, eg [__builtin_clzl], and the
336 # second is its argument list, eg [unsigned long x]. The current coding
337 # works only for a single argument named x; we might generalize that later.
338 # It's assumed that the function's result type is coercible to int.
339 # On success, we define "HAVEfuncname" (there's usually more than enough
340 # underscores already, so we don't add another one).
341 AC_DEFUN([PGAC_CHECK_BUILTIN_FUNC],
342 [AC_CACHE_CHECK(for $1, pgac_cv$1,
343 [AC_LINK_IFELSE([AC_LANG_PROGRAM([
344 int
345 call$1($2)
346 {
347 return $1(x);
348 }], [])],
349 [pgac_cv$1=yes],
350 [pgac_cv$1=no])])
351 if test x"${pgac_cv$1}" = xyes ; then
352 AC_DEFINE_UNQUOTED(AS_TR_CPP([HAVE$1]), 1,
353 [Define to 1 if your compiler understands $1.])
354 fi])# PGAC_CHECK_BUILTIN_FUNC
358 # PGAC_CHECK_BUILTIN_FUNC_PTR
359 # -----------------------
360 # Like PGAC_CHECK_BUILTIN_FUNC, except that the function is assumed to
361 # return a pointer type, and the argument(s) should be given literally.
362 # This handles some cases that PGAC_CHECK_BUILTIN_FUNC doesn't.
363 AC_DEFUN([PGAC_CHECK_BUILTIN_FUNC_PTR],
364 [AC_CACHE_CHECK(for $1, pgac_cv$1,
365 [AC_LINK_IFELSE([AC_LANG_PROGRAM([
366 void *
367 call$1(void)
368 {
369 return $1($2);
370 }], [])],
371 [pgac_cv$1=yes],
372 [pgac_cv$1=no])])
373 if test x"${pgac_cv$1}" = xyes ; then
374 AC_DEFINE_UNQUOTED(AS_TR_CPP([HAVE$1]), 1,
375 [Define to 1 if your compiler understands $1.])
376 fi])# PGAC_CHECK_BUILTIN_FUNC_PTR
380 # PGAC_PROG_VARCC_VARFLAGS_OPT
381 # ----------------------------
382 # Given a compiler, variable name and a string, check if the compiler
383 # supports the string as a command-line option. If it does, add the
384 # string to the given variable.
385 AC_DEFUN([PGAC_PROG_VARCC_VARFLAGS_OPT],
386 [define([Ac_cachevar], [AS_TR_SH([pgac_cv_prog_$1_cflags_$3])])dnl
387 AC_CACHE_CHECK([whether ${$1} supports $3, for $2], [Ac_cachevar],
388 [pgac_save_CFLAGS=$CFLAGS
389 pgac_save_CC=$CC
390 CC=${$1}
391 CFLAGS="${$2} $3"
392 ac_save_c_werror_flag=$ac_c_werror_flag
393 ac_c_werror_flag=yes
394 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
395 [Ac_cachevar=yes],
396 [Ac_cachevar=no])
397 ac_c_werror_flag=$ac_save_c_werror_flag
398 CFLAGS="$pgac_save_CFLAGS"
399 CC="$pgac_save_CC"])
400 if test x"$Ac_cachevar" = x"yes"; then
401 $2="${$2} $3"
402 fi
403 undefine([Ac_cachevar])dnl
404 ])# PGAC_PROG_VARCC_VARFLAGS_OPT
408 # PGAC_PROG_CC_CFLAGS_OPT
409 # -----------------------
410 # Given a string, check if the compiler supports the string as a
411 # command-line option. If it does, add the string to CFLAGS.
412 AC_DEFUN([PGAC_PROG_CC_CFLAGS_OPT], [
413 PGAC_PROG_VARCC_VARFLAGS_OPT(CC, CFLAGS, $1)
414 ])# PGAC_PROG_CC_CFLAGS_OPT
418 # PGAC_PROG_CC_VAR_OPT
419 # --------------------
420 # Given a variable name and a string, check if the compiler supports
421 # the string as a command-line option. If it does, add the string to
422 # the given variable.
423 AC_DEFUN([PGAC_PROG_CC_VAR_OPT],
424 [PGAC_PROG_VARCC_VARFLAGS_OPT(CC, $1, $2)
425 ])# PGAC_PROG_CC_VAR_OPT
429 # PGAC_PROG_VARCXX_VARFLAGS_OPT
430 # -----------------------------
431 # Given a compiler, variable name and a string, check if the compiler
432 # supports the string as a command-line option. If it does, add the
433 # string to the given variable.
434 AC_DEFUN([PGAC_PROG_VARCXX_VARFLAGS_OPT],
435 [define([Ac_cachevar], [AS_TR_SH([pgac_cv_prog_$1_cxxflags_$3])])dnl
436 AC_CACHE_CHECK([whether ${$1} supports $3, for $2], [Ac_cachevar],
437 [pgac_save_CXXFLAGS=$CXXFLAGS
438 pgac_save_CXX=$CXX
439 CXX=${$1}
440 CXXFLAGS="${$2} $3"
441 ac_save_cxx_werror_flag=$ac_cxx_werror_flag
442 ac_cxx_werror_flag=yes
443 AC_LANG_PUSH(C++)
444 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
445 [Ac_cachevar=yes],
446 [Ac_cachevar=no])
447 AC_LANG_POP([])
448 ac_cxx_werror_flag=$ac_save_cxx_werror_flag
449 CXXFLAGS="$pgac_save_CXXFLAGS"
450 CXX="$pgac_save_CXX"])
451 if test x"$Ac_cachevar" = x"yes"; then
452 $2="${$2} $3"
453 fi
454 undefine([Ac_cachevar])dnl
455 ])# PGAC_PROG_VARCXX_VARFLAGS_OPT
459 # PGAC_PROG_CXX_CFLAGS_OPT
460 # ------------------------
461 # Given a string, check if the compiler supports the string as a
462 # command-line option. If it does, add the string to CXXFLAGS.
463 AC_DEFUN([PGAC_PROG_CXX_CFLAGS_OPT],
464 [PGAC_PROG_VARCXX_VARFLAGS_OPT(CXX, CXXFLAGS, $1)
465 ])# PGAC_PROG_CXX_CFLAGS_OPT
469 # PGAC_PROG_CC_LDFLAGS_OPT
470 # ------------------------
471 # Given a string, check if the compiler supports the string as a
472 # command-line option. If it does, add the string to LDFLAGS.
473 # For reasons you'd really rather not know about, this checks whether
474 # you can link to a particular function, not just whether you can link.
475 # In fact, we must actually check that the resulting program runs :-(
476 AC_DEFUN([PGAC_PROG_CC_LDFLAGS_OPT],
477 [define([Ac_cachevar], [AS_TR_SH([pgac_cv_prog_cc_ldflags_$1])])dnl
478 AC_CACHE_CHECK([whether $CC supports $1], [Ac_cachevar],
479 [pgac_save_LDFLAGS=$LDFLAGS
480 LDFLAGS="$pgac_save_LDFLAGS $1"
481 AC_RUN_IFELSE([AC_LANG_PROGRAM([extern void $2 (); void (*fptr) () = $2;],[])],
482 [Ac_cachevar=yes],
483 [Ac_cachevar=no],
484 [Ac_cachevar="assuming no"])
485 LDFLAGS="$pgac_save_LDFLAGS"])
486 if test x"$Ac_cachevar" = x"yes"; then
487 LDFLAGS="$LDFLAGS $1"
488 fi
489 undefine([Ac_cachevar])dnl
490 ])# PGAC_PROG_CC_LDFLAGS_OPT
492 # PGAC_HAVE_GCC__SYNC_CHAR_TAS
493 # ----------------------------
494 # Check if the C compiler understands __sync_lock_test_and_set(char),
495 # and define HAVE_GCC__SYNC_CHAR_TAS
496 #
497 # NB: There are platforms where test_and_set is available but compare_and_swap
498 # is not, so test this separately.
499 # NB: Some platforms only do 32bit tas, others only do 8bit tas. Test both.
500 AC_DEFUN([PGAC_HAVE_GCC__SYNC_CHAR_TAS],
501 [AC_CACHE_CHECK(for builtin __sync char locking functions, pgac_cv_gcc_sync_char_tas,
502 [AC_LINK_IFELSE([AC_LANG_PROGRAM([],
503 [char lock = 0;
504 __sync_lock_test_and_set(&lock, 1);
505 __sync_lock_release(&lock);])],
506 [pgac_cv_gcc_sync_char_tas="yes"],
507 [pgac_cv_gcc_sync_char_tas="no"])])
508 if test x"$pgac_cv_gcc_sync_char_tas" = x"yes"; then
509 AC_DEFINE(HAVE_GCC__SYNC_CHAR_TAS, 1, [Define to 1 if you have __sync_lock_test_and_set(char *) and friends.])
510 fi])# PGAC_HAVE_GCC__SYNC_CHAR_TAS
512 # PGAC_HAVE_GCC__SYNC_INT32_TAS
513 # -----------------------------
514 # Check if the C compiler understands __sync_lock_test_and_set(),
515 # and define HAVE_GCC__SYNC_INT32_TAS
516 AC_DEFUN([PGAC_HAVE_GCC__SYNC_INT32_TAS],
517 [AC_CACHE_CHECK(for builtin __sync int32 locking functions, pgac_cv_gcc_sync_int32_tas,
518 [AC_LINK_IFELSE([AC_LANG_PROGRAM([],
519 [int lock = 0;
520 __sync_lock_test_and_set(&lock, 1);
521 __sync_lock_release(&lock);])],
522 [pgac_cv_gcc_sync_int32_tas="yes"],
523 [pgac_cv_gcc_sync_int32_tas="no"])])
524 if test x"$pgac_cv_gcc_sync_int32_tas" = x"yes"; then
525 AC_DEFINE(HAVE_GCC__SYNC_INT32_TAS, 1, [Define to 1 if you have __sync_lock_test_and_set(int *) and friends.])
526 fi])# PGAC_HAVE_GCC__SYNC_INT32_TAS
528 # PGAC_HAVE_GCC__SYNC_INT32_CAS
529 # -----------------------------
530 # Check if the C compiler understands __sync_compare_and_swap() for 32bit
531 # types, and define HAVE_GCC__SYNC_INT32_CAS if so.
532 AC_DEFUN([PGAC_HAVE_GCC__SYNC_INT32_CAS],
533 [AC_CACHE_CHECK(for builtin __sync int32 atomic operations, pgac_cv_gcc_sync_int32_cas,
534 [AC_LINK_IFELSE([AC_LANG_PROGRAM([],
535 [int val = 0;
536 __sync_val_compare_and_swap(&val, 0, 37);])],
537 [pgac_cv_gcc_sync_int32_cas="yes"],
538 [pgac_cv_gcc_sync_int32_cas="no"])])
539 if test x"$pgac_cv_gcc_sync_int32_cas" = x"yes"; then
540 AC_DEFINE(HAVE_GCC__SYNC_INT32_CAS, 1, [Define to 1 if you have __sync_val_compare_and_swap(int *, int, int).])
541 fi])# PGAC_HAVE_GCC__SYNC_INT32_CAS
543 # PGAC_HAVE_GCC__SYNC_INT64_CAS
544 # -----------------------------
545 # Check if the C compiler understands __sync_compare_and_swap() for 64bit
546 # types, and define HAVE_GCC__SYNC_INT64_CAS if so.
547 AC_DEFUN([PGAC_HAVE_GCC__SYNC_INT64_CAS],
548 [AC_CACHE_CHECK(for builtin __sync int64 atomic operations, pgac_cv_gcc_sync_int64_cas,
549 [AC_LINK_IFELSE([AC_LANG_PROGRAM([],
550 [PG_INT64_TYPE lock = 0;
551 __sync_val_compare_and_swap(&lock, 0, (PG_INT64_TYPE) 37);])],
552 [pgac_cv_gcc_sync_int64_cas="yes"],
553 [pgac_cv_gcc_sync_int64_cas="no"])])
554 if test x"$pgac_cv_gcc_sync_int64_cas" = x"yes"; then
555 AC_DEFINE(HAVE_GCC__SYNC_INT64_CAS, 1, [Define to 1 if you have __sync_val_compare_and_swap(int64 *, int64, int64).])
556 fi])# PGAC_HAVE_GCC__SYNC_INT64_CAS
558 # PGAC_HAVE_GCC__ATOMIC_INT32_CAS
559 # -------------------------------
560 # Check if the C compiler understands __atomic_compare_exchange_n() for 32bit
561 # types, and define HAVE_GCC__ATOMIC_INT32_CAS if so.
562 AC_DEFUN([PGAC_HAVE_GCC__ATOMIC_INT32_CAS],
563 [AC_CACHE_CHECK(for builtin __atomic int32 atomic operations, pgac_cv_gcc_atomic_int32_cas,
564 [AC_LINK_IFELSE([AC_LANG_PROGRAM([],
565 [int val = 0;
566 int expect = 0;
567 __atomic_compare_exchange_n(&val, &expect, 37, 0, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED);])],
568 [pgac_cv_gcc_atomic_int32_cas="yes"],
569 [pgac_cv_gcc_atomic_int32_cas="no"])])
570 if test x"$pgac_cv_gcc_atomic_int32_cas" = x"yes"; then
571 AC_DEFINE(HAVE_GCC__ATOMIC_INT32_CAS, 1, [Define to 1 if you have __atomic_compare_exchange_n(int *, int *, int).])
572 fi])# PGAC_HAVE_GCC__ATOMIC_INT32_CAS
574 # PGAC_HAVE_GCC__ATOMIC_INT64_CAS
575 # -------------------------------
576 # Check if the C compiler understands __atomic_compare_exchange_n() for 64bit
577 # types, and define HAVE_GCC__ATOMIC_INT64_CAS if so.
578 AC_DEFUN([PGAC_HAVE_GCC__ATOMIC_INT64_CAS],
579 [AC_CACHE_CHECK(for builtin __atomic int64 atomic operations, pgac_cv_gcc_atomic_int64_cas,
580 [AC_LINK_IFELSE([AC_LANG_PROGRAM([],
581 [PG_INT64_TYPE val = 0;
582 PG_INT64_TYPE expect = 0;
583 __atomic_compare_exchange_n(&val, &expect, 37, 0, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED);])],
584 [pgac_cv_gcc_atomic_int64_cas="yes"],
585 [pgac_cv_gcc_atomic_int64_cas="no"])])
586 if test x"$pgac_cv_gcc_atomic_int64_cas" = x"yes"; then
587 AC_DEFINE(HAVE_GCC__ATOMIC_INT64_CAS, 1, [Define to 1 if you have __atomic_compare_exchange_n(int64 *, int64 *, int64).])
588 fi])# PGAC_HAVE_GCC__ATOMIC_INT64_CAS
590 # PGAC_SSE42_CRC32_INTRINSICS
591 # ---------------------------
592 # Check if the compiler supports the x86 CRC instructions added in SSE 4.2,
593 # using the _mm_crc32_u8 and _mm_crc32_u32 intrinsic functions. (We don't
594 # test the 8-byte variant, _mm_crc32_u64, but it is assumed to be present if
595 # the other ones are, on x86-64 platforms)
596 #
597 # An optional compiler flag can be passed as argument (e.g. -msse4.2). If the
598 # intrinsics are supported, sets pgac_sse42_crc32_intrinsics, and CFLAGS_SSE42.
599 AC_DEFUN([PGAC_SSE42_CRC32_INTRINSICS],
600 [define([Ac_cachevar], [AS_TR_SH([pgac_cv_sse42_crc32_intrinsics_$1])])dnl
601 AC_CACHE_CHECK([for _mm_crc32_u8 and _mm_crc32_u32 with CFLAGS=$1], [Ac_cachevar],
602 [pgac_save_CFLAGS=$CFLAGS
603 CFLAGS="$pgac_save_CFLAGS $1"
604 AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <nmmintrin.h>],
605 [unsigned int crc = 0;
606 crc = _mm_crc32_u8(crc, 0);
607 crc = _mm_crc32_u32(crc, 0);
608 /* return computed value, to prevent the above being optimized away */
609 return crc == 0;])],
610 [Ac_cachevar=yes],
611 [Ac_cachevar=no])
612 CFLAGS="$pgac_save_CFLAGS"])
613 if test x"$Ac_cachevar" = x"yes"; then
614 CFLAGS_SSE42="$1"
615 pgac_sse42_crc32_intrinsics=yes
616 fi
617 undefine([Ac_cachevar])dnl
618 ])# PGAC_SSE42_CRC32_INTRINSICS
621 # PGAC_ARMV8_CRC32C_INTRINSICS
622 # ----------------------------
623 # Check if the compiler supports the CRC32C instructions using the __crc32cb,
624 # __crc32ch, __crc32cw, and __crc32cd intrinsic functions. These instructions
625 # were first introduced in ARMv8 in the optional CRC Extension, and became
626 # mandatory in ARMv8.1.
627 #
628 # An optional compiler flag can be passed as argument (e.g.
629 # -march=armv8-a+crc). If the intrinsics are supported, sets
630 # pgac_armv8_crc32c_intrinsics, and CFLAGS_ARMV8_CRC32C.
631 AC_DEFUN([PGAC_ARMV8_CRC32C_INTRINSICS],
632 [define([Ac_cachevar], [AS_TR_SH([pgac_cv_armv8_crc32c_intrinsics_$1])])dnl
633 AC_CACHE_CHECK([for __crc32cb, __crc32ch, __crc32cw, and __crc32cd with CFLAGS=$1], [Ac_cachevar],
634 [pgac_save_CFLAGS=$CFLAGS
635 CFLAGS="$pgac_save_CFLAGS $1"
636 AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <arm_acle.h>],
637 [unsigned int crc = 0;
638 crc = __crc32cb(crc, 0);
639 crc = __crc32ch(crc, 0);
640 crc = __crc32cw(crc, 0);
641 crc = __crc32cd(crc, 0);
642 /* return computed value, to prevent the above being optimized away */
643 return crc == 0;])],
644 [Ac_cachevar=yes],
645 [Ac_cachevar=no])
646 CFLAGS="$pgac_save_CFLAGS"])
647 if test x"$Ac_cachevar" = x"yes"; then
648 CFLAGS_ARMV8_CRC32C="$1"
649 pgac_armv8_crc32c_intrinsics=yes
650 fi
651 undefine([Ac_cachevar])dnl
652 ])# PGAC_ARMV8_CRC32C_INTRINSICS