testsuite: add library dependencies for tests
[mpich.git] / confdb / aclocal_cc.m4
1 dnl AC_PROG_CC_GNU
2 ifdef([AC_PROG_CC_GNU],,[AC_DEFUN([AC_PROG_CC_GNU],)])
3
4 dnl PAC_PROG_CC - reprioritize the C compiler search order
5 AC_DEFUN([PAC_PROG_CC],[
6         dnl Many standard autoconf/automake/libtool macros, such as LT_INIT,
7         dnl perform an AC_REQUIRE([AC_PROG_CC]).  If this macro (PAC_PROG_CC)
8         dnl comes after LT_INIT (or similar) then the default compiler search
9         dnl path will be used instead.  This AC_BEFORE macro ensures that a
10         dnl warning will be emitted at autoconf-time (autogen.sh-time) to help
11         dnl developers notice this case.
12         AC_BEFORE([$0],[AC_PROG_CC])
13         PAC_PUSH_FLAG([CFLAGS])
14         AC_PROG_CC([icc pgcc xlc xlC pathcc gcc clang cc])
15         PAC_POP_FLAG([CFLAGS])
16 ])
17 dnl
18 dnl/*D
19 dnl PAC_C_CHECK_COMPILER_OPTION - Check that a compiler option is accepted
20 dnl without warning messages
21 dnl
22 dnl Synopsis:
23 dnl PAC_C_CHECK_COMPILER_OPTION(optionname,action-if-ok,action-if-fail)
24 dnl
25 dnl Output Effects:
26 dnl
27 dnl If no actions are specified, a working value is added to 'COPTIONS'
28 dnl
29 dnl Notes:
30 dnl This is now careful to check that the output is different, since 
31 dnl some compilers are noisy.
32 dnl 
33 dnl We are extra careful to prototype the functions in case compiler options
34 dnl that complain about poor code are in effect.
35 dnl
36 dnl Because this is a long script, we have ensured that you can pass a 
37 dnl variable containing the option name as the first argument.
38 dnl
39 dnl D*/
40 AC_DEFUN([PAC_C_CHECK_COMPILER_OPTION],[
41 AC_MSG_CHECKING([whether C compiler accepts option $1])
42 pac_opt="$1"
43 AC_LANG_PUSH([C])
44 CFLAGS_orig="$CFLAGS"
45 CFLAGS_opt="$pac_opt $CFLAGS"
46 pac_result="unknown"
47
48 AC_LANG_CONFTEST([
49         AC_LANG_PROGRAM([[#include <stdio.h>
50                           const char hw[] = "Hello, World\n";]],
51                 [[fputs (hw, stdout);]])
52 ])
53 CFLAGS="$CFLAGS_orig"
54 rm -f pac_test1.log
55 PAC_LINK_IFELSE_LOG([pac_test1.log], [], [
56     CFLAGS="$CFLAGS_opt"
57     rm -f pac_test2.log
58     PAC_LINK_IFELSE_LOG([pac_test2.log], [], [
59         PAC_RUNLOG_IFELSE([diff -b pac_test1.log pac_test2.log],
60                           [pac_result=yes],[pac_result=no])
61     ],[
62         pac_result=no
63     ])
64 ], [
65     pac_result=no
66 ])
67 AC_MSG_RESULT([$pac_result])
68 dnl Delete the conftest created by AC_LANG_CONFTEST.
69 rm -f conftest.$ac_ext
70
71 # gcc 4.2.4 on 32-bit does not complain about the -Wno-type-limits option 
72 # even though it doesn't support it.  However, when another warning is 
73 # triggered, it gives an error that the option is not recognized.  So we 
74 # need to test with a conftest file that will generate warnings.
75
76 # add an extra switch, pac_c_check_compiler_option_prototest, to
77 # disable this test just in case some new compiler does not like it.
78 #
79 # Linking with a program with an invalid prototype to ensure a compiler warning.
80
81 if test "$pac_result" = "yes" \
82      -a "$pac_c_check_compiler_option_prototest" != "no" ; then
83     AC_MSG_CHECKING([whether C compiler option $1 works with an invalid prototype program])
84     AC_LINK_IFELSE([
85         dnl We want a warning, but we don't want to inadvertently disable
86         dnl special warnings like -Werror-implicit-function-declaration (e.g.,
87         dnl in PAC_CC_STRICT) by compiling something that might actually be
88         dnl treated as an error by the compiler.  So we try to elicit an
89         dnl "unused variable" warning and/or an "uninitialized" warning with the
90         dnl test program below.
91         dnl
92         dnl The old sanity program was:
93         dnl   void main() {return 0;}
94         dnl which clang (but not GCC) would treat as an *error*, invalidating
95         dnl the test for any given parameter.
96         AC_LANG_SOURCE([int main(int argc, char **argv){ int foo, bar = 0; foo += 1; return foo; }])
97     ],[pac_result=yes],[pac_result=no])
98     AC_MSG_RESULT([$pac_result])
99 fi
100 #
101 if test "$pac_result" = "yes" ; then
102     AC_MSG_CHECKING([whether routines compiled with $pac_opt can be linked with ones compiled without $pac_opt])
103     pac_result=unknown
104     CFLAGS="$CFLAGS_orig"
105     rm -f pac_test3.log
106     PAC_COMPILE_IFELSE_LOG([pac_test3.log], [
107         AC_LANG_SOURCE([
108             int foo(void);
109             int foo(void){return 0;}
110         ])
111     ],[
112         PAC_RUNLOG([mv conftest.$OBJEXT pac_conftest.$OBJEXT])
113         saved_LIBS="$LIBS"
114         LIBS="pac_conftest.$OBJEXT $LIBS"
115
116         rm -f pac_test4.log
117         PAC_LINK_IFELSE_LOG([pac_test4.log], [AC_LANG_PROGRAM()], [
118             CFLAGS="$CFLAGS_opt"
119             rm -f pac_test5.log
120             PAC_LINK_IFELSE_LOG([pac_test5.log], [AC_LANG_PROGRAM()], [
121                 PAC_RUNLOG_IFELSE([diff -b pac_test4.log pac_test5.log],
122                                   [pac_result=yes], [pac_result=no])
123             ],[
124                 pac_result=no
125             ])
126         ],[
127             pac_result=no
128         ])
129         LIBS="$saved_LIBS"
130         rm -f pac_conftest.$OBJEXT
131     ],[
132         pac_result=no
133     ])
134     AC_MSG_RESULT([$pac_result])
135     rm -f pac_test3.log pac_test4.log pac_test5.log
136 fi
137 rm -f pac_test1.log pac_test2.log
138
139 dnl Restore CFLAGS before 2nd/3rd argument commands are executed,
140 dnl as 2nd/3rd argument command could be modifying CFLAGS.
141 CFLAGS="$CFLAGS_orig"
142 if test "$pac_result" = "yes" ; then
143      ifelse([$2],[],[COPTIONS="$COPTIONS $1"],[$2])
144 else
145      ifelse([$3],[],[:],[$3])
146 fi
147 AC_LANG_POP([C])
148 ])
149 dnl
150 dnl/*D
151 dnl PAC_C_OPTIMIZATION - Determine C options for producing optimized code
152 dnl
153 dnl Synopsis
154 dnl PAC_C_OPTIMIZATION([action if found])
155 dnl
156 dnl Output Effect:
157 dnl Adds options to 'COPTIONS' if no other action is specified
158 dnl 
159 dnl Notes:
160 dnl This is a temporary standin for compiler optimization.
161 dnl It should try to match known systems to known compilers (checking, of
162 dnl course), and then falling back to some common defaults.
163 dnl Note that many compilers will complain about -g and aggressive
164 dnl optimization.  
165 dnl D*/
166 AC_DEFUN([PAC_C_OPTIMIZATION],[
167     for copt in "-O4 -Ofast" "-Ofast" "-fast" "-O3" "-xO3" "-O" ; do
168         PAC_C_CHECK_COMPILER_OPTION($copt,found_opt=yes,found_opt=no)
169         if test "$found_opt" = "yes" ; then
170             ifelse($1,,COPTIONS="$COPTIONS $copt",$1)
171             break
172         fi
173     done
174     if test "$ac_cv_prog_gcc" = "yes" ; then
175         for copt in "-fomit-frame-pointer" "-finline-functions" \
176                  "-funroll-loops" ; do
177             PAC_C_CHECK_COMPILER_OPTION($copt,found_opt=yes,found_opt=no)
178             if test "$found_opt" = "yes" ; then
179                 ifelse($1,,COPTIONS="$COPTIONS $copt",$1)
180                 # no break because we're trying to add them all
181             fi
182         done
183         # We could also look for architecture-specific gcc options
184     fi
185
186 ])
187
188 dnl/*D
189 dnl PAC_PROG_C_UNALIGNED_DOUBLES - Check that the C compiler allows unaligned
190 dnl doubles
191 dnl
192 dnl Synopsis:
193 dnl   PAC_PROG_C_UNALIGNED_DOUBLES(action-if-true,action-if-false,
194 dnl       action-if-unknown)
195 dnl
196 dnl Notes:
197 dnl 'action-if-unknown' is used in the case of cross-compilation.
198 dnl D*/
199 AC_DEFUN([PAC_PROG_C_UNALIGNED_DOUBLES],[
200 AC_CACHE_CHECK([whether C compiler allows unaligned doubles],
201 pac_cv_prog_c_unaligned_doubles,[
202 AC_TRY_RUN([
203 void fetch_double( v )
204 double *v;
205 {
206 *v = 1.0;
207 }
208 int main( argc, argv )
209 int argc;
210 char **argv;
211 {
212 int p[4];
213 double *p_val;
214 fetch_double( (double *)&(p[0]) );
215 p_val = (double *)&(p[0]);
216 if (*p_val != 1.0) return 1;
217 fetch_double( (double *)&(p[1]) );
218 p_val = (double *)&(p[1]);
219 if (*p_val != 1.0) return 1;
220 return 0;
221 }
222 ],pac_cv_prog_c_unaligned_doubles="yes",pac_cv_prog_c_unaligned_doubles="no",
223 pac_cv_prog_c_unaligned_doubles="unknown")])
224 ifelse($1,,,if test "X$pac_cv_prog_c_unaligned_doubles" = "yes" ; then 
225 $1
226 fi)
227 ifelse($2,,,if test "X$pac_cv_prog_c_unaligned_doubles" = "no" ; then 
228 $2
229 fi)
230 ifelse($3,,,if test "X$pac_cv_prog_c_unaligned_doubles" = "unknown" ; then 
231 $3
232 fi)
233 ])
234
235 dnl/*D 
236 dnl PAC_PROG_C_WEAK_SYMBOLS - Test whether C supports weak alias symbols.
237 dnl
238 dnl Synopsis
239 dnl PAC_PROG_C_WEAK_SYMBOLS(action-if-true,action-if-false)
240 dnl
241 dnl Output Effect:
242 dnl Defines one of the following if a weak symbol pragma is found:
243 dnl.vb
244 dnl    HAVE_PRAGMA_WEAK - #pragma weak
245 dnl    HAVE_PRAGMA_HP_SEC_DEF - #pragma _HP_SECONDARY_DEF
246 dnl    HAVE_PRAGMA_CRI_DUP  - #pragma _CRI duplicate x as y
247 dnl.ve
248 dnl May also define
249 dnl.vb
250 dnl    HAVE_WEAK_ATTRIBUTE
251 dnl.ve
252 dnl if functions can be declared as 'int foo(...) __attribute__ ((weak));'
253 dnl sets the shell variable pac_cv_attr_weak to yes.
254 dnl Also checks for __attribute__((weak_import)) which is supported by
255 dnl Apple in Mac OSX (at least in Darwin).  Note that this provides only
256 dnl weak symbols, not weak aliases
257 dnl 
258 dnl D*/
259 AC_DEFUN([PAC_PROG_C_WEAK_SYMBOLS],[
260 pragma_extra_message=""
261 AC_CACHE_CHECK([for type of weak symbol alias support],
262 pac_cv_prog_c_weak_symbols,[
263 # Test for weak symbol support...
264 # We can't put # in the message because it causes autoconf to generate
265 # incorrect code
266 AC_TRY_LINK([
267 extern int PFoo(int);
268 #pragma weak PFoo = Foo
269 int Foo(int a) { return a; }
270 ],[return PFoo(1);],has_pragma_weak=yes)
271 #
272 # Some systems (Linux ia64 and ecc, for example), support weak symbols
273 # only within a single object file!  This tests that case.
274 # Note that there is an extern int PFoo declaration before the
275 # pragma.  Some compilers require this in order to make the weak symbol
276 # externally visible.  
277 if test "$has_pragma_weak" = yes ; then
278     PAC_COMPLINK_IFELSE([
279         AC_LANG_SOURCE([
280 extern int PFoo(int);
281 #pragma weak PFoo = Foo
282 int Foo(int);
283 int Foo(int a) { return a; }
284         ])
285     ],[
286         AC_LANG_SOURCE([
287 extern int PFoo(int);
288 int main(int argc, char **argv) {
289 return PFoo(0);}
290         ])
291     ],[
292         PAC_COMPLINK_IFELSE([
293             AC_LANG_SOURCE([
294 extern int PFoo(int);
295 #pragma weak PFoo = Foo
296 int Foo(int);
297 int Foo(int a) { return a; }
298             ])
299         ],[
300             AC_LANG_SOURCE([
301 extern int Foo(int);
302 int PFoo(int a) { return a+1;}
303 int main(int argc, char **argv) {
304 return Foo(0);}
305             ])
306         ],[
307             pac_cv_prog_c_weak_symbols="pragma weak"
308         ],[
309             has_pragma_weak=0
310             pragma_extra_message="pragma weak accepted but does not work (probably creates two non-weak entries)"
311         ])
312     ],[
313         has_pragma_weak=0
314         pragma_extra_message="pragma weak accepted but does not work (probably creates two non-weak entries)"
315     ])
316 fi
317 dnl
318 if test -z "$pac_cv_prog_c_weak_symbols" ; then 
319     AC_TRY_LINK([
320 extern int PFoo(int);
321 #pragma _HP_SECONDARY_DEF Foo  PFoo
322 int Foo(int a) { return a; }
323 ],[return PFoo(1);],pac_cv_prog_c_weak_symbols="pragma _HP_SECONDARY_DEF")
324 fi
325 dnl
326 if test -z "$pac_cv_prog_c_weak_symbols" ; then
327     AC_TRY_LINK([
328 extern int PFoo(int);
329 #pragma _CRI duplicate PFoo as Foo
330 int Foo(int a) { return a; }
331 ],[return PFoo(1);],pac_cv_prog_c_weak_symbols="pragma _CRI duplicate x as y")
332 fi
333 dnl
334 if test -z "$pac_cv_prog_c_weak_symbols" ; then
335     pac_cv_prog_c_weak_symbols="no"
336 fi
337 dnl
338 dnl If there is an extra explanatory message, echo it now so that it
339 dnl doesn't interfere with the cache result value
340 if test -n "$pragma_extra_message" ; then
341     echo $pragma_extra_message
342 fi
343 dnl
344 ])
345 if test "$pac_cv_prog_c_weak_symbols" != "no" ; then
346     case "$pac_cv_prog_c_weak_symbols" in
347         "pragma weak") AC_DEFINE(HAVE_PRAGMA_WEAK,1,[Supports weak pragma])
348         ;;
349         "pragma _HP")  AC_DEFINE(HAVE_PRAGMA_HP_SEC_DEF,1,[HP style weak pragma])
350         ;;
351         "pragma _CRI") AC_DEFINE(HAVE_PRAGMA_CRI_DUP,1,[Cray style weak pragma])
352         ;;
353     esac
354 fi
355 AC_CACHE_CHECK([whether __attribute__ ((weak)) allowed],
356 pac_cv_attr_weak,[
357 AC_TRY_COMPILE([int foo(int) __attribute__ ((weak));],[int a;],
358 pac_cv_attr_weak=yes,pac_cv_attr_weak=no)])
359 # Note that being able to compile with weak_import doesn't mean that
360 # it works.
361 AC_CACHE_CHECK([whether __attribute__ ((weak_import)) allowed],
362 pac_cv_attr_weak_import,[
363 AC_TRY_COMPILE([int foo(int) __attribute__ ((weak_import));],[int a;],
364 pac_cv_attr_weak_import=yes,pac_cv_attr_weak_import=no)])
365 # Check if the alias option for weak attributes is allowed
366 AC_CACHE_CHECK([whether __attribute__((weak,alias(...))) allowed],
367 pac_cv_attr_weak_alias,[
368 PAC_PUSH_FLAG([CFLAGS])
369 # force an error exit if the weak attribute isn't understood
370 CFLAGS=-Werror
371 AC_TRY_COMPILE([int __foo(int a){return 0;} int foo(int) __attribute__((weak,alias("__foo")));],[int a;],
372 pac_cv_attr_weak_alias=yes,pac_cv_attr_weak_alias=no)
373 # Restore original CFLAGS
374 PAC_POP_FLAG([CFLAGS])])
375 if test "$pac_cv_attr_weak_alias" = "yes" ; then
376     AC_DEFINE(HAVE_WEAK_ATTRIBUTE,1,[Attribute style weak pragma])
377 fi
378 if test "$pac_cv_prog_c_weak_symbols" = "no" -a "$pac_cv_attr_weak_alias" = "no" ; then
379     ifelse([$2],,:,[$2])
380 else
381     ifelse([$1],,:,[$1])
382 fi
383 ])
384
385 #
386 # This is a replacement that checks that FAILURES are signaled as well
387 # (later configure macros look for the .o file, not just success from the
388 # compiler, but they should not HAVE to
389 #
390 dnl --- insert 2.52 compatibility here ---
391 dnl 2.52 does not have AC_PROG_CC_WORKS
392 ifdef([AC_PROG_CC_WORKS],,[AC_DEFUN([AC_PROG_CC_WORKS],)])
393 dnl
394 AC_DEFUN([PAC_PROG_CC_WORKS],
395 [AC_PROG_CC_WORKS
396 AC_MSG_CHECKING([whether the C compiler sets its return status correctly])
397 AC_LANG_SAVE
398 AC_LANG_C
399 AC_TRY_COMPILE(,[int a = bzzzt;],notbroken=no,notbroken=yes)
400 AC_MSG_RESULT($notbroken)
401 if test "$notbroken" = "no" ; then
402     AC_MSG_ERROR([installation or configuration problem: C compiler does not
403 correctly set error code when a fatal error occurs])
404 fi
405 ])
406
407 dnl/*D 
408 dnl PAC_PROG_C_MULTIPLE_WEAK_SYMBOLS - Test whether C and the
409 dnl linker allow multiple weak symbols.
410 dnl
411 dnl Synopsis
412 dnl PAC_PROG_C_MULTIPLE_WEAK_SYMBOLS(action-if-true,action-if-false)
413 dnl
414 dnl 
415 dnl D*/
416 AC_DEFUN([PAC_PROG_C_MULTIPLE_WEAK_SYMBOLS],[
417 AC_CACHE_CHECK([for multiple weak symbol support],
418 pac_cv_prog_c_multiple_weak_symbols,[
419 # Test for multiple weak symbol support...
420 PAC_COMPLINK_IFELSE([
421     AC_LANG_SOURCE([
422 extern int PFoo(int);
423 extern int PFoo_(int);
424 extern int pfoo_(int);
425 #pragma weak PFoo = Foo
426 #pragma weak PFoo_ = Foo
427 #pragma weak pfoo_ = Foo
428 int Foo(int);
429 int Foo(a) { return a; }
430     ])
431 ],[
432     AC_LANG_SOURCE([
433 extern int PFoo(int), PFoo_(int), pfoo_(int);
434 int main() {
435 return PFoo(0) + PFoo_(1) + pfoo_(2);}
436     ])
437 ],[
438     pac_cv_prog_c_multiple_weak_symbols="yes"
439 ])
440 dnl
441 ])
442 if test "$pac_cv_prog_c_multiple_weak_symbols" = "yes" ; then
443     ifelse([$1],,:,[$1])
444 else
445     ifelse([$2],,:,[$2])
446 fi
447 ])
448
449 dnl Use the value of enable-strict to update CFLAGS
450 dnl pac_cc_strict_flags contains the strict flags.
451 dnl
452 dnl -std=c89 is used to select the C89 version of the ANSI/ISO C standard.
453 dnl As of this writing, many C compilers still accepted only this version,
454 dnl not the later C99 version. When all compilers accept C99, this 
455 dnl should be changed to the appropriate standard level.  Note that we've
456 dnl had trouble with gcc 2.95.3 accepting -std=c89 but then trying to 
457 dnl compile program with a invalid set of options 
458 dnl (-D __STRICT_ANSI__-trigraphs)
459 AC_DEFUN([PAC_CC_STRICT],[
460 export enable_strict_done
461 if test "$enable_strict_done" != "yes" ; then
462
463     # Some comments on strict warning options.
464     # These were added to reduce warnings:
465     #   -Wno-missing-field-initializers  -- We want to allow a struct to be 
466     #       initialized to zero using "struct x y = {0};" and not require 
467     #       each field to be initialized individually.
468     #   -Wno-unused-parameter -- For portability, some parameters go unused
469     #       when we have different implementations of functions for 
470     #       different platforms
471     #   -Wno-unused-label -- We add fn_exit: and fn_fail: on all functions, 
472     #       but fn_fail may not be used if the function doesn't return an 
473     #       error.
474     #   -Wno-sign-compare -- read() and write() return bytes read/written
475     #       as a signed value, but we often compare this to size_t (or
476     #       msg_sz_t) variables.
477     #   -Wno-format-zero-length -- this warning is irritating and useless, since
478     #                              a zero-length format string is very well defined
479     # These were removed to reduce warnings:
480     #   -Wcast-qual -- Sometimes we need to cast "volatile char*" to 
481     #       "char*", e.g., for memcpy.
482     #   -Wpadded -- We catch struct padding with asserts when we need to
483     #   -Wredundant-decls -- Having redundant declarations is benign and the 
484     #       code already has some.
485     #   -Waggregate-return -- This seems to be a performance-related warning
486     #       aggregate return values are legal in ANSI C, but they may be returned
487     #       in memory rather than through a register.  We do use aggregate return
488     #       values, but they are structs of a single basic type (used to enforce
489     #       type checking for relative vs. absolute ptrs), and with optimization
490     #       the aggregate value is converted to a scalar.
491     #   -Wdeclaration-after-statement -- This is a C89
492     #       requirement. When compiling with C99, this should be
493     #       disabled.
494     #   -Wfloat-equal -- There are places in hwloc that set a float var to 0, then 
495     #       compare it to 0 later to see if it was updated.  Also when using strtod()
496     #       one needs to compare the return value with 0 to see whether a conversion
497     #       was performed.
498     #   -Werror-implicit-function-declaration -- implicit function declarations
499     #       should never be tolerated.  This also ensures that we get quick
500     #       compilation failures rather than later link failures that usually
501     #       come from a function name typo.
502     #   -Wcast-align -- Casting alignment warnings.  This is an
503     #       important check, but is temporarily disabled, since it is
504     #       throwing too many (correct) warnings currently, causing us
505     #       to miss other warnings.
506     #   -Wshorten-64-to-32 -- Bad type-casting warnings.  This is an
507     #       important check, but is temporarily disabled, since it is
508     #       throwing too many (correct) warnings currently, causing us
509     #       to miss other warnings.
510     #
511     # This was removed because it masks important failures (see ticket #2094).
512     # However, since Intel compiler currently does not include -Wtype-limits
513     # in -Wextra, -Wtype-limits was added to handle warnings with the Intel
514     # compiler.
515     #   -Wno-type-limits -- There are places where we compare an unsigned to 
516     #       a constant that happens to be zero e.g., if x is unsigned and 
517     #       MIN_VAL is zero, we'd like to do "MPIU_Assert(x >= MIN_VAL);".
518     #       Note this option is not supported by gcc 4.2.  This needs to be added 
519     #       after most other warning flags, so that we catch a gcc bug on 32-bit 
520     #       that doesn't give a warning that this is unsupported, unless another
521     #       warning is triggered, and then if gives an error.
522     # the embedded newlines in this string are safe because we evaluate each
523     # argument in the for-loop below and append them to the CFLAGS with a space
524     # as the separator instead
525     pac_common_strict_flags="
526         -Wall
527         -Wextra
528         -Wno-missing-field-initializers
529         -Wstrict-prototypes
530         -Wmissing-prototypes
531         -DGCC_WALL
532         -Wno-unused-parameter
533         -Wno-unused-label
534         -Wshadow
535         -Wmissing-declarations
536         -Wno-long-long
537         -Wundef
538         -Wno-endif-labels
539         -Wpointer-arith
540         -Wbad-function-cast
541         -Wwrite-strings
542         -Wno-sign-compare
543         -Wold-style-definition
544         -Wno-multichar
545         -Wno-deprecated-declarations
546         -Wpacked
547         -Wnested-externs
548         -Winvalid-pch
549         -Wno-pointer-sign
550         -Wvariadic-macros
551         -Wno-format-zero-length
552         -Wtype-limits
553         -Werror-implicit-function-declaration
554     "
555
556     enable_c89=no
557     enable_c99=yes
558     enable_posix=2001
559     enable_opt=yes
560     flags="`echo $1 | sed -e 's/:/ /g' -e 's/,/ /g'`"
561     for flag in ${flags}; do
562         case "$flag" in
563              c89)
564                 enable_strict_done="yes"
565                 enable_c89=yes
566                 enable_c99=no
567                 ;;
568              c99)
569                 enable_strict_done="yes"
570                 enable_c89=no
571                 enable_c99=yes
572                 ;;
573              posix1995)
574                 enable_strict_done="yes"
575                 enable_posix=1995
576                 ;;
577              posix|posix2001)
578                 enable_strict_done="yes"
579                 enable_posix=2001
580                 ;;
581              posix2008)
582                 enable_strict_done="yes"
583                 enable_posix=2008
584                 ;;
585              noposix)
586                 enable_strict_done="yes"
587                 enable_posix=no
588                 ;;
589              opt)
590                 enable_strict_done="yes"
591                 enable_opt=yes
592                 ;;
593              noopt)
594                 enable_strict_done="yes"
595                 enable_opt=no
596                 ;;
597              all|yes)
598                 enable_strict_done="yes"
599                 enable_c99=yes
600                 enable_posix=2001
601                 enable_opt=yes
602                 ;;
603              no)
604                 # Accept and ignore this value
605                 :
606                 ;;
607              *)
608                 if test -n "$flag" ; then
609                    AC_MSG_WARN([Unrecognized value for enable-strict:$flag])
610                 fi
611                 ;;
612         esac
613     done
614
615     pac_cc_strict_flags=""
616     if test "${enable_strict_done}" = "yes" ; then
617        if test "${enable_opt}" = "yes" ; then
618           pac_cc_strict_flags="-O2"
619        fi
620        pac_cc_strict_flags="$pac_cc_strict_flags $pac_common_strict_flags"
621        case "$enable_posix" in
622             no)   : ;;
623             1995) PAC_APPEND_FLAG([-D_POSIX_C_SOURCE=199506L],[pac_cc_strict_flags]) ;;
624             2001) PAC_APPEND_FLAG([-D_POSIX_C_SOURCE=200112L],[pac_cc_strict_flags]) ;;
625             2008) PAC_APPEND_FLAG([-D_POSIX_C_SOURCE=200809L],[pac_cc_strict_flags]) ;;
626             *)    AC_MSG_ERROR([internal error, unexpected POSIX version: '$enable_posix']) ;;
627        esac
628        # We only allow one of strict-C99 or strict-C89 to be
629        # enabled. If C99 is enabled, we automatically disable C89.
630        if test "${enable_c99}" = "yes" ; then
631           PAC_APPEND_FLAG([-std=c99],[pac_cc_strict_flags])
632           # Use -D_STDC_C99= for Solaris compilers. See
633           # http://lists.gnu.org/archive/html/autoconf/2010-12/msg00059.html
634           # for discussion on why not to use -xc99
635           PAC_APPEND_FLAG([-D_STDC_C99=],[pac_cc_strict_flags])
636        elif test "${enable_c89}" = "yes" ; then
637           PAC_APPEND_FLAG([-std=c89],[pac_cc_strict_flags])
638           PAC_APPEND_FLAG([-Wdeclaration-after-statement],[pac_cc_strict_flags])
639        fi
640     fi
641
642     # See if the above options work with the compiler
643     accepted_flags=""
644     for flag in $pac_cc_strict_flags ; do
645         PAC_PUSH_FLAG([CFLAGS])
646         CFLAGS="$CFLAGS $accepted_flags"
647         PAC_C_CHECK_COMPILER_OPTION([$flag],[accepted_flags="$accepted_flags $flag"],)
648         PAC_POP_FLAG([CFLAGS])
649     done
650     pac_cc_strict_flags=$accepted_flags
651 fi
652 ])
653
654 dnl/*D
655 dnl PAC_ARG_STRICT - Add --enable-strict to configure.  
656 dnl
657 dnl Synopsis:
658 dnl PAC_ARG_STRICT
659 dnl 
660 dnl Output effects:
661 dnl Adds '--enable-strict' to the command line.
662 dnl
663 dnl D*/
664 AC_DEFUN([PAC_ARG_STRICT],[
665 AC_ARG_ENABLE(strict,
666         AC_HELP_STRING([--enable-strict], [Turn on strict compilation testing]))
667 PAC_CC_STRICT($enable_strict)
668 CFLAGS="$CFLAGS $pac_cc_strict_flags"
669 export CFLAGS
670 ])
671
672 dnl Return the integer structure alignment in pac_cv_c_max_integer_align
673 dnl Possible values include
674 dnl     packed
675 dnl     two
676 dnl     four
677 dnl     eight
678 dnl
679 dnl In addition, a "Could not determine alignment" and a "error!"
680 dnl return is possible.  
681 AC_DEFUN([PAC_C_MAX_INTEGER_ALIGN],[
682 AC_CACHE_CHECK([for max C struct integer alignment],
683 pac_cv_c_max_integer_align,[
684 AC_TRY_RUN([
685 #include <stdio.h>
686 #define DBG(a,b,c)
687 int main( int argc, char *argv[] )
688 {
689     FILE *cf;
690     int is_packed  = 1;
691     int is_two     = 1;
692     int is_four    = 1;
693     int is_eight   = 1;
694     struct { char a; int b; } char_int;
695     struct { char a; short b; } char_short;
696     struct { char a; long b; } char_long;
697     struct { char a; int b; char c; } char_int_char;
698     struct { char a; short b; char c; } char_short_char;
699 #ifdef HAVE_LONG_LONG_INT
700     struct { long long int a; char b; } lli_c;
701     struct { char a; long long int b; } c_lli;
702 #endif
703     int size, extent, extent2;
704
705     /* assume max integer alignment isn't 8 if we don't have
706      * an eight-byte value :)
707      */
708 #ifdef HAVE_LONG_LONG_INT
709     if (sizeof(int) < 8 && sizeof(long) < 8 && sizeof(long long int) < 8)
710         is_eight = 0;
711 #else
712     if (sizeof(int) < 8 && sizeof(long) < 8) is_eight = 0;
713 #endif
714
715     size = sizeof(char) + sizeof(int);
716     extent = sizeof(char_int);
717     if (size != extent) is_packed = 0;
718     if ( (extent % 2) != 0) is_two = 0;
719     if ( (extent % 4) != 0) is_four = 0;
720     if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
721     DBG("char_int",size,extent);
722
723     size = sizeof(char) + sizeof(short);
724     extent = sizeof(char_short);
725     if (size != extent) is_packed = 0;
726     if ( (extent % 2) != 0) is_two = 0;
727     if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;
728     if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;
729     DBG("char_short",size,extent);
730
731     size = sizeof(char) + sizeof(long);
732     extent = sizeof(char_long);
733     if (size != extent) is_packed = 0;
734     if ( (extent % 2) != 0) is_two = 0;
735     if ( (extent % 4) != 0) is_four = 0;
736     if (sizeof(long) == 8 && (extent % 8) != 0) is_eight = 0;
737     DBG("char_long",size,extent);
738
739 #ifdef HAVE_LONG_LONG_INT
740     size = sizeof(char) + sizeof(long long int);
741     extent = sizeof(lli_c);
742     extent2 = sizeof(c_lli);
743     if (size != extent) is_packed = 0;
744     if ( (extent % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
745     if ( (extent % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
746     if (sizeof(long long int) >= 8 && (extent % 8) != 0 && (extent2 % 8) != 0)
747         is_eight = 0;
748 #endif
749
750     size = sizeof(char) + sizeof(int) + sizeof(char);
751     extent = sizeof(char_int_char);
752     if (size != extent) is_packed = 0;
753     if ( (extent % 2) != 0) is_two = 0;
754     if ( (extent % 4) != 0) is_four = 0;
755     if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
756     DBG("char_int_char",size,extent);
757
758     size = sizeof(char) + sizeof(short) + sizeof(char);
759     extent = sizeof(char_short_char);
760     if (size != extent) is_packed = 0;
761     if ( (extent % 2) != 0) is_two = 0;
762     if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;
763     if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;
764     DBG("char_short_char",size,extent);
765
766     /* If aligned mod 8, it will be aligned mod 4 */
767     if (is_eight) { is_four = 0; is_two = 0; }
768
769     if (is_four) is_two = 0;
770
771     /* Tabulate the results */
772     cf = fopen( "ctest.out", "w" );
773     if (is_packed + is_two + is_four + is_eight == 0) {
774         fprintf( cf, "Could not determine alignment\n" );
775     }
776     else {
777         if (is_packed + is_two + is_four + is_eight != 1) {
778             fprintf( cf, "error!\n" );
779         }
780         else {
781             if (is_packed) fprintf( cf, "packed\n" );
782             if (is_two) fprintf( cf, "two\n" );
783             if (is_four) fprintf( cf, "four\n" );
784             if (is_eight) fprintf( cf, "eight\n" );
785         }
786     }
787     fclose( cf );
788     return 0;
789 }],
790 pac_cv_c_max_integer_align=`cat ctest.out`,
791 pac_cv_c_max_integer_align="unknown",
792 pac_cv_c_max_integer_align="$CROSS_ALIGN_STRUCT_INT")
793 rm -f ctest.out
794 ])
795 if test -z "$pac_cv_c_max_integer_align" ; then
796     pac_cv_c_max_integer_align="unknown"
797 fi
798 ])
799
800 dnl Return the floating point structure alignment in
801 dnl pac_cv_c_max_fp_align.
802 dnl
803 dnl Possible values include:
804 dnl     packed
805 dnl     two
806 dnl     four
807 dnl     eight
808 dnl     sixteen
809 dnl
810 dnl In addition, a "Could not determine alignment" and a "error!"
811 dnl return is possible.  
812 AC_DEFUN([PAC_C_MAX_FP_ALIGN],[
813 AC_CACHE_CHECK([for max C struct floating point alignment],
814 pac_cv_c_max_fp_align,[
815 AC_TRY_RUN([
816 #include <stdio.h>
817 #define DBG(a,b,c)
818 int main( int argc, char *argv[] )
819 {
820     FILE *cf;
821     int is_packed  = 1;
822     int is_two     = 1;
823     int is_four    = 1;
824     int is_eight   = 1;
825     int is_sixteen = 1;
826     struct { char a; float b; } char_float;
827     struct { float b; char a; } float_char;
828     struct { char a; double b; } char_double;
829     struct { double b; char a; } double_char;
830 #ifdef HAVE_LONG_DOUBLE
831     struct { char a; long double b; } char_long_double;
832     struct { long double b; char a; } long_double_char;
833     struct { long double a; int b; char c; } long_double_int_char;
834 #endif
835     int size, extent1, extent2;
836
837     size = sizeof(char) + sizeof(float);
838     extent1 = sizeof(char_float);
839     extent2 = sizeof(float_char);
840     if (size != extent1) is_packed = 0;
841     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
842     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
843     if (sizeof(float) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
844         is_eight = 0;
845     DBG("char_float",size,extent1);
846
847     size = sizeof(char) + sizeof(double);
848     extent1 = sizeof(char_double);
849     extent2 = sizeof(double_char);
850     if (size != extent1) is_packed = 0;
851     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
852     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
853     if (sizeof(double) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
854         is_eight = 0;
855     DBG("char_double",size,extent1);
856
857 #ifdef HAVE_LONG_DOUBLE
858     size = sizeof(char) + sizeof(long double);
859     extent1 = sizeof(char_long_double);
860     extent2 = sizeof(long_double_char);
861     if (size != extent1) is_packed = 0;
862     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
863     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
864     if (sizeof(long double) >= 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
865         is_eight = 0;
866     if (sizeof(long double) > 8 && (extent1 % 16) != 0
867         && (extent2 % 16) != 0) is_sixteen = 0;
868     DBG("char_long-double",size,extent1);
869
870     extent1 = sizeof(long_double_int_char);
871     if ( (extent1 % 2) != 0) is_two = 0;
872     if ( (extent1 % 4) != 0) is_four = 0;
873     if (sizeof(long double) >= 8 && (extent1 % 8) != 0) is_eight = 0;
874     if (sizeof(long double) > 8 && (extent1 % 16) != 0) is_sixteen = 0;
875 #else
876     is_sixteen = 0;
877 #endif
878
879     if (is_sixteen) { is_eight = 0; is_four = 0; is_two = 0; }
880
881     if (is_eight) { is_four = 0; is_two = 0; }
882
883     if (is_four) is_two = 0;
884
885     /* Tabulate the results */
886     cf = fopen( "ctest.out", "w" );
887     if (is_packed + is_two + is_four + is_eight + is_sixteen == 0) {
888         fprintf( cf, "Could not determine alignment\n" );
889     }
890     else {
891         if (is_packed + is_two + is_four + is_eight + is_sixteen != 1) {
892             fprintf( cf, "error!\n" );
893         }
894         else {
895             if (is_packed) fprintf( cf, "packed\n" );
896             if (is_two) fprintf( cf, "two\n" );
897             if (is_four) fprintf( cf, "four\n" );
898             if (is_eight) fprintf( cf, "eight\n" );
899             if (is_sixteen) fprintf( cf, "sixteen\n" );
900         }
901     }
902     fclose( cf );
903     return 0;
904 }],
905 pac_cv_c_max_fp_align=`cat ctest.out`,
906 pac_cv_c_max_fp_align="unknown",
907 pac_cv_c_max_fp_align="$CROSS_ALIGN_STRUCT_FP")
908 rm -f ctest.out
909 ])
910 if test -z "$pac_cv_c_max_fp_align" ; then
911     pac_cv_c_max_fp_align="unknown"
912 fi
913 ])
914
915 dnl Return the floating point structure alignment in
916 dnl pac_cv_c_max_double_fp_align.
917 dnl
918 dnl Possible values include:
919 dnl     packed
920 dnl     two
921 dnl     four
922 dnl     eight
923 dnl
924 dnl In addition, a "Could not determine alignment" and a "error!"
925 dnl return is possible.  
926 AC_DEFUN([PAC_C_MAX_DOUBLE_FP_ALIGN],[
927 AC_CACHE_CHECK([for max C struct alignment of structs with doubles],
928 pac_cv_c_max_double_fp_align,[
929 AC_TRY_RUN([
930 #include <stdio.h>
931 #define DBG(a,b,c)
932 int main( int argc, char *argv[] )
933 {
934     FILE *cf;
935     int is_packed  = 1;
936     int is_two     = 1;
937     int is_four    = 1;
938     int is_eight   = 1;
939     struct { char a; float b; } char_float;
940     struct { float b; char a; } float_char;
941     struct { char a; double b; } char_double;
942     struct { double b; char a; } double_char;
943     int size, extent1, extent2;
944
945     size = sizeof(char) + sizeof(float);
946     extent1 = sizeof(char_float);
947     extent2 = sizeof(float_char);
948     if (size != extent1) is_packed = 0;
949     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
950     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
951     if (sizeof(float) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
952         is_eight = 0;
953     DBG("char_float",size,extent1);
954
955     size = sizeof(char) + sizeof(double);
956     extent1 = sizeof(char_double);
957     extent2 = sizeof(double_char);
958     if (size != extent1) is_packed = 0;
959     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
960     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
961     if (sizeof(double) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
962         is_eight = 0;
963     DBG("char_double",size,extent1);
964
965     if (is_eight) { is_four = 0; is_two = 0; }
966
967     if (is_four) is_two = 0;
968
969     /* Tabulate the results */
970     cf = fopen( "ctest.out", "w" );
971     if (is_packed + is_two + is_four + is_eight == 0) {
972         fprintf( cf, "Could not determine alignment\n" );
973     }
974     else {
975         if (is_packed + is_two + is_four + is_eight != 1) {
976             fprintf( cf, "error!\n" );
977         }
978         else {
979             if (is_packed) fprintf( cf, "packed\n" );
980             if (is_two) fprintf( cf, "two\n" );
981             if (is_four) fprintf( cf, "four\n" );
982             if (is_eight) fprintf( cf, "eight\n" );
983         }
984     }
985     fclose( cf );
986     return 0;
987 }],
988 pac_cv_c_max_double_fp_align=`cat ctest.out`,
989 pac_cv_c_max_double_fp_align="unknown",
990 pac_cv_c_max_double_fp_align="$CROSS_ALIGN_STRUCT_DOUBLE_FP")
991 rm -f ctest.out
992 ])
993 if test -z "$pac_cv_c_max_double_fp_align" ; then
994     pac_cv_c_max_double_fp_align="unknown"
995 fi
996 ])
997 AC_DEFUN([PAC_C_MAX_LONGDOUBLE_FP_ALIGN],[
998 AC_CACHE_CHECK([for max C struct floating point alignment with long doubles],
999 pac_cv_c_max_longdouble_fp_align,[
1000 AC_TRY_RUN([
1001 #include <stdio.h>
1002 #define DBG(a,b,c)
1003 int main( int argc, char *argv[] )
1004 {
1005     FILE *cf;
1006     int is_packed  = 1;
1007     int is_two     = 1;
1008     int is_four    = 1;
1009     int is_eight   = 1;
1010     int is_sixteen = 1;
1011     struct { char a; long double b; } char_long_double;
1012     struct { long double b; char a; } long_double_char;
1013     struct { long double a; int b; char c; } long_double_int_char;
1014     int size, extent1, extent2;
1015
1016     size = sizeof(char) + sizeof(long double);
1017     extent1 = sizeof(char_long_double);
1018     extent2 = sizeof(long_double_char);
1019     if (size != extent1) is_packed = 0;
1020     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
1021     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
1022     if (sizeof(long double) >= 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
1023         is_eight = 0;
1024     if (sizeof(long double) > 8 && (extent1 % 16) != 0
1025         && (extent2 % 16) != 0) is_sixteen = 0;
1026     DBG("char_long-double",size,extent1);
1027
1028     extent1 = sizeof(long_double_int_char);
1029     if ( (extent1 % 2) != 0) is_two = 0;
1030     if ( (extent1 % 4) != 0) is_four = 0;
1031     if (sizeof(long double) >= 8 && (extent1 % 8) != 0) is_eight = 0;
1032     if (sizeof(long double) > 8 && (extent1 % 16) != 0) is_sixteen = 0;
1033
1034     if (is_sixteen) { is_eight = 0; is_four = 0; is_two = 0; }
1035
1036     if (is_eight) { is_four = 0; is_two = 0; }
1037
1038     if (is_four) is_two = 0;
1039
1040     /* Tabulate the results */
1041     cf = fopen( "ctest.out", "w" );
1042     if (is_packed + is_two + is_four + is_eight + is_sixteen == 0) {
1043         fprintf( cf, "Could not determine alignment\n" );
1044     }
1045     else {
1046         if (is_packed + is_two + is_four + is_eight + is_sixteen != 1) {
1047             fprintf( cf, "error!\n" );
1048         }
1049         else {
1050             if (is_packed) fprintf( cf, "packed\n" );
1051             if (is_two) fprintf( cf, "two\n" );
1052             if (is_four) fprintf( cf, "four\n" );
1053             if (is_eight) fprintf( cf, "eight\n" );
1054             if (is_sixteen) fprintf( cf, "sixteen\n" );
1055         }
1056     }
1057     fclose( cf );
1058     return 0;
1059 }],
1060 pac_cv_c_max_longdouble_fp_align=`cat ctest.out`,
1061 pac_cv_c_max_longdouble_fp_align="unknown",
1062 pac_cv_c_max_longdouble_fp_align="$CROSS_ALIGN_STRUCT_LONGDOUBLE_FP")
1063 rm -f ctest.out
1064 ])
1065 if test -z "$pac_cv_c_max_longdouble_fp_align" ; then
1066     pac_cv_c_max_longdouble_fp_align="unknown"
1067 fi
1068 ])
1069
1070 dnl Other tests assume that there is potentially a maximum alignment
1071 dnl and that if there is no maximum alignment, or a type is smaller than
1072 dnl that value, then we align on the size of the value, with the exception
1073 dnl of the "position-based alignment" rules we test for separately.
1074 dnl
1075 dnl It turns out that these assumptions have fallen short in at least one
1076 dnl case, on MacBook Pros, where doubles are aligned on 4-byte boundaries
1077 dnl even when long doubles are aligned on 16-byte boundaries. So this test
1078 dnl is here specifically to handle this case.
1079 dnl
1080 dnl Puts result in pac_cv_c_double_alignment_exception.
1081 dnl
1082 dnl Possible values currently include no and four.
1083 dnl
1084 AC_DEFUN([PAC_C_DOUBLE_ALIGNMENT_EXCEPTION],[
1085 AC_CACHE_CHECK([if double alignment breaks rules, find actual alignment],
1086 pac_cv_c_double_alignment_exception,[
1087 AC_TRY_RUN([
1088 #include <stdio.h>
1089 #define DBG(a,b,c)
1090 int main( int argc, char *argv[] )
1091 {
1092     FILE *cf;
1093     struct { char a; double b; } char_double;
1094     struct { double b; char a; } double_char;
1095     int extent1, extent2, align_4 = 0;
1096
1097     extent1 = sizeof(char_double);
1098     extent2 = sizeof(double_char);
1099
1100     /* we're interested in the largest value, will let separate test
1101      * deal with position-based issues.
1102      */
1103     if (extent1 < extent2) extent1 = extent2;
1104     if ((sizeof(double) == 8) && (extent1 % 8) != 0) {
1105        if (extent1 % 4 == 0) {
1106 #ifdef HAVE_MAX_FP_ALIGNMENT
1107           if (HAVE_MAX_FP_ALIGNMENT >= 8) align_4 = 1;
1108 #else
1109           align_4 = 1;
1110 #endif
1111        }
1112     }
1113
1114     cf = fopen( "ctest.out", "w" );
1115
1116     if (align_4) fprintf( cf, "four\n" );
1117     else fprintf( cf, "no\n" );
1118
1119     fclose( cf );
1120     return 0;
1121 }],
1122 pac_cv_c_double_alignment_exception=`cat ctest.out`,
1123 pac_cv_c_double_alignment_exception="unknown",
1124 pac_cv_c_double_alignment_exception="$CROSS_ALIGN_DOUBLE_EXCEPTION")
1125 rm -f ctest.out
1126 ])
1127 if test -z "$pac_cv_c_double_alignment_exception" ; then
1128     pac_cv_c_double_alignment_exception="unknown"
1129 fi
1130 ])
1131
1132 dnl Test for odd struct alignment rule that only applies max.
1133 dnl padding when double value is at front of type.
1134 dnl Puts result in pac_cv_c_double_pos_align.
1135 dnl
1136 dnl Search for "Power alignment mode" for more details.
1137 dnl
1138 dnl Possible values include yes, no, and unknown.
1139 dnl
1140 AC_DEFUN([PAC_C_DOUBLE_POS_ALIGN],[
1141 AC_CACHE_CHECK([if alignment of structs with doubles is based on position],
1142 pac_cv_c_double_pos_align,[
1143 AC_TRY_RUN([
1144 #include <stdio.h>
1145 #define DBG(a,b,c)
1146 int main( int argc, char *argv[] )
1147 {
1148     FILE *cf;
1149     int padding_varies_by_pos = 0;
1150     struct { char a; double b; } char_double;
1151     struct { double b; char a; } double_char;
1152     int extent1, extent2;
1153
1154     extent1 = sizeof(char_double);
1155     extent2 = sizeof(double_char);
1156     if (extent1 != extent2) padding_varies_by_pos = 1;
1157
1158     cf = fopen( "ctest.out", "w" );
1159     if (padding_varies_by_pos) fprintf( cf, "yes\n" );
1160     else fprintf( cf, "no\n" );
1161
1162     fclose( cf );
1163     return 0;
1164 }],
1165 pac_cv_c_double_pos_align=`cat ctest.out`,
1166 pac_cv_c_double_pos_align="unknown",
1167 pac_cv_c_double_pos_align="$CROSS_ALIGN_DOUBLE_POS")
1168 rm -f ctest.out
1169 ])
1170 if test -z "$pac_cv_c_double_pos_align" ; then
1171     pac_cv_c_double_pos_align="unknown"
1172 fi
1173 ])
1174
1175 dnl Test for odd struct alignment rule that only applies max.
1176 dnl padding when long long int value is at front of type.
1177 dnl Puts result in pac_cv_c_llint_pos_align.
1178 dnl
1179 dnl Search for "Power alignment mode" for more details.
1180 dnl
1181 dnl Possible values include yes, no, and unknown.
1182 dnl
1183 AC_DEFUN([PAC_C_LLINT_POS_ALIGN],[
1184 AC_CACHE_CHECK([if alignment of structs with long long ints is based on position],
1185 pac_cv_c_llint_pos_align,[
1186 AC_TRY_RUN([
1187 #include <stdio.h>
1188 #define DBG(a,b,c)
1189 int main( int argc, char *argv[] )
1190 {
1191     FILE *cf;
1192     int padding_varies_by_pos = 0;
1193 #ifdef HAVE_LONG_LONG_INT
1194     struct { char a; long long int b; } char_llint;
1195     struct { long long int b; char a; } llint_char;
1196     int extent1, extent2;
1197
1198     extent1 = sizeof(char_llint);
1199     extent2 = sizeof(llint_char);
1200     if (extent1 != extent2) padding_varies_by_pos = 1;
1201 #endif
1202
1203     cf = fopen( "ctest.out", "w" );
1204     if (padding_varies_by_pos) fprintf( cf, "yes\n" );
1205     else fprintf( cf, "no\n" );
1206
1207     fclose( cf );
1208     return 0;
1209 }],
1210 pac_cv_c_llint_pos_align=`cat ctest.out`,
1211 pac_cv_c_llint_pos_align="unknown",
1212 pac_cv_c_llint_pos_align="$CROSS_ALIGN_LLINT_POS")
1213 rm -f ctest.out
1214 ])
1215 if test -z "$pac_cv_c_llint_pos_align" ; then
1216     pac_cv_c_llint_pos_align="unknown"
1217 fi
1218 ])
1219
1220 dnl/*D
1221 dnl PAC_FUNC_NEEDS_DECL - Set NEEDS_<funcname>_DECL if a declaration is needed
1222 dnl
1223 dnl Synopsis:
1224 dnl PAC_FUNC_NEEDS_DECL(headerfiles,funcname)
1225 dnl
1226 dnl Output Effect:
1227 dnl Sets 'NEEDS_<funcname>_DECL' if 'funcname' is not declared by the 
1228 dnl headerfiles.
1229 dnl
1230 dnl Approach:
1231 dnl Attempt to assign library function to function pointer.  If the function
1232 dnl is not declared in a header, this will fail.  Use a non-static global so
1233 dnl the compiler does not warn about an unused variable.
1234 dnl
1235 dnl Simply calling the function is not enough because C89 compilers allow
1236 dnl calls to implicitly-defined functions.  Re-declaring a library function
1237 dnl with an incompatible prototype is also not sufficient because some
1238 dnl compilers (notably clang-3.2) only produce a warning in this case.
1239 dnl
1240 dnl D*/
1241 AC_DEFUN([PAC_FUNC_NEEDS_DECL],[
1242 AC_CACHE_CHECK([whether $2 needs a declaration],
1243 pac_cv_func_decl_$2,[
1244 AC_TRY_COMPILE([$1
1245 void (*fptr)(void) = (void(*)(void))$2;],[],
1246 pac_cv_func_decl_$2=no,pac_cv_func_decl_$2=yes)])
1247 if test "$pac_cv_func_decl_$2" = "yes" ; then
1248 changequote(<<,>>)dnl
1249 define(<<PAC_FUNC_NAME>>, translit(NEEDS_$2_DECL, [a-z *], [A-Z__]))dnl
1250 changequote([, ])dnl
1251     AC_DEFINE_UNQUOTED(PAC_FUNC_NAME,1,[Define if $2 needs a declaration])
1252 undefine([PAC_FUNC_NAME])
1253 fi
1254 ])
1255
1256 dnl PAC_C_GNU_ATTRIBUTE - See if the GCC __attribute__ specifier is allow.
1257 dnl Use the following
1258 dnl #ifndef HAVE_GCC_ATTRIBUTE
1259 dnl #define __attribute__(a)
1260 dnl #endif
1261 dnl If *not*, define __attribute__(a) as null
1262 dnl
1263 dnl We start by requiring Gcc.  Some other compilers accept __attribute__
1264 dnl but generate warning messages, or have different interpretations 
1265 dnl (which seems to make __attribute__ just as bad as #pragma) 
1266 dnl For example, the Intel icc compiler accepts __attribute__ and
1267 dnl __attribute__((pure)) but generates warnings for __attribute__((format...))
1268 dnl
1269 AC_DEFUN([PAC_C_GNU_ATTRIBUTE],[
1270 AC_REQUIRE([AC_PROG_CC_GNU])
1271 if test "$ac_cv_prog_gcc" = "yes" ; then
1272     AC_CACHE_CHECK([whether __attribute__ allowed],
1273 pac_cv_gnu_attr_pure,[
1274 AC_TRY_COMPILE([int foo(int) __attribute__ ((pure));],[int a;],
1275 pac_cv_gnu_attr_pure=yes,pac_cv_gnu_attr_pure=no)])
1276 AC_CACHE_CHECK([whether __attribute__((format)) allowed],
1277 pac_cv_gnu_attr_format,[
1278 AC_TRY_COMPILE([int foo(char *,...) __attribute__ ((format(printf,1,2)));],[int a;],
1279 pac_cv_gnu_attr_format=yes,pac_cv_gnu_attr_format=no)])
1280     if test "$pac_cv_gnu_attr_pure" = "yes" -a "$pac_cv_gnu_attr_format" = "yes" ; then
1281         AC_DEFINE(HAVE_GCC_ATTRIBUTE,1,[Define if GNU __attribute__ is supported])
1282     fi
1283 fi
1284 ])
1285 dnl
1286 dnl Check for a broken install (fails to preserve file modification times,
1287 dnl thus breaking libraries.
1288 dnl
1289 dnl Create a library, install it, and then try to link against it.
1290 AC_DEFUN([PAC_PROG_INSTALL_BREAKS_LIBS],[
1291 AC_CACHE_CHECK([whether install breaks libraries],
1292 ac_cv_prog_install_breaks_libs,[
1293 AC_REQUIRE([AC_PROG_RANLIB])
1294 AC_REQUIRE([AC_PROG_INSTALL])
1295 AC_REQUIRE([AC_PROG_CC])
1296 ac_cv_prog_install_breaks_libs=yes
1297
1298 AC_COMPILE_IFELSE([
1299     AC_LANG_SOURCE([ int foo(int); int foo(int a){return a;} ])
1300 ],[
1301     if ${AR-ar} ${AR_FLAGS-cr} libconftest.a conftest.$OBJEXT >/dev/null 2>&1 ; then
1302         if ${RANLIB-:} libconftest.a >/dev/null 2>&1 ; then
1303             # Anything less than sleep 10, and Mac OS/X (Darwin) 
1304             # will claim that install works because ranlib won't complain
1305             sleep 10
1306             libinstall="$INSTALL_DATA"
1307             eval "libinstall=\"$libinstall\""
1308             if ${libinstall} libconftest.a libconftest1.a >/dev/null 2>&1 ; then
1309                 saved_LIBS="$LIBS"
1310                 LIBS="libconftest1.a"
1311                 AC_LINK_IFELSE([
1312                     AC_LANG_SOURCE([
1313 extern int foo(int);
1314 int main(int argc, char **argv){ return foo(0); }
1315                     ])
1316                 ],[
1317                     # Success!  Install works
1318                     ac_cv_prog_install_breaks_libs=no
1319                 ],[
1320                     # Failure!  Does install -p work?        
1321                     rm -f libconftest1.a
1322                     if ${libinstall} -p libconftest.a libconftest1.a >/dev/null 2>&1 ; then
1323                         AC_LINK_IFELSE([],[
1324                             # Success!  Install works
1325                             ac_cv_prog_install_breaks_libs="no, with -p"
1326                         ])
1327                     fi
1328                 ])
1329                 LIBS="$saved_LIBS"
1330             fi
1331         fi
1332     fi
1333 ])
1334 rm -f libconftest*.a
1335 ]) dnl Endof ac_cache_check
1336
1337 if test -z "$RANLIB_AFTER_INSTALL" ; then
1338     RANLIB_AFTER_INSTALL=no
1339 fi
1340 case "$ac_cv_prog_install_breaks_libs" in
1341     yes)
1342         RANLIB_AFTER_INSTALL=yes
1343     ;;
1344     "no, with -p")
1345         INSTALL_DATA="$INSTALL_DATA -p"
1346     ;;
1347     *)
1348     # Do nothing
1349     :
1350     ;;
1351 esac
1352 AC_SUBST(RANLIB_AFTER_INSTALL)
1353 ])
1354
1355 #
1356 # determine if the compiler defines a symbol containing the function name
1357 #
1358 # These tests check not only that the compiler defines some symbol, such
1359 # as __FUNCTION__, but that the symbol correctly names the function.
1360 #
1361 # Defines 
1362 #   HAVE__FUNC__      (if __func__ defined)
1363 #   HAVE_CAP__FUNC__  (if __FUNC__ defined)
1364 #   HAVE__FUNCTION__  (if __FUNCTION__ defined)
1365 #
1366 AC_DEFUN([PAC_CC_FUNCTION_NAME_SYMBOL],[
1367 AC_CACHE_CHECK([whether the compiler defines __func__],
1368 pac_cv_have__func__,[
1369 tmp_am_cross=no
1370 AC_RUN_IFELSE([
1371 AC_LANG_SOURCE([
1372 #include <string.h>
1373 int foo(void);
1374 int foo(void)
1375 {
1376     return (strcmp(__func__, "foo") == 0);
1377 }
1378 int main(int argc, char ** argv)
1379 {
1380     return (foo() ? 0 : 1);
1381 }
1382 ])
1383 ], pac_cv_have__func__=yes, pac_cv_have__func__=no,tmp_am_cross=yes)
1384 if test "$tmp_am_cross" = yes ; then
1385     AC_LINK_IFELSE([
1386     AC_LANG_SOURCE([
1387 #include <string.h>
1388 int foo(void);
1389 int foo(void)
1390 {
1391     return (strcmp(__func__, "foo") == 0);
1392 }
1393 int main(int argc, char ** argv)
1394 {
1395     return (foo() ? 0 : 1);
1396 }
1397     ])
1398 ], pac_cv_have__func__=yes, pac_cv_have__func__=no)
1399 fi
1400 ])
1401
1402 if test "$pac_cv_have__func__" = "yes" ; then
1403     AC_DEFINE(HAVE__FUNC__,,[define if the compiler defines __func__])
1404 fi
1405
1406 AC_CACHE_CHECK([whether the compiler defines __FUNC__],
1407 pac_cv_have_cap__func__,[
1408 tmp_am_cross=no
1409 AC_RUN_IFELSE([
1410 AC_LANG_SOURCE([
1411 #include <string.h>
1412 int foo(void);
1413 int foo(void)
1414 {
1415     return (strcmp(__FUNC__, "foo") == 0);
1416 }
1417 int main(int argc, char ** argv)
1418 {
1419     return (foo() ? 0 : 1);
1420 }
1421 ])
1422 ], pac_cv_have_cap__func__=yes, pac_cv_have_cap__func__=no,tmp_am_cross=yes)
1423 if test "$tmp_am_cross" = yes ; then
1424     AC_LINK_IFELSE([
1425     AC_LANG_SOURCE([
1426 #include <string.h>
1427 int foo(void);
1428 int foo(void)
1429 {
1430     return (strcmp(__FUNC__, "foo") == 0);
1431 }
1432 int main(int argc, char ** argv)
1433 {
1434     return (foo() ? 0 : 1);
1435 }
1436     ])
1437 ], pac_cv_have__func__=yes, pac_cv_have__func__=no)
1438 fi
1439 ])
1440
1441 if test "$pac_cv_have_cap__func__" = "yes" ; then
1442     AC_DEFINE(HAVE_CAP__FUNC__,,[define if the compiler defines __FUNC__])
1443 fi
1444
1445 AC_CACHE_CHECK([whether the compiler sets __FUNCTION__],
1446 pac_cv_have__function__,[
1447 tmp_am_cross=no
1448 AC_RUN_IFELSE([
1449 AC_LANG_SOURCE([
1450 #include <string.h>
1451 int foo(void);
1452 int foo(void)
1453 {
1454     return (strcmp(__FUNCTION__, "foo") == 0);
1455 }
1456 int main(int argc, char ** argv)
1457 {
1458     return (foo() ? 0 : 1);
1459 }
1460 ])
1461 ], pac_cv_have__function__=yes, pac_cv_have__function__=no,tmp_am_cross=yes)
1462 if test "$tmp_am_cross" = yes ; then
1463     AC_LINK_IFELSE([
1464     AC_LANG_SOURCE([
1465 #include <string.h>
1466 int foo(void);
1467 int foo(void)
1468 {
1469     return (strcmp(__FUNCTION__, "foo") == 0);
1470 }
1471 int main(int argc, char ** argv)
1472 {
1473     return (foo() ? 0 : 1);
1474 }
1475     ])
1476 ], pac_cv_have__func__=yes, pac_cv_have__func__=no)
1477 fi
1478 ])
1479
1480 if test "$pac_cv_have__function__" = "yes" ; then
1481     AC_DEFINE(HAVE__FUNCTION__,,[define if the compiler defines __FUNCTION__])
1482 fi
1483
1484 ])
1485
1486
1487 dnl Check structure alignment
1488 AC_DEFUN([PAC_STRUCT_ALIGNMENT],[
1489         # Initialize alignment checks
1490         is_packed=1
1491         is_two=1
1492         is_four=1
1493         is_eight=1
1494         is_largest=1
1495
1496         # See if long double exists
1497         AC_TRY_COMPILE(,[long double a;],have_long_double=yes,have_long_double=no)
1498
1499         # Get sizes of regular types
1500         AC_CHECK_SIZEOF(char)
1501         AC_CHECK_SIZEOF(int)
1502         AC_CHECK_SIZEOF(short)
1503         AC_CHECK_SIZEOF(long)
1504         AC_CHECK_SIZEOF(float)
1505         AC_CHECK_SIZEOF(double)
1506         AC_CHECK_SIZEOF(long double)
1507
1508         # char_int comparison
1509         AC_CHECK_SIZEOF(char_int, 0, [typedef struct { char a; int b; } char_int; ])
1510         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_int`
1511         extent=$ac_cv_sizeof_char_int
1512         if test "$size" != "$extent" ; then is_packed=0 ; fi
1513         if test "`expr $extent % $ac_cv_sizeof_int`" != "0" ; then is_largest=0 ; fi
1514         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1515         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1516         if test "$ac_cv_sizeof_int" = "8" -a "`expr $extent % 8`" != "0" ; then
1517            is_eight=0
1518         fi
1519
1520         # char_short comparison
1521         AC_CHECK_SIZEOF(char_short, 0, [typedef struct { char a; short b; } char_short; ])
1522         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_short`
1523         extent=$ac_cv_sizeof_char_short
1524         if test "$size" != "$extent" ; then is_packed=0 ; fi
1525         if test "`expr $extent % $ac_cv_sizeof_short`" != "0" ; then is_largest=0 ; fi
1526         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1527         if test "$ac_cv_sizeof_short" = "4" -a "`expr $extent % 4`" != "0" ; then
1528            is_four=0
1529         fi
1530         if test "$ac_cv_sizeof_short" = "8" -a "`expr $extent % 8`" != "0" ; then
1531            is_eight=0
1532         fi
1533
1534         # char_long comparison
1535         AC_CHECK_SIZEOF(char_long, 0, [typedef struct { char a; long b; } char_long; ])
1536         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_long`
1537         extent=$ac_cv_sizeof_char_long
1538         if test "$size" != "$extent" ; then is_packed=0 ; fi
1539         if test "`expr $extent % $ac_cv_sizeof_long`" != "0" ; then is_largest=0 ; fi
1540         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1541         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1542         if test "$ac_cv_sizeof_long" = "8" -a "`expr $extent % 8`" != "0" ; then
1543            is_eight=0
1544         fi
1545
1546         # char_float comparison
1547         AC_CHECK_SIZEOF(char_float, 0, [typedef struct { char a; float b; } char_float; ])
1548         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_float`
1549         extent=$ac_cv_sizeof_char_float
1550         if test "$size" != "$extent" ; then is_packed=0 ; fi
1551         if test "`expr $extent % $ac_cv_sizeof_float`" != "0" ; then is_largest=0 ; fi
1552         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1553         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1554         if test "$ac_cv_sizeof_float" = "8" -a "`expr $extent % 8`" != "0" ; then
1555            is_eight=0
1556         fi
1557
1558         # char_double comparison
1559         AC_CHECK_SIZEOF(char_double, 0, [typedef struct { char a; double b; } char_double; ])
1560         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_double`
1561         extent=$ac_cv_sizeof_char_double
1562         if test "$size" != "$extent" ; then is_packed=0 ; fi
1563         if test "`expr $extent % $ac_cv_sizeof_double`" != "0" ; then is_largest=0 ; fi
1564         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1565         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1566         if test "$ac_cv_sizeof_double" = "8" -a "`expr $extent % 8`" != "0" ; then
1567            is_eight=0
1568         fi
1569
1570         # char_long_double comparison
1571         if test "$have_long_double" = "yes"; then
1572         AC_CHECK_SIZEOF(char_long_double, 0, [
1573                                        typedef struct {
1574                                                char a;
1575                                                long double b;
1576                                        } char_long_double;
1577                                        ])
1578         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_long_double`
1579         extent=$ac_cv_sizeof_char_long_double
1580         if test "$size" != "$extent" ; then is_packed=0 ; fi
1581         if test "`expr $extent % $ac_cv_sizeof_long_double`" != "0" ; then is_largest=0 ; fi
1582         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1583         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1584         if test "$ac_cv_sizeof_long_double" = "8" -a "`expr $extent % 8`" != "0" ; then
1585            is_eight=0
1586         fi
1587         fi
1588
1589         # char_int_char comparison
1590         AC_CHECK_SIZEOF(char_int_char, 0, [
1591                                        typedef struct {
1592                                                char a;
1593                                                int b;
1594                                                char c;
1595                                        } char_int_char;
1596                                        ])
1597         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_int + $ac_cv_sizeof_char`
1598         extent=$ac_cv_sizeof_char_int_char
1599         if test "$size" != "$extent" ; then is_packed=0 ; fi
1600         if test "`expr $extent % $ac_cv_sizeof_int`" != "0" ; then is_largest=0 ; fi
1601         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1602         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1603         if test "$ac_cv_sizeof_int" = "8" -a "`expr $extent % 8`" != "0" ; then
1604            is_eight=0
1605         fi
1606
1607         # char_short_char comparison
1608         AC_CHECK_SIZEOF(char_short_char, 0, [
1609                                        typedef struct {
1610                                                char a;
1611                                                short b;
1612                                                char c;
1613                                        } char_short_char;
1614                                        ])
1615         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_short + $ac_cv_sizeof_char`
1616         extent=$ac_cv_sizeof_char_short_char
1617         if test "$size" != "$extent" ; then is_packed=0 ; fi
1618         if test "`expr $extent % $ac_cv_sizeof_short`" != "0" ; then is_largest=0 ; fi
1619         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1620         if test "$ac_cv_sizeof_short" = "4" -a "`expr $extent % 4`" != "0" ; then
1621            is_four=0
1622         fi
1623         if test "$ac_cv_sizeof_short" = "8" -a "`expr $extent % 8`" != "0" ; then
1624            is_eight=0
1625         fi
1626
1627         # If aligned mod 8, it will be aligned mod 4
1628         if test $is_eight = 1 ; then is_four=0 ; is_two=0 ; fi
1629         if test $is_four = 1 ; then is_two=0 ; fi
1630
1631         # Largest supersedes 8
1632         if test $is_largest = 1 ; then is_eight=0 ; fi
1633
1634         # Find the alignment
1635         if test "`expr $is_packed + $is_largest + $is_two + $is_four + $is_eight`" = "0" ; then
1636            pac_cv_struct_alignment="unknown"
1637         elif test "`expr $is_packed + $is_largest + $is_two + $is_four + $is_eight`" != "1" ; then
1638            pac_cv_struct_alignment="unknown"
1639         elif test $is_packed = 1 ; then
1640            pac_cv_struct_alignment="packed"
1641         elif test $is_largest = 1 ; then
1642            pac_cv_struct_alignment="largest"
1643         elif test $is_two = 1 ; then
1644            pac_cv_struct_alignment="two"
1645         elif test $is_four = 1 ; then
1646            pac_cv_struct_alignment="four"
1647         elif test $is_eight = 1 ; then
1648            pac_cv_struct_alignment="eight"
1649         fi
1650 ])
1651 dnl
1652 dnl PAC_C_MACRO_VA_ARGS
1653 dnl
1654 dnl will AC_DEFINE([HAVE_MACRO_VA_ARGS]) if the compiler supports C99 variable
1655 dnl length argument lists in macros (#define foo(...) bar(__VA_ARGS__))
1656 AC_DEFUN([PAC_C_MACRO_VA_ARGS],[
1657     AC_MSG_CHECKING([for variable argument list macro functionality])
1658     AC_LINK_IFELSE([AC_LANG_PROGRAM([
1659         #include <stdio.h>
1660         #define conftest_va_arg_macro(...) printf(__VA_ARGS__)
1661     ],
1662     [conftest_va_arg_macro("a test %d", 3);])],
1663     [AC_DEFINE([HAVE_MACRO_VA_ARGS],[1],[Define if C99-style variable argument list macro functionality])
1664      AC_MSG_RESULT([yes])],
1665     [AC_MSG_RESULT([no])])
1666 ])dnl
1667
1668 # Will AC_DEFINE([HAVE_BUILTIN_EXPECT]) if the compiler supports __builtin_expect.
1669 AC_DEFUN([PAC_C_BUILTIN_EXPECT],[
1670 AC_MSG_CHECKING([if C compiler supports __builtin_expect])
1671
1672 AC_TRY_LINK(, [
1673     return __builtin_expect(1, 1) ? 1 : 0
1674 ], [
1675     have_builtin_expect=yes
1676     AC_MSG_RESULT([yes])
1677 ], [
1678     have_builtin_expect=no
1679     AC_MSG_RESULT([no])
1680 ])
1681 if test x$have_builtin_expect = xyes ; then
1682     AC_DEFINE([HAVE_BUILTIN_EXPECT], [1], [Define to 1 if the compiler supports __builtin_expect.])
1683 fi
1684 ])