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