CH4: Move lock cycling to the CH4 layer
[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 improve portability
465     #   -Wstack-usage=262144 -- 32 bit FreeBSD did not like the mprobe test
466     #       allocating a big variable on the stack. (See tt#2160).  The "right"
467     #       value requires further investigation; 1 MiB would have at least
468     #       caught #2160 at compile-time, and only two other tests show a
469     #       warning at 256k.
470     #
471     # These were added to reduce warnings:
472     #   -Wno-missing-field-initializers  -- We want to allow a struct to be 
473     #       initialized to zero using "struct x y = {0};" and not require 
474     #       each field to be initialized individually.
475     #   -Wno-unused-parameter -- For portability, some parameters go unused
476     #       when we have different implementations of functions for 
477     #       different platforms
478     #   -Wno-unused-label -- We add fn_exit: and fn_fail: on all functions, 
479     #       but fn_fail may not be used if the function doesn't return an 
480     #       error.
481     #   -Wno-sign-compare -- read() and write() return bytes read/written
482     #       as a signed value, but we often compare this to size_t (or
483     #       msg_sz_t) variables.
484     #   -Wno-format-zero-length -- this warning is irritating and useless, since
485     #                              a zero-length format string is very well defined
486     # These were removed to reduce warnings:
487     #   -Wcast-qual -- Sometimes we need to cast "volatile char*" to 
488     #       "char*", e.g., for memcpy.
489     #   -Wpadded -- We catch struct padding with asserts when we need to
490     #   -Wredundant-decls -- Having redundant declarations is benign and the 
491     #       code already has some.
492     #   -Waggregate-return -- This seems to be a performance-related warning
493     #       aggregate return values are legal in ANSI C, but they may be returned
494     #       in memory rather than through a register.  We do use aggregate return
495     #       values, but they are structs of a single basic type (used to enforce
496     #       type checking for relative vs. absolute ptrs), and with optimization
497     #       the aggregate value is converted to a scalar.
498     #   -Wdeclaration-after-statement -- This is a C89
499     #       requirement. When compiling with C99, this should be
500     #       disabled.
501     #   -Wfloat-equal -- There are places in hwloc that set a float var to 0, then 
502     #       compare it to 0 later to see if it was updated.  Also when using strtod()
503     #       one needs to compare the return value with 0 to see whether a conversion
504     #       was performed.
505     #   -Werror-implicit-function-declaration -- implicit function declarations
506     #       should never be tolerated.  This also ensures that we get quick
507     #       compilation failures rather than later link failures that usually
508     #       come from a function name typo.
509     #   -Wcast-align -- Casting alignment warnings.  This is an
510     #       important check, but is temporarily disabled, since it is
511     #       throwing too many (correct) warnings currently, causing us
512     #       to miss other warnings.
513     #   -Wshorten-64-to-32 -- Bad type-casting warnings.  This is an
514     #       important check, but is temporarily disabled, since it is
515     #       throwing too many (correct) warnings currently, causing us
516     #       to miss other warnings.
517     #
518     # This was removed because it masks important failures (see ticket #2094).
519     # However, since Intel compiler currently does not include -Wtype-limits
520     # in -Wextra, -Wtype-limits was added to handle warnings with the Intel
521     # compiler.
522     #   -Wno-type-limits -- There are places where we compare an unsigned to 
523     #       a constant that happens to be zero e.g., if x is unsigned and 
524     #       MIN_VAL is zero, we'd like to do "MPIR_Assert(x >= MIN_VAL);".
525     #       Note this option is not supported by gcc 4.2.  This needs to be added 
526     #       after most other warning flags, so that we catch a gcc bug on 32-bit 
527     #       that doesn't give a warning that this is unsupported, unless another
528     #       warning is triggered, and then if gives an error.
529     # the embedded newlines in this string are safe because we evaluate each
530     # argument in the for-loop below and append them to the CFLAGS with a space
531     # as the separator instead
532     pac_common_strict_flags="
533         -Wall
534         -Wextra
535         -Wno-missing-field-initializers
536         -Wstrict-prototypes
537         -Wmissing-prototypes
538         -DGCC_WALL
539         -Wno-unused-parameter
540         -Wno-unused-label
541         -Wshadow
542         -Wmissing-declarations
543         -Wno-long-long
544         -Wundef
545         -Wno-endif-labels
546         -Wpointer-arith
547         -Wbad-function-cast
548         -Wwrite-strings
549         -Wno-sign-compare
550         -Wold-style-definition
551         -Wno-multichar
552         -Wno-deprecated-declarations
553         -Wpacked
554         -Wnested-externs
555         -Winvalid-pch
556         -Wno-pointer-sign
557         -Wvariadic-macros
558         -Wno-format-zero-length
559         -Wtype-limits
560         -Werror-implicit-function-declaration
561         -Wstack-usage=262144
562     "
563
564     enable_c89=no
565     enable_c99=yes
566     enable_posix=2001
567     enable_opt=yes
568     flags="`echo $1 | sed -e 's/:/ /g' -e 's/,/ /g'`"
569     for flag in ${flags}; do
570         case "$flag" in
571              c89)
572                 enable_strict_done="yes"
573                 enable_c89=yes
574                 enable_c99=no
575                 ;;
576              c99)
577                 enable_strict_done="yes"
578                 enable_c89=no
579                 enable_c99=yes
580                 ;;
581              posix1995)
582                 enable_strict_done="yes"
583                 enable_posix=1995
584                 ;;
585              posix|posix2001)
586                 enable_strict_done="yes"
587                 enable_posix=2001
588                 ;;
589              posix2008)
590                 enable_strict_done="yes"
591                 enable_posix=2008
592                 ;;
593              noposix)
594                 enable_strict_done="yes"
595                 enable_posix=no
596                 ;;
597              opt)
598                 enable_strict_done="yes"
599                 enable_opt=yes
600                 ;;
601              noopt)
602                 enable_strict_done="yes"
603                 enable_opt=no
604                 ;;
605              all|yes)
606                 enable_strict_done="yes"
607                 enable_c99=yes
608                 enable_posix=2001
609                 enable_opt=yes
610                 ;;
611              no)
612                 # Accept and ignore this value
613                 :
614                 ;;
615              *)
616                 if test -n "$flag" ; then
617                    AC_MSG_WARN([Unrecognized value for enable-strict:$flag])
618                 fi
619                 ;;
620         esac
621     done
622
623     pac_cc_strict_flags=""
624     if test "${enable_strict_done}" = "yes" ; then
625        if test "${enable_opt}" = "yes" ; then
626           pac_cc_strict_flags="-O2"
627        fi
628        pac_cc_strict_flags="$pac_cc_strict_flags $pac_common_strict_flags"
629        # We only allow one of strict-C99 or strict-C89 to be
630        # enabled. If C99 is enabled, we automatically disable C89.
631        if test "${enable_c99}" = "yes" ; then
632           PAC_APPEND_FLAG([-std=c99],[pac_cc_strict_flags])
633           # Use -D_STDC_C99= for Solaris compilers. See
634           # http://lists.gnu.org/archive/html/autoconf/2010-12/msg00059.html
635           # for discussion on why not to use -xc99
636           PAC_APPEND_FLAG([-D_STDC_C99=],[pac_cc_strict_flags])
637        elif test "${enable_c89}" = "yes" ; then
638           PAC_APPEND_FLAG([-std=c89],[pac_cc_strict_flags])
639           PAC_APPEND_FLAG([-Wdeclaration-after-statement],[pac_cc_strict_flags])
640        fi
641        # POSIX 2001 should be used with C99. But the default standard for some
642        # compilers are not C99. We must test the support of POSIX 2001 after
643        # testing C99.
644        case "$enable_posix" in
645             no)   : ;;
646             1995) PAC_APPEND_FLAG([-D_POSIX_C_SOURCE=199506L],[pac_cc_strict_flags]) ;;
647             2001) PAC_APPEND_FLAG([-D_POSIX_C_SOURCE=200112L],[pac_cc_strict_flags]) ;;
648             2008) PAC_APPEND_FLAG([-D_POSIX_C_SOURCE=200809L],[pac_cc_strict_flags]) ;;
649             *)    AC_MSG_ERROR([internal error, unexpected POSIX version: '$enable_posix']) ;;
650        esac
651     fi
652
653     # See if the above options work with the compiler
654     accepted_flags=""
655     for flag in $pac_cc_strict_flags ; do
656         PAC_PUSH_FLAG([CFLAGS])
657         CFLAGS="$CFLAGS $accepted_flags"
658         PAC_C_CHECK_COMPILER_OPTION([$flag],[accepted_flags="$accepted_flags $flag"],)
659         PAC_POP_FLAG([CFLAGS])
660     done
661     pac_cc_strict_flags=$accepted_flags
662 fi
663 ])
664
665 dnl/*D
666 dnl PAC_ARG_STRICT - Add --enable-strict to configure.  
667 dnl
668 dnl Synopsis:
669 dnl PAC_ARG_STRICT
670 dnl 
671 dnl Output effects:
672 dnl Adds '--enable-strict' to the command line.
673 dnl
674 dnl D*/
675 AC_DEFUN([PAC_ARG_STRICT],[
676 AC_ARG_ENABLE(strict,
677         AC_HELP_STRING([--enable-strict], [Turn on strict compilation testing]))
678 PAC_CC_STRICT($enable_strict)
679 CFLAGS="$CFLAGS $pac_cc_strict_flags"
680 export CFLAGS
681 ])
682
683 dnl Return the integer structure alignment in pac_cv_c_max_integer_align
684 dnl Possible values include
685 dnl     packed
686 dnl     two
687 dnl     four
688 dnl     eight
689 dnl
690 dnl In addition, a "Could not determine alignment" and a "error!"
691 dnl return is possible.  
692 AC_DEFUN([PAC_C_MAX_INTEGER_ALIGN],[
693 AC_CACHE_CHECK([for max C struct integer alignment],
694 pac_cv_c_max_integer_align,[
695 AC_TRY_RUN([
696 #include <stdio.h>
697 #define DBG(a,b,c)
698 int main( int argc, char *argv[] )
699 {
700     FILE *cf;
701     int is_packed  = 1;
702     int is_two     = 1;
703     int is_four    = 1;
704     int is_eight   = 1;
705     struct { char a; int b; } char_int;
706     struct { char a; short b; } char_short;
707     struct { char a; long b; } char_long;
708     struct { char a; int b; char c; } char_int_char;
709     struct { char a; short b; char c; } char_short_char;
710 #ifdef HAVE_LONG_LONG_INT
711     struct { long long int a; char b; } lli_c;
712     struct { char a; long long int b; } c_lli;
713 #endif
714     int size, extent, extent2;
715
716     /* assume max integer alignment isn't 8 if we don't have
717      * an eight-byte value :)
718      */
719 #ifdef HAVE_LONG_LONG_INT
720     if (sizeof(int) < 8 && sizeof(long) < 8 && sizeof(long long int) < 8)
721         is_eight = 0;
722 #else
723     if (sizeof(int) < 8 && sizeof(long) < 8) is_eight = 0;
724 #endif
725
726     size = sizeof(char) + sizeof(int);
727     extent = sizeof(char_int);
728     if (size != extent) is_packed = 0;
729     if ( (extent % 2) != 0) is_two = 0;
730     if ( (extent % 4) != 0) is_four = 0;
731     if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
732     DBG("char_int",size,extent);
733
734     size = sizeof(char) + sizeof(short);
735     extent = sizeof(char_short);
736     if (size != extent) is_packed = 0;
737     if ( (extent % 2) != 0) is_two = 0;
738     if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;
739     if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;
740     DBG("char_short",size,extent);
741
742     size = sizeof(char) + sizeof(long);
743     extent = sizeof(char_long);
744     if (size != extent) is_packed = 0;
745     if ( (extent % 2) != 0) is_two = 0;
746     if ( (extent % 4) != 0) is_four = 0;
747     if (sizeof(long) == 8 && (extent % 8) != 0) is_eight = 0;
748     DBG("char_long",size,extent);
749
750 #ifdef HAVE_LONG_LONG_INT
751     size = sizeof(char) + sizeof(long long int);
752     extent = sizeof(lli_c);
753     extent2 = sizeof(c_lli);
754     if (size != extent) is_packed = 0;
755     if ( (extent % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
756     if ( (extent % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
757     if (sizeof(long long int) >= 8 && (extent % 8) != 0 && (extent2 % 8) != 0)
758         is_eight = 0;
759 #endif
760
761     size = sizeof(char) + sizeof(int) + sizeof(char);
762     extent = sizeof(char_int_char);
763     if (size != extent) is_packed = 0;
764     if ( (extent % 2) != 0) is_two = 0;
765     if ( (extent % 4) != 0) is_four = 0;
766     if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
767     DBG("char_int_char",size,extent);
768
769     size = sizeof(char) + sizeof(short) + sizeof(char);
770     extent = sizeof(char_short_char);
771     if (size != extent) is_packed = 0;
772     if ( (extent % 2) != 0) is_two = 0;
773     if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;
774     if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;
775     DBG("char_short_char",size,extent);
776
777     /* If aligned mod 8, it will be aligned mod 4 */
778     if (is_eight) { is_four = 0; is_two = 0; }
779
780     if (is_four) is_two = 0;
781
782     /* Tabulate the results */
783     cf = fopen( "ctest.out", "w" );
784     if (is_packed + is_two + is_four + is_eight == 0) {
785         fprintf( cf, "Could not determine alignment\n" );
786     }
787     else {
788         if (is_packed + is_two + is_four + is_eight != 1) {
789             fprintf( cf, "error!\n" );
790         }
791         else {
792             if (is_packed) fprintf( cf, "packed\n" );
793             if (is_two) fprintf( cf, "two\n" );
794             if (is_four) fprintf( cf, "four\n" );
795             if (is_eight) fprintf( cf, "eight\n" );
796         }
797     }
798     fclose( cf );
799     return 0;
800 }],
801 pac_cv_c_max_integer_align=`cat ctest.out`,
802 pac_cv_c_max_integer_align="unknown",
803 pac_cv_c_max_integer_align="$CROSS_ALIGN_STRUCT_INT")
804 rm -f ctest.out
805 ])
806 if test -z "$pac_cv_c_max_integer_align" ; then
807     pac_cv_c_max_integer_align="unknown"
808 fi
809 ])
810
811 dnl Return the floating point structure alignment in
812 dnl pac_cv_c_max_fp_align.
813 dnl
814 dnl Possible values include:
815 dnl     packed
816 dnl     two
817 dnl     four
818 dnl     eight
819 dnl     sixteen
820 dnl
821 dnl In addition, a "Could not determine alignment" and a "error!"
822 dnl return is possible.  
823 AC_DEFUN([PAC_C_MAX_FP_ALIGN],[
824 AC_CACHE_CHECK([for max C struct floating point alignment],
825 pac_cv_c_max_fp_align,[
826 AC_TRY_RUN([
827 #include <stdio.h>
828 #define DBG(a,b,c)
829 int main( int argc, char *argv[] )
830 {
831     FILE *cf;
832     int is_packed  = 1;
833     int is_two     = 1;
834     int is_four    = 1;
835     int is_eight   = 1;
836     int is_sixteen = 1;
837     struct { char a; float b; } char_float;
838     struct { float b; char a; } float_char;
839     struct { char a; double b; } char_double;
840     struct { double b; char a; } double_char;
841 #ifdef HAVE_LONG_DOUBLE
842     struct { char a; long double b; } char_long_double;
843     struct { long double b; char a; } long_double_char;
844     struct { long double a; int b; char c; } long_double_int_char;
845 #endif
846     int size, extent1, extent2;
847
848     size = sizeof(char) + sizeof(float);
849     extent1 = sizeof(char_float);
850     extent2 = sizeof(float_char);
851     if (size != extent1) is_packed = 0;
852     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
853     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
854     if (sizeof(float) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
855         is_eight = 0;
856     DBG("char_float",size,extent1);
857
858     size = sizeof(char) + sizeof(double);
859     extent1 = sizeof(char_double);
860     extent2 = sizeof(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(double) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
865         is_eight = 0;
866     DBG("char_double",size,extent1);
867
868 #ifdef HAVE_LONG_DOUBLE
869     size = sizeof(char) + sizeof(long double);
870     extent1 = sizeof(char_long_double);
871     extent2 = sizeof(long_double_char);
872     if (size != extent1) is_packed = 0;
873     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
874     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
875     if (sizeof(long double) >= 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
876         is_eight = 0;
877     if (sizeof(long double) > 8 && (extent1 % 16) != 0
878         && (extent2 % 16) != 0) is_sixteen = 0;
879     DBG("char_long-double",size,extent1);
880
881     extent1 = sizeof(long_double_int_char);
882     if ( (extent1 % 2) != 0) is_two = 0;
883     if ( (extent1 % 4) != 0) is_four = 0;
884     if (sizeof(long double) >= 8 && (extent1 % 8) != 0) is_eight = 0;
885     if (sizeof(long double) > 8 && (extent1 % 16) != 0) is_sixteen = 0;
886 #else
887     is_sixteen = 0;
888 #endif
889
890     if (is_sixteen) { is_eight = 0; is_four = 0; is_two = 0; }
891
892     if (is_eight) { is_four = 0; is_two = 0; }
893
894     if (is_four) is_two = 0;
895
896     /* Tabulate the results */
897     cf = fopen( "ctest.out", "w" );
898     if (is_packed + is_two + is_four + is_eight + is_sixteen == 0) {
899         fprintf( cf, "Could not determine alignment\n" );
900     }
901     else {
902         if (is_packed + is_two + is_four + is_eight + is_sixteen != 1) {
903             fprintf( cf, "error!\n" );
904         }
905         else {
906             if (is_packed) fprintf( cf, "packed\n" );
907             if (is_two) fprintf( cf, "two\n" );
908             if (is_four) fprintf( cf, "four\n" );
909             if (is_eight) fprintf( cf, "eight\n" );
910             if (is_sixteen) fprintf( cf, "sixteen\n" );
911         }
912     }
913     fclose( cf );
914     return 0;
915 }],
916 pac_cv_c_max_fp_align=`cat ctest.out`,
917 pac_cv_c_max_fp_align="unknown",
918 pac_cv_c_max_fp_align="$CROSS_ALIGN_STRUCT_FP")
919 rm -f ctest.out
920 ])
921 if test -z "$pac_cv_c_max_fp_align" ; then
922     pac_cv_c_max_fp_align="unknown"
923 fi
924 ])
925
926 dnl Return the floating point structure alignment in
927 dnl pac_cv_c_max_double_fp_align.
928 dnl
929 dnl Possible values include:
930 dnl     packed
931 dnl     two
932 dnl     four
933 dnl     eight
934 dnl
935 dnl In addition, a "Could not determine alignment" and a "error!"
936 dnl return is possible.  
937 AC_DEFUN([PAC_C_MAX_DOUBLE_FP_ALIGN],[
938 AC_CACHE_CHECK([for max C struct alignment of structs with doubles],
939 pac_cv_c_max_double_fp_align,[
940 AC_TRY_RUN([
941 #include <stdio.h>
942 #define DBG(a,b,c)
943 int main( int argc, char *argv[] )
944 {
945     FILE *cf;
946     int is_packed  = 1;
947     int is_two     = 1;
948     int is_four    = 1;
949     int is_eight   = 1;
950     struct { char a; float b; } char_float;
951     struct { float b; char a; } float_char;
952     struct { char a; double b; } char_double;
953     struct { double b; char a; } double_char;
954     int size, extent1, extent2;
955
956     size = sizeof(char) + sizeof(float);
957     extent1 = sizeof(char_float);
958     extent2 = sizeof(float_char);
959     if (size != extent1) is_packed = 0;
960     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
961     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
962     if (sizeof(float) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
963         is_eight = 0;
964     DBG("char_float",size,extent1);
965
966     size = sizeof(char) + sizeof(double);
967     extent1 = sizeof(char_double);
968     extent2 = sizeof(double_char);
969     if (size != extent1) is_packed = 0;
970     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
971     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
972     if (sizeof(double) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
973         is_eight = 0;
974     DBG("char_double",size,extent1);
975
976     if (is_eight) { is_four = 0; is_two = 0; }
977
978     if (is_four) is_two = 0;
979
980     /* Tabulate the results */
981     cf = fopen( "ctest.out", "w" );
982     if (is_packed + is_two + is_four + is_eight == 0) {
983         fprintf( cf, "Could not determine alignment\n" );
984     }
985     else {
986         if (is_packed + is_two + is_four + is_eight != 1) {
987             fprintf( cf, "error!\n" );
988         }
989         else {
990             if (is_packed) fprintf( cf, "packed\n" );
991             if (is_two) fprintf( cf, "two\n" );
992             if (is_four) fprintf( cf, "four\n" );
993             if (is_eight) fprintf( cf, "eight\n" );
994         }
995     }
996     fclose( cf );
997     return 0;
998 }],
999 pac_cv_c_max_double_fp_align=`cat ctest.out`,
1000 pac_cv_c_max_double_fp_align="unknown",
1001 pac_cv_c_max_double_fp_align="$CROSS_ALIGN_STRUCT_DOUBLE_FP")
1002 rm -f ctest.out
1003 ])
1004 if test -z "$pac_cv_c_max_double_fp_align" ; then
1005     pac_cv_c_max_double_fp_align="unknown"
1006 fi
1007 ])
1008 AC_DEFUN([PAC_C_MAX_LONGDOUBLE_FP_ALIGN],[
1009 AC_CACHE_CHECK([for max C struct floating point alignment with long doubles],
1010 pac_cv_c_max_longdouble_fp_align,[
1011 AC_TRY_RUN([
1012 #include <stdio.h>
1013 #define DBG(a,b,c)
1014 int main( int argc, char *argv[] )
1015 {
1016     FILE *cf;
1017     int is_packed  = 1;
1018     int is_two     = 1;
1019     int is_four    = 1;
1020     int is_eight   = 1;
1021     int is_sixteen = 1;
1022     struct { char a; long double b; } char_long_double;
1023     struct { long double b; char a; } long_double_char;
1024     struct { long double a; int b; char c; } long_double_int_char;
1025     int size, extent1, extent2;
1026
1027     size = sizeof(char) + sizeof(long double);
1028     extent1 = sizeof(char_long_double);
1029     extent2 = sizeof(long_double_char);
1030     if (size != extent1) is_packed = 0;
1031     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
1032     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
1033     if (sizeof(long double) >= 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
1034         is_eight = 0;
1035     if (sizeof(long double) > 8 && (extent1 % 16) != 0
1036         && (extent2 % 16) != 0) is_sixteen = 0;
1037     DBG("char_long-double",size,extent1);
1038
1039     extent1 = sizeof(long_double_int_char);
1040     if ( (extent1 % 2) != 0) is_two = 0;
1041     if ( (extent1 % 4) != 0) is_four = 0;
1042     if (sizeof(long double) >= 8 && (extent1 % 8) != 0) is_eight = 0;
1043     if (sizeof(long double) > 8 && (extent1 % 16) != 0) is_sixteen = 0;
1044
1045     if (is_sixteen) { is_eight = 0; is_four = 0; is_two = 0; }
1046
1047     if (is_eight) { is_four = 0; is_two = 0; }
1048
1049     if (is_four) is_two = 0;
1050
1051     /* Tabulate the results */
1052     cf = fopen( "ctest.out", "w" );
1053     if (is_packed + is_two + is_four + is_eight + is_sixteen == 0) {
1054         fprintf( cf, "Could not determine alignment\n" );
1055     }
1056     else {
1057         if (is_packed + is_two + is_four + is_eight + is_sixteen != 1) {
1058             fprintf( cf, "error!\n" );
1059         }
1060         else {
1061             if (is_packed) fprintf( cf, "packed\n" );
1062             if (is_two) fprintf( cf, "two\n" );
1063             if (is_four) fprintf( cf, "four\n" );
1064             if (is_eight) fprintf( cf, "eight\n" );
1065             if (is_sixteen) fprintf( cf, "sixteen\n" );
1066         }
1067     }
1068     fclose( cf );
1069     return 0;
1070 }],
1071 pac_cv_c_max_longdouble_fp_align=`cat ctest.out`,
1072 pac_cv_c_max_longdouble_fp_align="unknown",
1073 pac_cv_c_max_longdouble_fp_align="$CROSS_ALIGN_STRUCT_LONGDOUBLE_FP")
1074 rm -f ctest.out
1075 ])
1076 if test -z "$pac_cv_c_max_longdouble_fp_align" ; then
1077     pac_cv_c_max_longdouble_fp_align="unknown"
1078 fi
1079 ])
1080
1081 dnl Other tests assume that there is potentially a maximum alignment
1082 dnl and that if there is no maximum alignment, or a type is smaller than
1083 dnl that value, then we align on the size of the value, with the exception
1084 dnl of the "position-based alignment" rules we test for separately.
1085 dnl
1086 dnl It turns out that these assumptions have fallen short in at least one
1087 dnl case, on MacBook Pros, where doubles are aligned on 4-byte boundaries
1088 dnl even when long doubles are aligned on 16-byte boundaries. So this test
1089 dnl is here specifically to handle this case.
1090 dnl
1091 dnl Puts result in pac_cv_c_double_alignment_exception.
1092 dnl
1093 dnl Possible values currently include no and four.
1094 dnl
1095 AC_DEFUN([PAC_C_DOUBLE_ALIGNMENT_EXCEPTION],[
1096 AC_CACHE_CHECK([if double alignment breaks rules, find actual alignment],
1097 pac_cv_c_double_alignment_exception,[
1098 AC_TRY_RUN([
1099 #include <stdio.h>
1100 #define DBG(a,b,c)
1101 int main( int argc, char *argv[] )
1102 {
1103     FILE *cf;
1104     struct { char a; double b; } char_double;
1105     struct { double b; char a; } double_char;
1106     int extent1, extent2, align_4 = 0;
1107
1108     extent1 = sizeof(char_double);
1109     extent2 = sizeof(double_char);
1110
1111     /* we're interested in the largest value, will let separate test
1112      * deal with position-based issues.
1113      */
1114     if (extent1 < extent2) extent1 = extent2;
1115     if ((sizeof(double) == 8) && (extent1 % 8) != 0) {
1116        if (extent1 % 4 == 0) {
1117 #ifdef HAVE_MAX_FP_ALIGNMENT
1118           if (HAVE_MAX_FP_ALIGNMENT >= 8) align_4 = 1;
1119 #else
1120           align_4 = 1;
1121 #endif
1122        }
1123     }
1124
1125     cf = fopen( "ctest.out", "w" );
1126
1127     if (align_4) fprintf( cf, "four\n" );
1128     else fprintf( cf, "no\n" );
1129
1130     fclose( cf );
1131     return 0;
1132 }],
1133 pac_cv_c_double_alignment_exception=`cat ctest.out`,
1134 pac_cv_c_double_alignment_exception="unknown",
1135 pac_cv_c_double_alignment_exception="$CROSS_ALIGN_DOUBLE_EXCEPTION")
1136 rm -f ctest.out
1137 ])
1138 if test -z "$pac_cv_c_double_alignment_exception" ; then
1139     pac_cv_c_double_alignment_exception="unknown"
1140 fi
1141 ])
1142
1143 dnl Test for odd struct alignment rule that only applies max.
1144 dnl padding when double value is at front of type.
1145 dnl Puts result in pac_cv_c_double_pos_align.
1146 dnl
1147 dnl Search for "Power alignment mode" for more details.
1148 dnl
1149 dnl Possible values include yes, no, and unknown.
1150 dnl
1151 AC_DEFUN([PAC_C_DOUBLE_POS_ALIGN],[
1152 AC_CACHE_CHECK([if alignment of structs with doubles is based on position],
1153 pac_cv_c_double_pos_align,[
1154 AC_TRY_RUN([
1155 #include <stdio.h>
1156 #define DBG(a,b,c)
1157 int main( int argc, char *argv[] )
1158 {
1159     FILE *cf;
1160     int padding_varies_by_pos = 0;
1161     struct { char a; double b; } char_double;
1162     struct { double b; char a; } double_char;
1163     int extent1, extent2;
1164
1165     extent1 = sizeof(char_double);
1166     extent2 = sizeof(double_char);
1167     if (extent1 != extent2) padding_varies_by_pos = 1;
1168
1169     cf = fopen( "ctest.out", "w" );
1170     if (padding_varies_by_pos) fprintf( cf, "yes\n" );
1171     else fprintf( cf, "no\n" );
1172
1173     fclose( cf );
1174     return 0;
1175 }],
1176 pac_cv_c_double_pos_align=`cat ctest.out`,
1177 pac_cv_c_double_pos_align="unknown",
1178 pac_cv_c_double_pos_align="$CROSS_ALIGN_DOUBLE_POS")
1179 rm -f ctest.out
1180 ])
1181 if test -z "$pac_cv_c_double_pos_align" ; then
1182     pac_cv_c_double_pos_align="unknown"
1183 fi
1184 ])
1185
1186 dnl Test for odd struct alignment rule that only applies max.
1187 dnl padding when long long int value is at front of type.
1188 dnl Puts result in pac_cv_c_llint_pos_align.
1189 dnl
1190 dnl Search for "Power alignment mode" for more details.
1191 dnl
1192 dnl Possible values include yes, no, and unknown.
1193 dnl
1194 AC_DEFUN([PAC_C_LLINT_POS_ALIGN],[
1195 AC_CACHE_CHECK([if alignment of structs with long long ints is based on position],
1196 pac_cv_c_llint_pos_align,[
1197 AC_TRY_RUN([
1198 #include <stdio.h>
1199 #define DBG(a,b,c)
1200 int main( int argc, char *argv[] )
1201 {
1202     FILE *cf;
1203     int padding_varies_by_pos = 0;
1204 #ifdef HAVE_LONG_LONG_INT
1205     struct { char a; long long int b; } char_llint;
1206     struct { long long int b; char a; } llint_char;
1207     int extent1, extent2;
1208
1209     extent1 = sizeof(char_llint);
1210     extent2 = sizeof(llint_char);
1211     if (extent1 != extent2) padding_varies_by_pos = 1;
1212 #endif
1213
1214     cf = fopen( "ctest.out", "w" );
1215     if (padding_varies_by_pos) fprintf( cf, "yes\n" );
1216     else fprintf( cf, "no\n" );
1217
1218     fclose( cf );
1219     return 0;
1220 }],
1221 pac_cv_c_llint_pos_align=`cat ctest.out`,
1222 pac_cv_c_llint_pos_align="unknown",
1223 pac_cv_c_llint_pos_align="$CROSS_ALIGN_LLINT_POS")
1224 rm -f ctest.out
1225 ])
1226 if test -z "$pac_cv_c_llint_pos_align" ; then
1227     pac_cv_c_llint_pos_align="unknown"
1228 fi
1229 ])
1230
1231 dnl/*D
1232 dnl PAC_FUNC_NEEDS_DECL - Set NEEDS_<funcname>_DECL if a declaration is needed
1233 dnl
1234 dnl Synopsis:
1235 dnl PAC_FUNC_NEEDS_DECL(headerfiles,funcname)
1236 dnl
1237 dnl Output Effect:
1238 dnl Sets 'NEEDS_<funcname>_DECL' if 'funcname' is not declared by the 
1239 dnl headerfiles.
1240 dnl
1241 dnl Approach:
1242 dnl Attempt to assign library function to function pointer.  If the function
1243 dnl is not declared in a header, this will fail.  Use a non-static global so
1244 dnl the compiler does not warn about an unused variable.
1245 dnl
1246 dnl Simply calling the function is not enough because C89 compilers allow
1247 dnl calls to implicitly-defined functions.  Re-declaring a library function
1248 dnl with an incompatible prototype is also not sufficient because some
1249 dnl compilers (notably clang-3.2) only produce a warning in this case.
1250 dnl
1251 dnl D*/
1252 AC_DEFUN([PAC_FUNC_NEEDS_DECL],[
1253 AC_CACHE_CHECK([whether $2 needs a declaration],
1254 pac_cv_func_decl_$2,[
1255 AC_TRY_COMPILE([$1
1256 void (*fptr)(void) = (void(*)(void))$2;],[],
1257 pac_cv_func_decl_$2=no,pac_cv_func_decl_$2=yes)])
1258 if test "$pac_cv_func_decl_$2" = "yes" ; then
1259 changequote(<<,>>)dnl
1260 define(<<PAC_FUNC_NAME>>, translit(NEEDS_$2_DECL, [a-z *], [A-Z__]))dnl
1261 changequote([, ])dnl
1262     AC_DEFINE_UNQUOTED(PAC_FUNC_NAME,1,[Define if $2 needs a declaration])
1263 undefine([PAC_FUNC_NAME])
1264 fi
1265 ])
1266
1267 dnl PAC_C_GNU_ATTRIBUTE - See if the GCC __attribute__ specifier is allow.
1268 dnl Use the following
1269 dnl #ifndef HAVE_GCC_ATTRIBUTE
1270 dnl #define __attribute__(a)
1271 dnl #endif
1272 dnl If *not*, define __attribute__(a) as null
1273 dnl
1274 dnl We start by requiring Gcc.  Some other compilers accept __attribute__
1275 dnl but generate warning messages, or have different interpretations 
1276 dnl (which seems to make __attribute__ just as bad as #pragma) 
1277 dnl For example, the Intel icc compiler accepts __attribute__ and
1278 dnl __attribute__((pure)) but generates warnings for __attribute__((format...))
1279 dnl
1280 AC_DEFUN([PAC_C_GNU_ATTRIBUTE],[
1281 AC_REQUIRE([AC_PROG_CC_GNU])
1282 if test "$ac_cv_prog_gcc" = "yes" ; then
1283     AC_CACHE_CHECK([whether __attribute__ allowed],
1284 pac_cv_gnu_attr_pure,[
1285 AC_TRY_COMPILE([int foo(int) __attribute__ ((pure));],[int a;],
1286 pac_cv_gnu_attr_pure=yes,pac_cv_gnu_attr_pure=no)])
1287 AC_CACHE_CHECK([whether __attribute__((format)) allowed],
1288 pac_cv_gnu_attr_format,[
1289 AC_TRY_COMPILE([int foo(char *,...) __attribute__ ((format(printf,1,2)));],[int a;],
1290 pac_cv_gnu_attr_format=yes,pac_cv_gnu_attr_format=no)])
1291     if test "$pac_cv_gnu_attr_pure" = "yes" -a "$pac_cv_gnu_attr_format" = "yes" ; then
1292         AC_DEFINE(HAVE_GCC_ATTRIBUTE,1,[Define if GNU __attribute__ is supported])
1293     fi
1294 fi
1295 ])
1296 dnl
1297 dnl Check for a broken install (fails to preserve file modification times,
1298 dnl thus breaking libraries.
1299 dnl
1300 dnl Create a library, install it, and then try to link against it.
1301 AC_DEFUN([PAC_PROG_INSTALL_BREAKS_LIBS],[
1302 AC_CACHE_CHECK([whether install breaks libraries],
1303 ac_cv_prog_install_breaks_libs,[
1304 AC_REQUIRE([AC_PROG_RANLIB])
1305 AC_REQUIRE([AC_PROG_INSTALL])
1306 AC_REQUIRE([AC_PROG_CC])
1307 ac_cv_prog_install_breaks_libs=yes
1308
1309 AC_COMPILE_IFELSE([
1310     AC_LANG_SOURCE([ int foo(int); int foo(int a){return a;} ])
1311 ],[
1312     if ${AR-ar} ${AR_FLAGS-cr} libconftest.a conftest.$OBJEXT >/dev/null 2>&1 ; then
1313         if ${RANLIB-:} libconftest.a >/dev/null 2>&1 ; then
1314             # Anything less than sleep 10, and Mac OS/X (Darwin) 
1315             # will claim that install works because ranlib won't complain
1316             sleep 10
1317             libinstall="$INSTALL_DATA"
1318             eval "libinstall=\"$libinstall\""
1319             if ${libinstall} libconftest.a libconftest1.a >/dev/null 2>&1 ; then
1320                 saved_LIBS="$LIBS"
1321                 LIBS="libconftest1.a"
1322                 AC_LINK_IFELSE([
1323                     AC_LANG_SOURCE([
1324 extern int foo(int);
1325 int main(int argc, char **argv){ return foo(0); }
1326                     ])
1327                 ],[
1328                     # Success!  Install works
1329                     ac_cv_prog_install_breaks_libs=no
1330                 ],[
1331                     # Failure!  Does install -p work?        
1332                     rm -f libconftest1.a
1333                     if ${libinstall} -p libconftest.a libconftest1.a >/dev/null 2>&1 ; then
1334                         AC_LINK_IFELSE([],[
1335                             # Success!  Install works
1336                             ac_cv_prog_install_breaks_libs="no, with -p"
1337                         ])
1338                     fi
1339                 ])
1340                 LIBS="$saved_LIBS"
1341             fi
1342         fi
1343     fi
1344 ])
1345 rm -f libconftest*.a
1346 ]) dnl Endof ac_cache_check
1347
1348 if test -z "$RANLIB_AFTER_INSTALL" ; then
1349     RANLIB_AFTER_INSTALL=no
1350 fi
1351 case "$ac_cv_prog_install_breaks_libs" in
1352     yes)
1353         RANLIB_AFTER_INSTALL=yes
1354     ;;
1355     "no, with -p")
1356         INSTALL_DATA="$INSTALL_DATA -p"
1357     ;;
1358     *)
1359     # Do nothing
1360     :
1361     ;;
1362 esac
1363 AC_SUBST(RANLIB_AFTER_INSTALL)
1364 ])
1365
1366 #
1367 # determine if the compiler defines a symbol containing the function name
1368 #
1369 # These tests check not only that the compiler defines some symbol, such
1370 # as __FUNCTION__, but that the symbol correctly names the function.
1371 #
1372 # Defines 
1373 #   HAVE__FUNC__      (if __func__ defined)
1374 #   HAVE_CAP__FUNC__  (if __FUNC__ defined)
1375 #   HAVE__FUNCTION__  (if __FUNCTION__ defined)
1376 #
1377 AC_DEFUN([PAC_CC_FUNCTION_NAME_SYMBOL],[
1378 AC_CACHE_CHECK([whether the compiler defines __func__],
1379 pac_cv_have__func__,[
1380 tmp_am_cross=no
1381 AC_RUN_IFELSE([
1382 AC_LANG_SOURCE([
1383 #include <string.h>
1384 int foo(void);
1385 int foo(void)
1386 {
1387     return (strcmp(__func__, "foo") == 0);
1388 }
1389 int main(int argc, char ** argv)
1390 {
1391     return (foo() ? 0 : 1);
1392 }
1393 ])
1394 ], pac_cv_have__func__=yes, pac_cv_have__func__=no,tmp_am_cross=yes)
1395 if test "$tmp_am_cross" = yes ; then
1396     AC_LINK_IFELSE([
1397     AC_LANG_SOURCE([
1398 #include <string.h>
1399 int foo(void);
1400 int foo(void)
1401 {
1402     return (strcmp(__func__, "foo") == 0);
1403 }
1404 int main(int argc, char ** argv)
1405 {
1406     return (foo() ? 0 : 1);
1407 }
1408     ])
1409 ], pac_cv_have__func__=yes, pac_cv_have__func__=no)
1410 fi
1411 ])
1412
1413 if test "$pac_cv_have__func__" = "yes" ; then
1414     AC_DEFINE(HAVE__FUNC__,,[define if the compiler defines __func__])
1415 fi
1416
1417 AC_CACHE_CHECK([whether the compiler defines __FUNC__],
1418 pac_cv_have_cap__func__,[
1419 tmp_am_cross=no
1420 AC_RUN_IFELSE([
1421 AC_LANG_SOURCE([
1422 #include <string.h>
1423 int foo(void);
1424 int foo(void)
1425 {
1426     return (strcmp(__FUNC__, "foo") == 0);
1427 }
1428 int main(int argc, char ** argv)
1429 {
1430     return (foo() ? 0 : 1);
1431 }
1432 ])
1433 ], pac_cv_have_cap__func__=yes, pac_cv_have_cap__func__=no,tmp_am_cross=yes)
1434 if test "$tmp_am_cross" = yes ; then
1435     AC_LINK_IFELSE([
1436     AC_LANG_SOURCE([
1437 #include <string.h>
1438 int foo(void);
1439 int foo(void)
1440 {
1441     return (strcmp(__FUNC__, "foo") == 0);
1442 }
1443 int main(int argc, char ** argv)
1444 {
1445     return (foo() ? 0 : 1);
1446 }
1447     ])
1448 ], pac_cv_have__func__=yes, pac_cv_have__func__=no)
1449 fi
1450 ])
1451
1452 if test "$pac_cv_have_cap__func__" = "yes" ; then
1453     AC_DEFINE(HAVE_CAP__FUNC__,,[define if the compiler defines __FUNC__])
1454 fi
1455
1456 AC_CACHE_CHECK([whether the compiler sets __FUNCTION__],
1457 pac_cv_have__function__,[
1458 tmp_am_cross=no
1459 AC_RUN_IFELSE([
1460 AC_LANG_SOURCE([
1461 #include <string.h>
1462 int foo(void);
1463 int foo(void)
1464 {
1465     return (strcmp(__FUNCTION__, "foo") == 0);
1466 }
1467 int main(int argc, char ** argv)
1468 {
1469     return (foo() ? 0 : 1);
1470 }
1471 ])
1472 ], pac_cv_have__function__=yes, pac_cv_have__function__=no,tmp_am_cross=yes)
1473 if test "$tmp_am_cross" = yes ; then
1474     AC_LINK_IFELSE([
1475     AC_LANG_SOURCE([
1476 #include <string.h>
1477 int foo(void);
1478 int foo(void)
1479 {
1480     return (strcmp(__FUNCTION__, "foo") == 0);
1481 }
1482 int main(int argc, char ** argv)
1483 {
1484     return (foo() ? 0 : 1);
1485 }
1486     ])
1487 ], pac_cv_have__func__=yes, pac_cv_have__func__=no)
1488 fi
1489 ])
1490
1491 if test "$pac_cv_have__function__" = "yes" ; then
1492     AC_DEFINE(HAVE__FUNCTION__,,[define if the compiler defines __FUNCTION__])
1493 fi
1494
1495 ])
1496
1497
1498 dnl Check structure alignment
1499 AC_DEFUN([PAC_STRUCT_ALIGNMENT],[
1500         # Initialize alignment checks
1501         is_packed=1
1502         is_two=1
1503         is_four=1
1504         is_eight=1
1505         is_largest=1
1506
1507         # See if long double exists
1508         AC_TRY_COMPILE(,[long double a;],have_long_double=yes,have_long_double=no)
1509
1510         # Get sizes of regular types
1511         AC_CHECK_SIZEOF(char)
1512         AC_CHECK_SIZEOF(int)
1513         AC_CHECK_SIZEOF(short)
1514         AC_CHECK_SIZEOF(long)
1515         AC_CHECK_SIZEOF(float)
1516         AC_CHECK_SIZEOF(double)
1517         AC_CHECK_SIZEOF(long double)
1518
1519         # char_int comparison
1520         AC_CHECK_SIZEOF(char_int, 0, [typedef struct { char a; int b; } char_int; ])
1521         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_int`
1522         extent=$ac_cv_sizeof_char_int
1523         if test "$size" != "$extent" ; then is_packed=0 ; fi
1524         if test "`expr $extent % $ac_cv_sizeof_int`" != "0" ; then is_largest=0 ; fi
1525         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1526         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1527         if test "$ac_cv_sizeof_int" = "8" -a "`expr $extent % 8`" != "0" ; then
1528            is_eight=0
1529         fi
1530
1531         # char_short comparison
1532         AC_CHECK_SIZEOF(char_short, 0, [typedef struct { char a; short b; } char_short; ])
1533         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_short`
1534         extent=$ac_cv_sizeof_char_short
1535         if test "$size" != "$extent" ; then is_packed=0 ; fi
1536         if test "`expr $extent % $ac_cv_sizeof_short`" != "0" ; then is_largest=0 ; fi
1537         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1538         if test "$ac_cv_sizeof_short" = "4" -a "`expr $extent % 4`" != "0" ; then
1539            is_four=0
1540         fi
1541         if test "$ac_cv_sizeof_short" = "8" -a "`expr $extent % 8`" != "0" ; then
1542            is_eight=0
1543         fi
1544
1545         # char_long comparison
1546         AC_CHECK_SIZEOF(char_long, 0, [typedef struct { char a; long b; } char_long; ])
1547         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_long`
1548         extent=$ac_cv_sizeof_char_long
1549         if test "$size" != "$extent" ; then is_packed=0 ; fi
1550         if test "`expr $extent % $ac_cv_sizeof_long`" != "0" ; then is_largest=0 ; fi
1551         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1552         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1553         if test "$ac_cv_sizeof_long" = "8" -a "`expr $extent % 8`" != "0" ; then
1554            is_eight=0
1555         fi
1556
1557         # char_float comparison
1558         AC_CHECK_SIZEOF(char_float, 0, [typedef struct { char a; float b; } char_float; ])
1559         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_float`
1560         extent=$ac_cv_sizeof_char_float
1561         if test "$size" != "$extent" ; then is_packed=0 ; fi
1562         if test "`expr $extent % $ac_cv_sizeof_float`" != "0" ; then is_largest=0 ; fi
1563         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1564         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1565         if test "$ac_cv_sizeof_float" = "8" -a "`expr $extent % 8`" != "0" ; then
1566            is_eight=0
1567         fi
1568
1569         # char_double comparison
1570         AC_CHECK_SIZEOF(char_double, 0, [typedef struct { char a; double b; } char_double; ])
1571         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_double`
1572         extent=$ac_cv_sizeof_char_double
1573         if test "$size" != "$extent" ; then is_packed=0 ; fi
1574         if test "`expr $extent % $ac_cv_sizeof_double`" != "0" ; then is_largest=0 ; fi
1575         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1576         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1577         if test "$ac_cv_sizeof_double" = "8" -a "`expr $extent % 8`" != "0" ; then
1578            is_eight=0
1579         fi
1580
1581         # char_long_double comparison
1582         if test "$have_long_double" = "yes"; then
1583         AC_CHECK_SIZEOF(char_long_double, 0, [
1584                                        typedef struct {
1585                                                char a;
1586                                                long double b;
1587                                        } char_long_double;
1588                                        ])
1589         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_long_double`
1590         extent=$ac_cv_sizeof_char_long_double
1591         if test "$size" != "$extent" ; then is_packed=0 ; fi
1592         if test "`expr $extent % $ac_cv_sizeof_long_double`" != "0" ; then is_largest=0 ; fi
1593         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1594         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1595         if test "$ac_cv_sizeof_long_double" = "8" -a "`expr $extent % 8`" != "0" ; then
1596            is_eight=0
1597         fi
1598         fi
1599
1600         # char_int_char comparison
1601         AC_CHECK_SIZEOF(char_int_char, 0, [
1602                                        typedef struct {
1603                                                char a;
1604                                                int b;
1605                                                char c;
1606                                        } char_int_char;
1607                                        ])
1608         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_int + $ac_cv_sizeof_char`
1609         extent=$ac_cv_sizeof_char_int_char
1610         if test "$size" != "$extent" ; then is_packed=0 ; fi
1611         if test "`expr $extent % $ac_cv_sizeof_int`" != "0" ; then is_largest=0 ; fi
1612         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1613         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1614         if test "$ac_cv_sizeof_int" = "8" -a "`expr $extent % 8`" != "0" ; then
1615            is_eight=0
1616         fi
1617
1618         # char_short_char comparison
1619         AC_CHECK_SIZEOF(char_short_char, 0, [
1620                                        typedef struct {
1621                                                char a;
1622                                                short b;
1623                                                char c;
1624                                        } char_short_char;
1625                                        ])
1626         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_short + $ac_cv_sizeof_char`
1627         extent=$ac_cv_sizeof_char_short_char
1628         if test "$size" != "$extent" ; then is_packed=0 ; fi
1629         if test "`expr $extent % $ac_cv_sizeof_short`" != "0" ; then is_largest=0 ; fi
1630         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1631         if test "$ac_cv_sizeof_short" = "4" -a "`expr $extent % 4`" != "0" ; then
1632            is_four=0
1633         fi
1634         if test "$ac_cv_sizeof_short" = "8" -a "`expr $extent % 8`" != "0" ; then
1635            is_eight=0
1636         fi
1637
1638         # If aligned mod 8, it will be aligned mod 4
1639         if test $is_eight = 1 ; then is_four=0 ; is_two=0 ; fi
1640         if test $is_four = 1 ; then is_two=0 ; fi
1641
1642         # Largest supersedes 8
1643         if test $is_largest = 1 ; then is_eight=0 ; fi
1644
1645         # Find the alignment
1646         if test "`expr $is_packed + $is_largest + $is_two + $is_four + $is_eight`" = "0" ; then
1647            pac_cv_struct_alignment="unknown"
1648         elif test "`expr $is_packed + $is_largest + $is_two + $is_four + $is_eight`" != "1" ; then
1649            pac_cv_struct_alignment="unknown"
1650         elif test $is_packed = 1 ; then
1651            pac_cv_struct_alignment="packed"
1652         elif test $is_largest = 1 ; then
1653            pac_cv_struct_alignment="largest"
1654         elif test $is_two = 1 ; then
1655            pac_cv_struct_alignment="two"
1656         elif test $is_four = 1 ; then
1657            pac_cv_struct_alignment="four"
1658         elif test $is_eight = 1 ; then
1659            pac_cv_struct_alignment="eight"
1660         fi
1661 ])
1662 dnl
1663 dnl PAC_C_MACRO_VA_ARGS
1664 dnl
1665 dnl will AC_DEFINE([HAVE_MACRO_VA_ARGS]) if the compiler supports C99 variable
1666 dnl length argument lists in macros (#define foo(...) bar(__VA_ARGS__))
1667 AC_DEFUN([PAC_C_MACRO_VA_ARGS],[
1668     AC_MSG_CHECKING([for variable argument list macro functionality])
1669     AC_LINK_IFELSE([AC_LANG_PROGRAM([
1670         #include <stdio.h>
1671         #define conftest_va_arg_macro(...) printf(__VA_ARGS__)
1672     ],
1673     [conftest_va_arg_macro("a test %d", 3);])],
1674     [AC_DEFINE([HAVE_MACRO_VA_ARGS],[1],[Define if C99-style variable argument list macro functionality])
1675      AC_MSG_RESULT([yes])],
1676     [AC_MSG_RESULT([no])])
1677 ])dnl
1678
1679 # Will AC_DEFINE([HAVE_BUILTIN_EXPECT]) if the compiler supports __builtin_expect.
1680 AC_DEFUN([PAC_C_BUILTIN_EXPECT],[
1681 AC_MSG_CHECKING([if C compiler supports __builtin_expect])
1682
1683 AC_TRY_LINK(, [
1684     return __builtin_expect(1, 1) ? 1 : 0
1685 ], [
1686     have_builtin_expect=yes
1687     AC_MSG_RESULT([yes])
1688 ], [
1689     have_builtin_expect=no
1690     AC_MSG_RESULT([no])
1691 ])
1692 if test x$have_builtin_expect = xyes ; then
1693     AC_DEFINE([HAVE_BUILTIN_EXPECT], [1], [Define to 1 if the compiler supports __builtin_expect.])
1694 fi
1695 ])