hwloc: null check for cpuset
[mpich-dev.git] / configure.ac
1 AC_PREREQ(2.63)
2
3 # (C) 2006 by Argonne National Laboratory.
4 #     See COPYRIGHT in top-level directory.
5 #
6 dnl Process this file with autoconf to produce a configure script.
7 dnl
8 dnl aclocal_cache.m4, included by sowing/confdb/aclocal.m4, fixes 
9 dnl bugs in autoconf caching.
10 dnl
11 dnl This is a large configure script and it is important to keep it
12 dnl clearly organized.  In addition, this script must coordinate with 
13 dnl the other modules that can be used to construct MPICH, such as
14 dnl the communication device and the process manager.  Each of these
15 dnl may have special features or limitations that other modules or
16 dnl this configure may need to take into account.  To handle this, there
17 dnl are xx major steps in this configure script:
18 dnl
19 dnl 1. Identify major modules and source any prerequisite scripts
20 dnl 2. Determine compiler characteristics 
21 dnl 3. Setup and configure the other modules
22 dnl 4. Determine MPI features and characteristics (such as datatype values)
23 dnl
24 dnl Each of these is described in more detail below.
25 dnl
26 dnl 1. Identify the modules (most are specified by 
27 dnl --with-<modulename>=instance,
28 dnl for example, --with-pm=hydra or --with-device=ch3:nemesis).
29 dnl For each module, source the file mpichprereq if present (in the
30 dnl module's top-level directory).  This
31 dnl must be a bourne (sh) shell script; it can access any of the variables
32 dnl in the configure script.  In addition, there are a few variables that
33 dnl are defined and provided to allow the modules to communicate their 
34 dnl needs or limitations to the other modules.  These are:
35 dnl    MPID_MAX_THREAD_LEVEL - thread level supported by device.
36 dnl                            if unset, is MPI_THREAD_FUNNELED
37 dnl    MPID_NO_LONG_LONG     - if yes, the device does not support the 
38 dnl                            long long integer type
39 dnl    MPID_NO_LONG_DOUBLE   - if yes, the device does not support the
40 dnl                            long double type
41 dnl    MPID_PM_NAMESERVER    - if set, provides the name of the nameserver
42 dnl                            that the process manager supports.
43 dnl                            This name server will be used if the
44 dnl                            default name server is selected.
45 dnl    MPID_NO_PM            - If yes, the device does not require any
46 dnl                            PM implementation.  
47 dnl    MPID_MAX_PROCESSOR_NAME - The maximum number of character in a processor
48 dnl                            name.  If not set, 128 will be used.
49 dnl    MPID_MAX_ERROR_STRING - The maximum number of character in an error
50 dnl                            string.  If not set, 1024 will be used.
51 dnl    MPID_LIBTOOL_STATIC_FLAG - The static compilation flag to use
52 dnl                               for the example executables within
53 dnl                               mpich.  If not set, -static will be
54 dnl                               used.
55 dnl    PM_REQUIRES_PMI       - if set, provides the name of the PMI 
56 dnl                            interface implementation.  If not set,
57 dnl                            the "simple" PMI implementation is used.
58 dnl                            A process manager that needs a particular
59 dnl                            process manager should check that this is
60 dnl                            not set to an incompatible value.
61 dnl    MPID_NO_SPAWN         - if yes, the device does not support the
62 dnl                            dynamic process routines (spawn, connect
63 dnl                            attach, join, plus port and publish 
64 dnl                            routines).  The major effect of this
65 dnl                            is to let the test codes know that
66 dnl                            spawn is not implemented.
67 dnl    MPID_NO_RMA           - if yes, the device does not support the
68 dnl                            MPI RMA routines (MPI_Win_create and 
69 dnl                            MPI_Put etc.).  The major effect of this
70 dnl                            is to let the test codes know that 
71 dnl                            RMA is not implemented.
72 dnl
73 dnl Note that the meanings of these variables are defined so that an 
74 dnl undefined value gives the default.  This makes it easy to expand
75 dnl the set of such variables, since only modules that need the new
76 dnl variable will need to be changed.
77 dnl
78 dnl 2. Determine compiler characteristics
79 dnl Here is where features of the compilers are determined, including
80 dnl support for shared libraries and sizes of the basic datatype types.
81 dnl
82 dnl 3. Setup and configure the other modules
83 dnl Before each module configure is executed, the script setup_<module>
84 dnl is run if present.  This is a bourne (sh) shell script and may
85 dnl access configure variables.  It should not make any changes to the
86 dnl compiler name or flags (e.g., do not add -D_XOPEN_SOURCE to CFLAGS here,
87 dnl because that may invalidate the determination of the compiler 
88 dnl characteristics in the prior step).
89 dnl
90 dnl 4. Determine MPI features
91 dnl    
92 dnl
93 dnl Special environment variables
94 dnl To let other scripts and in particular the configure in test/mpi
95 dnl know that they are being invoked from within the MPICH configure,
96 dnl the following environment variables are set and exported:
97 dnl    FROM_MPICH
98 dnl    MPICH_ENABLE_F77
99 dnl    MPICH_ENABLE_FC
100 dnl    MPICH_ENABLE_CXX
101 dnl
102 dnl Note that no executable statements are allowed (and any are silently 
103 dnl dropped) before AC_INIT.
104
105 m4_include([maint/version.m4])
106 dnl 2nd arg is intentionally underquoted
107 AC_INIT([MPICH],
108         MPICH_VERSION_m4,
109         [discuss@mpich.org],
110         [mpich],
111         [http://www.mpich.org/])
112
113 if test "x$prefix" != "xNONE" && test -d "$prefix"; then 
114     if test "x`(cd \"$prefix\"; echo \"$PWD\")`" = "x`(cd \"$srcdir\"; echo \"$PWD\")`" ||\
115        test "x`(cd \"$prefix\"; echo \"$PWD\")`" = "x$PWD"  ; then
116         AC_MSG_ERROR([The install directory (--prefix=) cannot be the same as the build or src directory.])
117     fi
118 fi         
119
120 CONFIGURE_ARGS_CLEAN=`echo $* | tr '"' ' '`
121 AC_SUBST(CONFIGURE_ARGS_CLEAN)
122
123 # these values come from the m4_include above
124 MPICH_VERSION=MPICH_VERSION_m4
125 AC_SUBST([MPICH_VERSION])
126 MPICH_RELEASE_DATE="MPICH_RELEASE_DATE_m4"
127 AC_SUBST([MPICH_RELEASE_DATE])
128 libmpi_so_version="libmpi_so_version_m4"
129 AC_SUBST([libmpi_so_version])
130
131
132 if test -z "$MPICH_VERSION" ; then
133     AC_MSG_ERROR([MPICH_VERSION is empty, check maint/version.m4 for errors])
134 fi
135 # Produce a numeric version assuming the following format:
136 # Version: [MAJ].[MIN].[REV][EXT][EXT_NUMBER]
137 # Example: 1.0.7rc1 has
138 #          MAJ = 1
139 #          MIN = 0
140 #          REV = 7
141 #          EXT = rc
142 #          EXT_NUMBER = 1
143 #
144 # Converting to numeric version will convert EXT to a format number:
145 #          ALPHA (a) = 0
146 #          BETA (b)  = 1
147 #          RC (rc)   = 2
148 #          PATCH (p) = 3
149 # Regular releases are treated as patch 0
150 #
151 # Numeric version will have 1 digit for MAJ, 2 digits for MIN,
152 # 2 digits for REV, 1 digit for EXT and 2 digits for EXT_NUMBER.
153 changequote(<<,>>)
154 V1=`expr $MPICH_VERSION : '\([0-9]*\)\.[0-9]*\.*[0-9]*[a-zA-Z]*[0-9]*'`
155 V2=`expr $MPICH_VERSION : '[0-9]*\.\([0-9]*\)\.*[0-9]*[a-zA-Z]*[0-9]*'`
156 V3=`expr $MPICH_VERSION : '[0-9]*\.[0-9]*\.*\([0-9]*\)[a-zA-Z]*[0-9]*'`
157 V4=`expr $MPICH_VERSION : '[0-9]*\.[0-9]*\.*[0-9]*\([a-zA-Z]*\)[0-9]*'`
158 V5=`expr $MPICH_VERSION : '[0-9]*\.[0-9]*\.*[0-9]*[a-zA-Z]*\([0-9]*\)'`
159 changequote([,])
160
161 if test "$V2" -le 9 ; then V2=0$V2 ; fi
162 if test "$V3" = "" ; then V3=0; fi
163 if test "$V3" -le 9 ; then V3=0$V3 ; fi
164 if test "$V4" = "a" ; then
165     V4=0
166 elif test "$V4" = "b" ; then
167     V4=1
168 elif test "$V4" = "rc" ; then
169     V4=2
170 elif test "$V4" = "" ; then
171     V4=3
172     V5=0
173 elif test "$V4" = "p" ; then
174     V4=3
175 fi
176 if test "$V5" -le 9 ; then V5=0$V5 ; fi
177
178 MPICH_NUMVERSION=`expr $V1$V2$V3$V4$V5 + 0`
179 AC_SUBST(MPICH_NUMVERSION)
180
181 AC_ARG_WITH(custom-version-string,
182             AC_HELP_STRING([--with-custom-version-string], [Adds a user-specified value to the output of the mpichversion executable]),,with_custom_version_string="")
183 MPICH_CUSTOM_STRING=$with_custom_version_string
184 AC_SUBST(MPICH_CUSTOM_STRING)
185
186 # ABIVERSION is the name used by simplemake, so we reassign the
187 # libmpi_so_version number to it
188 ABIVERSION=${libmpi_so_version}
189 export ABIVERSION
190 export libmpi_so_version
191 AC_SUBST(ABIVERSION)
192
193 # Print out the configure options
194 CONFIGURE_ARGUMENTS="$ac_configure_args"
195 AC_SUBST(CONFIGURE_ARGUMENTS)
196 if test -n "$ac_configure_args" ; then
197     echo "Configuring MPICH version $MPICH_VERSION with $ac_configure_args"
198 else 
199     echo "Configuring MPICH version $MPICH_VERSION"
200 fi
201
202 # Add the information on the system:
203 echo "Running on system: `uname -a`"
204
205 dnl Definitions will be placed in this file rather than in the DEFS variable
206 AC_CONFIG_HEADER(src/include/mpichconf.h)
207 AH_TOP([/* -*- Mode: C; c-basic-offset:4 ; -*- */
208 /*
209  *  (C) 2001 by Argonne National Laboratory.
210  *      See COPYRIGHT in top-level directory.
211  */
212 #ifndef MPICHCONF_H_INCLUDED
213 #define MPICHCONF_H_INCLUDED
214 ])
215
216 # We use an #include strategy here because all of the alternative strategies for
217 # quashing these variables have various drawbacks.  The alternatives are listed
218 # here to avoid rediscovery of these problems by someone else in the future:
219 #
220 # 1) Strategy: Rewrite mpichconf.h.in with sed at autogen.sh time.
221 #    Problem: Automatic remaking of config.status and friends will re-run
222 #             autoheader and blow away our sed changes without an opportunity to
223 #             patch the resulting file again.
224 # 2) Strategy: Add literal "#undef PACKAGE" lines to the AH_BOTTOM text.
225 #    Problem: These lines get rewritten by config.status to be "#define" lines,
226 #             so the intended quashing never actually occurs.
227 # 3) Strategy: Use AC_CONFIG_COMMANDS to run a sed rewrite command on
228 #              mpichconf.h at config.status time.
229 #    Problem: Causes mpichconf.h to always be rewritten, first by the normal
230 #             config.status commands and then by sed.  This can cause
231 #             unnecessary remaking of object files since nearly every C source
232 #             file includes this header (see the Autoconf Manual, "Automatic
233 #             Remaking")
234 #
235 # The only other plausible strategy would seem to be rewriting config.status
236 # itself via AC_CONFIG_COMMANDS_POST, but that seems error prone.  The best
237 # solution would be to stop all subconfigures from including config.h headers
238 # from other packages.  Then all of this nonsense can be eliminated.
239 # [goodell@ 2011-08-26]
240 AH_BOTTOM([
241 /* Include nopackage.h to undef autoconf-defined macros that cause conflicts in
242  * subpackages.  This should not be necessary, but some packages are too
243  * tightly intertwined right now (such as ROMIO and the MPICH core) */
244 #include "nopackage.h"
245
246 #endif /* !defined(MPICHCONF_H_INCLUDED) */
247 ])
248
249 dnl Set the directory that contains support scripts such as install-sh and
250 dnl config.guess
251 AC_CONFIG_AUX_DIR(confdb)
252 dnl our macro dir is the same as our aux dir
253 AC_CONFIG_MACRO_DIR([confdb])
254
255 # Set the FROM_MPICH variable to tell subconfigures that they are
256 # built from within MPICH
257 FROM_MPICH=yes
258 export FROM_MPICH
259
260 # Save a copy of precious flags as USER_* before any of these flags
261 # are being modified by configure tests.
262 PAC_PREFIX_ALL_FLAGS(USER)
263
264 # WRAPPER_xFLAGS are used by mpicc and friends.
265 #
266 # WRAPPER_CFLAGS and other compile flags are used for compile options
267 # that are added by MPICH, but should be used by applications (such
268 # as include paths).
269 #
270 # All libraries that are detected by MPICH as needed for some of its
271 # functionality (such as -lpthread) should be added to WRAPPER_LIBS
272 # so executables built within MPICH use them.  If inter-library
273 # dependencies are not supported on the platform, these libraries are
274 # added to the MPICH wrappers (mpicc and friends) as well.
275 PAC_PREFIX_ALL_FLAGS(WRAPPER)
276
277 # MPICH_MPIx_FLAGS are used by mpicc and friends.  They are like
278 # WRAPPER flags, but these are provided by the user.
279 AC_SUBST(MPICH_MPICC_CPPFLAGS)
280 AC_SUBST(MPICH_MPICC_CFLAGS)
281 AC_SUBST(MPICH_MPICC_LDFLAGS)
282 AC_SUBST(MPICH_MPICC_LIBS)
283
284 AC_SUBST(MPICH_MPICXX_CPPFLAGS)
285 AC_SUBST(MPICH_MPICXX_CXXFLAGS)
286 AC_SUBST(MPICH_MPICXX_LDFLAGS)
287 AC_SUBST(MPICH_MPICXX_LIBS)
288
289 AC_SUBST(MPICH_MPIF77_CPPFLAGS)
290 AC_SUBST(MPICH_MPIF77_FFLAGS)
291 AC_SUBST(MPICH_MPIF77_LDFLAGS)
292 AC_SUBST(MPICH_MPIF77_LIBS)
293
294 AC_SUBST(MPICH_MPIFORT_CPPFLAGS)
295 AC_SUBST(MPICH_MPIFORT_FCFLAGS)
296 AC_SUBST(MPICH_MPIFORT_LDFLAGS)
297 AC_SUBST(MPICH_MPIFORT_LIBS)
298
299 # Add MPICHLIB_* to the appropriate flags
300 AC_ARG_VAR(MPICHLIB_CFLAGS,
301         [extra CFLAGS used in building MPICH libraries])
302 AC_ARG_VAR(MPICHLIB_CPPFLAGS,
303         [extra CPPFLAGS used in building MPICH libraries])
304 AC_ARG_VAR(MPICHLIB_CXXFLAGS,
305         [extra CXXFLAGS used in building MPICH libraries])
306 AC_ARG_VAR(MPICHLIB_FFLAGS,
307         [extra FFLAGS used in building MPICH libraries])
308 AC_ARG_VAR(MPICHLIB_FCFLAGS,
309         [extra FCFLAGS used in building MPICH libraries])
310 CFLAGS="$CFLAGS $MPICHLIB_CFLAGS"
311 CPPFLAGS="$CPPFLAGS $MPICHLIB_CPPFLAGS"
312 CXXFLAGS="$CXXFLAGS $MPICHLIB_CXXFLAGS"
313 FFLAGS="$FFLAGS $MPICHLIB_FFLAGS"
314 FCFLAGS="$FCFLAGS $MPICHLIB_FCFLAGS"
315
316 dnl include all subsystem m4 fragments now that the core autoconf functionality
317 dnl has been setup.  No fragment should do anything except define
318 dnl PAC_SUBCFG_{PREREQ,BODY} macros which will be expanded later as
319 dnl appropriate
320 # begin subsys includes
321 m4_include([subsys_include.m4])
322 # end subsys includes
323
324 dnl ----------------------------------------------------------------------------
325 dnl setup top-level argument handling
326 AC_ARG_ENABLE(echo, 
327         AC_HELP_STRING([--enable-echo], [Turn on strong echoing. The default is enable=no.]),
328         set -x)
329
330 AC_ARG_ENABLE(error-checking,
331 [  --enable-error-checking=level
332       Control the amount of error checking.  
333         no        - no error checking
334         runtime   - error checking controllable at runtime through environment 
335                     variables
336         all       - error checking always enabled (default)
337 ],,enable_error_checking=all)
338
339 AC_ARG_ENABLE(error-messages,
340 [  --enable-error-messages=level - Control the amount of detail in error messages.
341         all       - Maximum amount of information
342         generic   - Only generic messages (no information about the specific
343                     instance)
344         class     - One message per MPI error class
345         none      - No messages
346 ],,enable_error_messages=all)
347
348 AC_ARG_ENABLE(tag-error-bits,
349 [  --enable-tag-error-bits=yes|no - Control whether bits are taken from the user tag for error handling.
350         yes       - Two bits are taken from the user tag to support error propagation.
351         no        - No bits are taken from the user tag (this could cause deadlock if an error is detected during a collective).
352 ],,enable_tag_error_bits=yes)
353
354 AC_ARG_ENABLE(timing,
355 [  --enable-timing=level - Control the amount of timing information
356                            collected by the MPICH implementation.
357         none    - Collect no data (default)
358         all     - Collect lots of data
359         runtime - Runtime control of data collected
360 ],,enable_timing=default)
361
362 AC_ARG_ENABLE(g,
363 [  --enable-g=option - Control the level of debugging support in the
364                        MPICH implementation.  "option" is a list of comma
365                        separated names including.  Default is "most".
366         none     - No debugging
367         handle   - Trace handle operations
368         handlealloc - Trace handle allocations
369         dbg      - Add compiler flag, -g, to all internal
370                    compiler flags, i.e. MPICHLIB_CFLAGS, MPICHLIB_CXXFLAGS,
371                    MPICHLIB_FFLAGS, and MPICHLIB_FCFLAGS.
372         debug    - Synonym for dbg
373         mem      - Memory usage tracing
374         meminit  - Preinitialize memory associated structures and unions to
375                    eliminate access warnings from programs like valgrind
376         memarena - Check for overwrite errors in memory allocation arena
377         mutex    - Enable error checking on pthread mutexes
378         mutexnesting - Check for non-nesting of mutexes
379         most     - Most of the above options, excluding some with severe
380                    performance impacts.  Recommended for typical development.
381         yes      - synonym for "most" (*not* "all")
382         all      - All of the above choices
383 ],,enable_g=none)
384
385 AC_ARG_ENABLE([mpit_pvars],
386 [  --enable-mpit-pvars=list - Selectively enable MPI_T performance variables in
387                       modules. list is a comma-separated module names,
388                       including (Default is "none"):
389         none     - No performance info recorded
390         recvq    - All message queue-related
391         nem      - All nemesis-related
392         rma      - All rma-related
393         all      - All variables above
394 ],[],[enable_mpit_pvars=none])
395
396 dnl We may want to force MPI_Aint to be the same size as MPI_Offset, 
397 dnl particularly on 32 bit systems with large (64 bit) file systems.
398 AC_ARG_WITH(aint-size,
399         AC_HELP_STRING([--with-aint-size], [Override the size of MPI_AINT (in bytes)]),,
400         with_aint_size=0)
401
402 AC_ARG_ENABLE(fast,
403 [  --enable-fast=option - Control the level of fast execution in the
404                          MPICH implementation.  option is a list of
405                          comma separated names including
406         O<n>     - Appends default optimization flags, -O<n>, to all internal
407                    compiler flags, i.e. MPICHLIB_CFLAGS, MPICHLIB_CXXFLAGS,
408                    MPICHLIB_FFLAGS, and MPICHLIB_FCFLAGS. (default is -O2)
409         ndebug   - Appends -DNDEBUG to MPICHLIB_CFLAGS.
410         all|yes  - "O2" and "ndebug" are enabled
411         none     - None of above options, i.e. --disable-fast
412 ],,enable_fast=O2)
413
414 AC_ARG_ENABLE(interlib-deps,
415         [AC_HELP_STRING([--enable-interlib-deps - Enable interlibrary dependencies])],,enable_interlib_deps=yes)
416
417 AC_ARG_ENABLE(check-compiler-flags,
418         AC_HELP_STRING([--enable-check-compiler-flags], [enable the checks for all compiler
419                        options, xxxFLAGS, MPICH_xxxFLAGS. Default is on.]),,
420                        enable_check_compiler_flags=yes)
421
422 dnl We enable f77 and fc if we can find compilers for them.
423 dnl In addition, we check whether f77 and fc can work together.
424 AC_ARG_ENABLE(fortran,
425 [  --enable-fortran=option - Control the level of Fortran support in the MPICH implementation.
426         yes|all   - Enable all available Fortran implementations (F77, F90+)
427         f77       - Enable Fortran 77 support
428         fc        - Enable Fortran 90 and 2008 support
429         no|none   - No Fortran support
430 ],,[enable_fortran=all])
431
432 AC_ARG_ENABLE(f77,
433         AC_HELP_STRING([--enable-f77],
434                 [DEPRECATED: Use --enable-fortran or --disable-fortran instead]),,[enable_f77=yes])
435
436 AC_ARG_ENABLE(fc,
437         AC_HELP_STRING([--enable-fc],
438                 [DEPRECATED: Use --enable-fortran or --disable-fortran instead]),,[enable_fc=yes])
439
440 AC_ARG_ENABLE(cxx,
441         AC_HELP_STRING([--enable-cxx], [Enable C++ bindings]),,enable_cxx=yes)
442
443 AC_ARG_ENABLE(romio,
444         AC_HELP_STRING([--enable-romio], [Enable ROMIO MPI I/O implementation]),,
445         enable_romio=yes)
446
447 AC_ARG_ENABLE(debuginfo,
448         AC_HELP_STRING([--enable-debuginfo], [Enable support for debuggers]),,
449         enable_debuginfo=no)
450
451
452 ## Enable creation of libtool-style versioning or no versioning
453 AC_ARG_ENABLE(versioning,
454         [AC_HELP_STRING([--enable-versioning],[Enable library versioning])],,
455         [enable_versioning=yes])
456
457 if test "$enable_versioning" = "yes" ; then
458    ABIVERSIONFLAGS="-version-info \$(ABIVERSION)"
459 else
460    ABIVERSIONFLAGS="-avoid-version"
461 fi
462 export ABIVERSIONFLAGS
463 AC_SUBST(ABIVERSIONFLAGS)
464
465
466 dnl The environment variable MPICH_DEBUGLIBNAME may be used to
467 dnl override the default name of the library that the debugger will
468 dnl load to access the MPICH internal data structures.
469
470 dnl "default" is a special device that allows MPICH to choose one
471 dnl based on the environment.
472 AC_ARG_WITH(device,
473         AC_HELP_STRING([--with-device=name], [Specify the communication device for MPICH]),,
474         with_device=default)
475
476 AC_ARG_WITH(pmi,
477         AC_HELP_STRING([--with-pmi=name], [Specify the pmi interface for MPICH]),,
478         with_pmi=default)
479
480 AC_ARG_WITH(pm, 
481         AC_HELP_STRING([--with-pm=name],
482                 [Specify the process manager for MPICH.  "no" or "none" are
483                  valid values.  Multiple process managers may be specified as
484                  long as they all use the same pmi interface by separating them
485                  with colons.  The mpiexec for the first named process manager
486                  will be installed.  Example: "--with-pm=hydra:gforker"
487                  builds the two process managers hydra, and gforker;
488                  only the mpiexec from hydra is installed into the bin
489                  directory.]),,with_pm=default)
490
491 AC_ARG_WITH(logging,
492         AC_HELP_STRING([--with-logging=name], [Specify the logging library for MPICH]),
493         [if test -z "$withval" ; then with_logging=rlog ; fi],with_logging=none)
494
495 AC_ARG_ENABLE(threads,
496 [  --enable-threads=level - Control the level of thread support in the 
497                            MPICH implementation.  The following levels
498                            are supported.
499         single          - No threads (MPI_THREAD_SINGLE)
500         funneled        - Only the main thread calls MPI (MPI_THREAD_FUNNELED)
501         serialized      - User serializes calls to MPI (MPI_THREAD_SERIALIZED)
502         multiple        - Fully multi-threaded (MPI_THREAD_MULTIPLE)
503         runtime         - Alias to "multiple"
504
505         See also the --enable-thread-cs option for controlling the granularity of
506         the concurrency inside of the library
507 ],,enable_threads=default)
508
509 AC_ARG_ENABLE(thread-cs,
510         AC_HELP_STRING([--enable-thread-cs=type],
511                         [Choose the method used for critical sections
512                          and other atomic updates when multiple
513                          threads are present.  Values may be global
514                          (default), per-object, lock-free]),,enable_thread_cs=global)
515
516 AC_ARG_ENABLE(refcount,
517         AC_HELP_STRING([--enable-refcount=type],
518                         [Choose the method for ensuring atomic updates
519                          to the reference counts for MPI objects.
520                          Values may be lock-free or none.  The
521                          default depends on the thread-cs choice; for
522                          global it is none (because none is required),
523                          for per-object and lock-free, lock-free]),,
524                          enable_refcount=default)
525
526 AC_ARG_ENABLE(mutex-timing,
527         AC_HELP_STRING([--enable-mutex-timing], [calculate the time spent waiting on mutexes]),
528         AC_DEFINE(MPIU_MUTEX_WAIT_TIME,1,[Define to enable timing mutexes]))
529
530 AC_ARG_ENABLE([predefined-refcount],
531         AS_HELP_STRING([--enable-predefined-refcount],
532                        [control whether predefined objects like
533                        MPI_COMM_WORLD are reference counted (default
534                        depends on --enable-thread-cs choice)]),[],
535               [enable_predefined_refcount=default])
536
537 AC_ARG_ENABLE(weak-symbols,
538         AC_HELP_STRING([--enable-weak-symbols],
539                         [Use weak symbols to implement PMPI routines (default)]),,
540                 enable_weak_symbols=yes)
541
542 AC_ARG_ENABLE([two-level-namespace],
543               [AS_HELP_STRING([--enable-two-level-namespace],
544                               [(Darwin only) Build shared libraries and programs
545                                built with the mpicc/mpifort/etc. compiler
546                                wrappers with '-Wl,-commons,use_dylibs' and
547                                without '-Wl,-flat_namespace'.  This may make the
548                                MPICH installation and MPI programs more
549                                compatible with other libraries.  Only enable
550                                this option if you really know what these linker
551                                options imply.])],
552               [],
553               [enable_two_level_namespace=no])
554
555 AC_ARG_ENABLE(multi-aliases,
556         AC_HELP_STRING([--enable-multi-aliases],
557                 [Multiple aliasing to support multiple fortran compilers (default)]),,
558                 enable_multi_aliases=yes)
559
560 AC_ARG_ENABLE([wrapper-rpath],
561               [AC_HELP_STRING([--enable-wrapper-rpath],
562                               [Determine whether the rpath is set when programs
563                                are linked by mpicc compiler wrappers.  This only
564                                applies when shared libraries are built.  The
565                                default is yes; use --disable-wrapper-rpath to
566                                turn this feature off.  In that case, shared
567                                libraries will be found according to the rules
568                                for your system (e.g., in LD_LIBRARY_PATH)])],
569               [],[enable_wrapper_rpath=yes])
570 AC_SUBST([enable_wrapper_rpath])
571
572 AC_ARG_ENABLE([long-double],
573               [AC_HELP_STRING([--disable-long-double],
574                               [Pass --disable-long-double to prevent the MPI
575                                library from supporting the C "long double" type,
576                                even if the C compiler supports it.  "long
577                                double" support is enabled by default, provided
578                                the compiler supports it.])],
579               [],
580               [enable_long_double=yes])
581
582 AC_ARG_WITH(cross,
583         AC_HELP_STRING([--with-cross=file],
584                 [Specify the values of variables that configure cannot
585                  determine in a cross-compilation environment]),,
586                  with_cross=$MPID_DEFAULT_CROSS_FILE)
587
588 AC_ARG_WITH(namepublisher,
589 [  --with-namepublisher=name   Choose the system that will support 
590                               MPI_PUBLISH_NAME and MPI_LOOKUP_NAME.  Options
591                               include
592                                    pmi (default)
593                                    file[:directory] (optional directory)
594                                    no (no service available)],,with_namepublisher=default)
595 AC_ARG_WITH(name-publisher,
596     [],
597     with_namepublisher=$with_name_publisher,)
598
599 AC_ARG_ENABLE(dbg-nolocal, AC_HELP_STRING([--enable-dbg-nolocal], [enables debugging mode where shared-memory communication is disabled]),
600     AC_DEFINE(ENABLED_NO_LOCAL, 1, [Define to disable shared-memory communication for debugging]))
601
602 AC_ARG_ENABLE(dbg-localoddeven, AC_HELP_STRING([--enable-dbg-localoddeven], [enables debugging mode where shared-memory communication is enabled only between even processes or odd processes on a node]),
603     AC_DEFINE(ENABLED_ODD_EVEN_CLIQUES, 1, [Define to enable debugging mode where shared-memory communication is done only between even procs or odd procs]))
604
605 AC_CANONICAL_TARGET
606
607 # Find a C compiler.
608 # We also need to do this before the F77 and FC test to ensure that we
609 # find the C preprocessor reliably.
610 PAC_PROG_CC
611 AM_PROG_CC_C_O dnl needed for automake "silent-rules"
612 PAC_PUSH_FLAG([CFLAGS])
613 AC_PROG_CPP
614 # Bug in autoconf.  Restore cross settings
615 if test "$pac_cross_compiling" = "yes" -a "$ac_cv_prog_cc_cross" = "no" ; then
616     AC_MSG_RESULT([Resetting cross compilation to yes])
617     cross_compiling=yes
618     ac_cv_prog_cc_cross=yes
619     ac_cv_prog_f77_cross=yes
620     ac_cv_prog_fc_cross=yes
621     ac_cv_prog_cxx_cross=yes
622 fi
623 PAC_POP_FLAG([CFLAGS])
624
625 # also needed by hwloc in embedded mode, must also come early for expansion
626 # ordering reasons
627 AC_USE_SYSTEM_EXTENSIONS
628
629 dnl now that autoconf and core compilers are setup, init automake and libtool
630 dnl
631 dnl We would like to pass -Werror, but we are cheating in the "examples/"
632 dnl directory and overriding the user-flags like CFLAGS, which automake-1.12
633 dnl warns about.  Long-term we may need to use a hand-written Makefile.in or
634 dnl something else in this special dir.
635 AM_INIT_AUTOMAKE([-Wall -Wno-portability-recursive foreign 1.12.3 silent-rules subdir-objects])
636 AM_MAINTAINER_MODE([enable])
637
638 AM_PROG_AR
639
640 LT_INIT()
641 # Non-verbose make by default
642 m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
643
644 # Disable rpath in the compiler wrappers if shared libraries are disabled, since
645 # rpath makes no sense in the context of static libraries.
646 if test "X$enable_shared" = "Xno" ; then
647     enable_wrapper_rpath=no
648 fi
649
650 INTERLIB_DEPS=yes
651 # We conservatively disable interlibrary dependencies if the libtool
652 # support model is anything different from "pass_all"
653 if test "X$enable_shared" = "Xno" -o "$deplibs_check_method" != "pass_all" -o "$enable_interlib_deps" = "no" ; then
654     INTERLIB_DEPS=no
655 fi
656 export INTERLIB_DEPS
657 AC_SUBST(INTERLIB_DEPS)
658
659 dnl AC_PROG_{CXX,F77,FC} must come early in configure.ac in order to avoid some
660 dnl esoteric autoconf macro expansion errors
661 dnl
662 dnl Also, DO NOT attempt to place shell conditionals (either manually or via
663 dnl AS_IF) around these macros in an effort to save configure time.  It will
664 dnl lead to weird AM_CONDITIONAL errors and potentially other problems.
665
666 # Before attempting to find valid compilers, set the corresponding precious
667 # shell variable to "no" for any languages that have been disabled by the user
668 # with "--disable-LANG".  Libtool understands this as a request to disable
669 # support for this language. This should save a bit of configure time and also
670 # prevent user complaints like ticket #1570.
671 AS_IF([test "x$enable_f77" = "xno"],[F77=no])
672 AS_IF([test "x$enable_fc"  = "xno"],[FC=no])
673 AS_IF([test "x$enable_cxx" = "xno"],[CXX=no])
674
675 # suppress default "-g -O2" from AC_PROG_CXX
676 : ${CXXFLAGS=""}
677 AC_PROG_CXX([PAC_CXX_SEARCH_LIST])
678
679 # suppress default "-g -O2" from AC_PROG_FC
680 : ${FCFLAGS=""}
681 AC_PROG_FC([PAC_FC_SEARCH_LIST])
682
683 save_IFS="$IFS"
684 IFS=","
685 enable_f77=no
686 enable_fc=no
687 for option in $enable_fortran ; do
688     case "$option" in
689         yes|all)
690                 enable_f77=yes
691                 enable_fc=yes
692                 ;;
693         no|none)
694                 ;;
695         f77)
696                 enable_f77=yes
697                 ;;
698         fc)
699                 enable_fc=yes
700                 ;;
701         *)
702                 IFS="$save_IFS"
703                 AC_MSG_WARN([Unknown value $option for --enable-fortran])
704                 IFS=","
705                 ;;
706     esac
707 done
708 IFS="$save_IFS"
709
710 if test "$enable_f77" = "no" ; then
711    if test "$enable_fc" = "yes" ; then
712       AC_MSG_ERROR([Fortran 90 support requires enabling Fortran 77])
713    fi
714 fi
715
716 if test ! -z "$FC" -a -z "$F77" ; then
717    F77=$FC
718    if test ! -z "$FCFLAGS" -a -z "$FFLAGS" ; then
719       FFLAGS=$FCFLAGS
720    fi
721 fi
722
723 AM_CONDITIONAL([INSTALL_MPIF77],[test "$F77" != "$FC" -a "$FFLAGS" != "$FCFLAGS"])
724
725 # This needs to come after we've potentially set F77=$FC. Otherwise, we could
726 # override the user's Fortran compiler selection when only specifying FC at configure
727 # time, as is allowed.
728 # suppress default "-g -O2" from AC_PROG_F77
729 : ${FFLAGS=""}
730 AC_PROG_F77([PAC_F77_SEARCH_LIST])
731
732 # compute canonical system types
733 AC_CANONICAL_BUILD
734 AC_CANONICAL_HOST
735 # TARGET not needed, MPICH isn't a compiler
736
737 # Enable better caching control
738 PAC_ARG_CACHING
739
740 # Set CFLAGS for enable strict if necessary.  Do this *first* because
741 # it may influence the output of the other tests
742 PAC_ARG_STRICT
743
744 # -----------------------------------------------------------------------------
745 # First check that we have a clean build if we are doing a VPATH build
746 PAC_VPATH_CHECK(src/include/mpi.h src/env/mpicc,lib)
747
748 # ----------------------------------------------------------------------------
749 # This test is complicated by the fact that top_srcdir is not set until
750 # the very end of configure.  Instead, we get it ourselves
751 if test -z "$top_srcdir" ; then
752    use_top_srcdir=$srcdir   
753 else
754    use_top_srcdir=$top_srcdir
755 fi
756 if test -z "$master_top_srcdir" ; then 
757     # This needs to be an absolute pathname
758     case "$use_top_srcdir" in
759     /*) ;;
760     *)
761         use_top_srcdir=`(cd $use_top_srcdir && pwd)`
762         ;;      
763     esac
764     master_top_srcdir=$use_top_srcdir
765 fi
766 # Get the directory that we're running in...
767 if test -z "$master_top_builddir" ; then
768    master_top_builddir="`pwd`"
769 fi
770 AC_SUBST(master_top_builddir)
771 AC_SUBST(master_top_srcdir)
772 export master_top_builddir
773 export master_top_srcdir
774
775 if test -z "$with_cross"; then
776   if test -f "$master_top_srcdir/src/cross/$host_alias"; then
777     with_cross="$master_top_srcdir/src/cross/$host_alias"
778   else
779     with_cross=no
780   fi
781 fi
782 if test "$with_cross" != "no"; then
783   AC_MSG_NOTICE([Using cross file: $with_cross])
784 fi
785
786 # ----------------------------------------------------------------------------
787 dnl Export important "precious" variables so that any directories configured via
788 dnl PAC_CONFIG_SUBDIR will agree with the top-level configure about these
789 dnl critical variables (esp. compiler selection).  These exports should come
790 dnl before any subconfigures in this script.
791 dnl
792 dnl This list is arguably incomplete, and should possibly be automatically
793 dnl generated from "$ac_precious_vars" using code similar to the implementation
794 dnl of PAC_CONFIG_SUBDIR.
795 dnl
796 dnl To be clear, without these exports any variable values determined by this
797 dnl configure script will not be seen by child scripts.  Instead they will dnl
798 dnl receive the only the original inherited environment and configure args used
799 dnl when this configure script was invoked.
800 export AR
801 export AR_FLAGS
802 export CC
803 export CFLAGS
804 export CPPFLAGS
805 export CXX
806 export CXXFLAGS
807 export F77
808 export FC
809 export FCFLAGS
810 export FFLAGS
811 export LDFLAGS
812 export LIBS
813 export MPILIBNAME
814 export PMPILIBNAME
815 export RANLIB
816 export OPALIBNAME
817 export MPLLIBNAME
818 # ----------------------------------------------------------------------------
819 # with-device
820 if test "$with_device" = "default" ; then
821     # Pick the device.  For now, always choose ch3
822     with_device=ch3
823 fi
824 # Extract the device name from any options
825 # Allow the device to specify a directory; if no directory, use the
826 # included directories
827
828 DEVICE=$with_device
829 AC_SUBST(DEVICE)
830
831 device_name=`echo $with_device | sed -e 's/:.*$//'`
832 changequote(<<,>>)
833 device_args=`echo $with_device | sed -e 's/^[^:]*//' -e 's/^://'`
834 changequote([,])
835
836 devicedir=$use_top_srcdir/src/mpid/$device_name
837 devicereldir=src/mpid/$device_name
838 case "$device_name" in
839      /*) 
840      devicedir=$DEVICE
841      # Get the name from the leaf
842      device_name=`echo $device_name ~ sed -e 's%.*/%%'`
843      # FIXME: should the devicereldir be different (perhaps not -
844      # this allows use to build within our tree, even when other data
845      # is outside of the tree)
846      ;;
847      *) 
848      ;;
849 esac
850 export device_name
851 export device_args
852 export devicedir
853
854 # See if the device wants to say something about the compilers
855 if test -f $devicedir/mpichprereq ; then
856     . $devicedir/mpichprereq
857 fi
858
859 # expand all of the prereq macros in the correct order
860 m4_map([PAC_SUBCFG_DO_PREREQ], [PAC_SUBCFG_MODULE_LIST])
861
862 # ----------------------------------------------------------------------------
863 # Set default library names if names haven't already been provided
864 AC_ARG_VAR([MPILIBNAME],[can be used to override the name of the MPI library (default: "mpi")])
865 AC_ARG_VAR([PMPILIBNAME],[can be used to override the name of the MPI profiling library (default: "p$MPILIBNAME")])
866 AC_ARG_VAR([MPICXXLIBNAME],[can be used to override the name of the MPI C++ library (default: "${MPILIBNAME}cxx")])
867 AC_ARG_VAR([MPIFCLIBNAME],[can be used to override the name of the MPI fortran library (default: "${MPILIBNAME}fort")])
868 MPILIBNAME=${MPILIBNAME:-"mpi"}
869 PMPILIBNAME_set=no
870 if test -n "$PMPILIBNAME" ; then 
871    PMPILIBNAME_set=yes
872 fi
873 PMPILIBNAME=${PMPILIBNAME:-"p$MPILIBNAME"}
874 # Note that the name for this library may be updated after we check for 
875 # enable_shmem
876 # Fortran names are set later.
877 # We use a different library for the C++ wrappers to avoid problems when
878 # creating shared libraries
879 if test -z "$MPICXXLIBNAME" ; then MPICXXLIBNAME="${MPILIBNAME}cxx" ; fi
880 if test -z "$MPIFCLIBNAME" ; then MPIFCLIBNAME="${MPILIBNAME}fort" ; fi
881 export MPICXXLIBNAME
882 export MPIFCLIBNAME
883 AC_SUBST(MPICXXLIBNAME)
884 AC_SUBST(MPIFCLIBNAME)
885
886 # We'll set FORTRAN_BINDING to 1 if we support Fortran 
887 FORTRAN_BINDING=0
888
889 # enable-fast
890 # strip off multiple options, separated by commas
891 save_IFS="$IFS"
892 IFS=","
893 for option in $enable_fast ; do
894     case "$option" in
895         O*)
896         enable_fast_opts=$option
897         ;;
898         ndebug)
899         enable_fast_ndebug=yes
900         ;;
901         all|yes)
902         enable_fast_ndebug=yes
903         enable_fast_opts=O2
904         ;;
905         none|no)
906         enable_fast_ndebug=no
907         enable_fast_opts=O0
908         ;;
909         *)
910         IFS="$save_IFS"
911         AC_MSG_WARN([Unknown value $option for --enable-fast])
912         IFS=","
913         ;;
914     esac
915 done
916 IFS="$save_IFS"
917
918 if test -n "$enable_fast_opts" ; then
919    # Allows O<n> where <n> can be [0-9] or ' '.
920    opt_flags=`echo $enable_fast_opts | sed -e 's%\(O[0-9] \)%\1%g'`
921    if test -n "$opt_flags" ; then
922       MPI_DEFAULT_COPTS="-$enable_fast_opts"
923       MPI_DEFAULT_CXXOPTS="-$enable_fast_opts"
924       MPI_DEFAULT_FOPTS="-$enable_fast_opts"
925       MPI_DEFAULT_FCOPTS="-$enable_fast_opts"
926    else
927       AC_MSG_WARN([Unknown value $enable_fast_opts for --enable-fast])
928    fi
929 fi
930
931 if test "$enable_fast_ndebug" = "yes" ; then
932     CFLAGS="$CFLAGS -DNDEBUG -DNVALGRIND"
933     CXXFLAGS="$CXXFLAGS -DNDEBUG -DNVALGRIND"
934     # MPICH does NOT assume any preprocessing support from the Fortran compiler,
935     # so no Fortran files contain any preprocessing statements.
936     # Don't set FFLAGS or FCFLAGS with any -D.
937 fi
938
939 # error-checking
940 # Change default into the specific value of the default
941 if test "$enable_error_checking" = "yes" ; then
942    enable_error_checking=all
943 fi
944 # mpir_ext.h needs the variable HAVE_ERROR_CHECKING to have the value 0 or 1
945 HAVE_ERROR_CHECKING=0
946 case "$enable_error_checking" in 
947     no)
948     # if error checking has been disabled, then automatically disable the error
949     # checking tests in the test suite
950     ac_configure_args="${ac_configure_args} --disable-checkerrors"
951     ;;
952     all|runtime)
953     error_checking_kind=`echo $enable_error_checking | \
954     tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
955     error_checking_kind=MPID_ERROR_LEVEL_$error_checking_kind
956     AC_DEFINE_UNQUOTED(HAVE_ERROR_CHECKING,$error_checking_kind,[Define to enable error checking])
957     HAVE_ERROR_CHECKING=1
958     ;;
959     *)
960     AC_MSG_WARN([Unknown value $enable_error_checking for enable-error-checking])
961     ;;
962 esac
963 # permit @HAVE_ERROR_CHECKING@ substitution in mpir_ext.h
964 AC_SUBST([HAVE_ERROR_CHECKING])
965
966 # error-messages
967 case "$enable_error_messages" in 
968     no|none)
969         error_message_kind="MPICH_ERROR_MSG__NONE"
970     ;;
971     all|yes)
972         error_message_kind="MPICH_ERROR_MSG__ALL"
973     ;;
974     generic)
975         error_message_kind="MPICH_ERROR_MSG__GENERIC"
976     ;;
977     class)
978         error_message_kind="MPICH_ERROR_MSG__CLASS"
979     ;;
980     *)
981     AC_MSG_WARN([Unknown value $enable_error_messages for enable-error-messages])
982     ;;
983 esac
984 AC_DEFINE_UNQUOTED(MPICH_ERROR_MSG_LEVEL,$error_message_kind,[define to enable error messages])
985
986 #error-tags
987 if test "$enable_tag_error_bits" = "yes" ; then
988     AC_DEFINE([HAVE_TAG_ERROR_BITS],[1],[Define to enable tag error bits])
989 fi
990
991 # ----------------------------------------------------------------------------
992 #
993 # enable-timing and with-logging
994 #
995 # Still to do: add subsets: e.g., class=pt2pt,class=coll.  See mpich doc
996 #
997 # Logging and timing are intertwined.  If you select logging, you
998 # may also need to select a timing level.  If no timing is selected 
999 # but logging with rlog is selected, make "all" the default timing level.
1000 #
1001 # FIXME: make timing and logging options work more cleanly together,
1002 # particularly when other logging options are selected (e.g., logging is not
1003 # rlog).
1004 # ----------------------------------------------------------------------------
1005 AM_CONDITIONAL([BUILD_LOGGING_RLOG],[test "X$with_logging" = "Xrlog"])
1006 collect_stats=false
1007 logging_required=false
1008 if test "$enable_timing" = "default" ; then
1009     if test "$with_logging" = "rlog" ; then
1010         enable_timing=all
1011     fi
1012 fi
1013 timing_name=$enable_timing
1014 case "$enable_timing" in
1015     no)
1016     timing_name=none
1017     ;;
1018     time)
1019     collect_stats=true
1020     ;;
1021     log|log_detailed)
1022     logging_required=true
1023     ;;
1024     yes)
1025     timing_name=all
1026     collect_stats=true
1027     logging_required=true
1028     ;;
1029     all|runtime)
1030     collect_stats=true
1031     logging_required=true
1032     ;;
1033     none|default)
1034     timing_name=none
1035     ;;
1036     *)
1037     AC_MSG_WARN([Unknown value $enable_timing for enable-timing])
1038     enable_timing=no
1039     timing_name=none
1040     ;; 
1041 esac
1042 #
1043 # The default logging package is rlog; you can get it by 
1044 # specifying --with-logging or --with-logging=rlog
1045 #
1046 case $with_logging in 
1047     yes)
1048     logging_name=rlog
1049     ;;
1050     no|none)
1051     logging_name=none
1052     ;;
1053     default)
1054     if test "$logging_required" = "true" ; then
1055         logging_name=rlog
1056     else
1057         logging_name=none
1058     fi
1059     ;;
1060     *)
1061     logging_name=$with_logging
1062     ;;
1063 esac
1064
1065 # Include the selected logging subsystem
1066 #
1067 # Choices:
1068 # 1) A subdir of src/util/logging
1069 #     This directory must contain a configure which will be executed
1070 #     to build the 
1071 # 2) An external directory
1072 #     This directory must contain 
1073 #          a mpilogging.h file
1074 #     It may contain 
1075 #          a setup_logging script
1076 #          a configure
1077 #     
1078 #   
1079 logging_subsystems=
1080 if test "$logging_name" != "none" ; then
1081     # Check for an external name (directory containing a /)
1082     hasSlash=`echo A$logging_name | sed -e 's%[[^/]]%%g'`
1083     if test -n "$hasSlash" ; then
1084         # Check that the external logging system is complete.
1085         # Any failure will cause configure to abort
1086         if test ! -d $logging_name ; then
1087             AC_MSG_ERROR([External logging directory $logging_name not found.  Configure aborted])
1088             logging_name=none
1089         elif test ! -s $logging_name/mpilogging.h ; then
1090             AC_MSG_ERROR([External logging header $logging_name/mpilogging.h not found.  Configure aborted])
1091             logging_name=none
1092         fi
1093
1094         logdir=$logging_name
1095         # Force the logdir to be absolute
1096         logdir=`cd $logdir && pwd`
1097         # Switch name to "external" because that is how the MPICH
1098         # code will know it
1099         logging_name=external
1100         # Add the dir to the include paths
1101         #CPPFLAGS="$CPPFLAGS -I$logdir"
1102         CPPFLAGS="$CPPFLAGS -I$logdir"
1103         # Add to the list of external modules to setup
1104         if test -x $logdir/setup_logging ; then
1105              EXTERNAL_SETUPS="$EXTERNAL_SETUPS $logdir/setup_logging"
1106         fi
1107     else
1108         logdir=$srcdir/src/util/logging
1109         logreldir=src/util/logging/$logging_name
1110         logging_subsystems="$logging_subsystems $logreldir"
1111         for dir in $logging_name ; do
1112             if test ! -d $logdir/$dir ; then
1113                 AC_MSG_ERROR([$logdir/$dir does not exist.  Configure aborted])
1114                 logging_name=none
1115             fi
1116         done
1117         for dir in $logging_subsystems ; do
1118             if test ! -x $srcdir/$dir/configure ; then
1119                 AC_MSG_ERROR([$srcdir/$dir has no configure (required).  Configure aborted])
1120                 logging_name=none
1121             fi
1122         done
1123     fi
1124 fi
1125 #
1126 # FIXME: Logging doesn't necessarily require timing (e.g., simply logging the 
1127 # sequence of routines).  
1128 if test "$logging_name" != "none" ; then
1129     if test "$enable_timing" != "no" ; then
1130         if test "$enable_timing" = "default" -o "$enable_timing" = "none" ; then
1131             enable_timing=log
1132             timing_name=log
1133         fi
1134         subsystems="$subsystems $logging_subsystems"
1135     else
1136         AC_MSG_WARN([Timing was disabled.  Logging has been disabled as well.])
1137         with_logging=no
1138         logging_name=none
1139     fi
1140 else
1141     if test "$logging_required" = "true" ; then
1142         AC_MSG_WARN([Timing was enabled with log option but no logging library is available.  Timing has been disabled.])
1143         enable_timing=no
1144         timing_name=none
1145     fi
1146 fi
1147 if test "$timing_name" != "none" ; then
1148     timing_kind=`echo $timing_name | \
1149        tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
1150     timing_kind=MPICH_TIMING_KIND__$timing_kind
1151     AC_DEFINE_UNQUOTED(HAVE_TIMING,$timing_kind,[define to enable timing collection])
1152     if test "$collect_stats" = "true" ; then
1153         AC_DEFINE(COLLECT_STATS,1,[define to enable collection of statistics])
1154     fi
1155 fi
1156
1157 use_logging_variable="MPICH_LOGGING__`echo $logging_name | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`"
1158 AC_DEFINE_UNQUOTED(USE_LOGGING,$use_logging_variable,[define to choose logging library])
1159 # ----------------------------------------------------------------------------
1160 # End of logging tests
1161 # ----------------------------------------------------------------------------
1162
1163 # ----------------------------------------------------------------------------
1164 # Check to see if the device does not support spawn.  
1165 # FIXME: This should provide the option of not building the dynamic
1166 # process routines.  It could also allow us to specialize support
1167 # for all processes are members of MPI_COMM_WORLD (only one comm_world).
1168 # ----------------------------------------------------------------------------
1169 if test "$MPID_NO_SPAWN" = yes ; then
1170     AC_MSG_WARN([The device $with_device does not support MPI dynamic process routines])   
1171 fi
1172
1173 # MPL
1174 AC_ARG_VAR([MPLLIBNAME],[can be used to override the name of the MPL library (default: "mpl")])
1175 MPLLIBNAME=${MPLLIBNAME:-"mpl"}
1176 export MPLLIBNAME
1177 AC_SUBST(MPLLIBNAME)
1178 AC_ARG_WITH([mpl-prefix],
1179             [AS_HELP_STRING([[--with-mpl-prefix[=DIR]]],
1180                             [use the MPL library installed in DIR,
1181                              rather than the one included in src/mpl.  Pass
1182                              "embedded" to force usage of the MPL source
1183                              distributed with MPICH.])],
1184             [],dnl action-if-given
1185             [with_mpl_prefix=embedded]) dnl action-if-not-given
1186 mplsrcdir=""
1187 AC_SUBST([mplsrcdir])
1188 mpllibdir=""
1189 AC_SUBST([mpllibdir])
1190 mpllib=""
1191 AC_SUBST([mpllib])
1192 if test "$with_mpl_prefix" = "embedded" ; then
1193     # no need for libtool versioning when embedding MPL
1194     mpl_subdir_args="--disable-versioning --enable-embedded"
1195     PAC_CONFIG_SUBDIR_ARGS([src/mpl],[$mpl_subdir_args],[],[AC_MSG_ERROR(MPL configure failed)])
1196     PAC_APPEND_FLAG([-I${master_top_builddir}/src/mpl/include], [CPPFLAGS])
1197     PAC_APPEND_FLAG([-I${use_top_srcdir}/src/mpl/include], [CPPFLAGS])
1198
1199     mplsrcdir="src/mpl"
1200     mpllib="src/mpl/lib${MPLLIBNAME}.la"
1201 else
1202     # The user specified an already-installed MPL; just sanity check, don't
1203     # subconfigure it
1204     AS_IF([test -s "${with_mpl_prefix}/include/mplconfig.h"],
1205           [:],[AC_MSG_ERROR([the MPL installation in "${with_mpl_prefix}" appears broken])])
1206     PAC_APPEND_FLAG([-I${with_mpl_prefix}/include],[CPPFLAGS])
1207     PAC_PREPEND_FLAG([-l${MPLLIBNAME}],[WRAPPER_LIBS])
1208     PAC_APPEND_FLAG([-L${with_mpl_prefix}/lib],[WRAPPER_LDFLAGS])
1209     mpllibdir="-L${with_mpl_prefix}/lib"
1210 fi
1211
1212 # OpenPA
1213 AC_ARG_VAR([OPALIBNAME],[can be used to override the name of the OpenPA library (default: "opa")])
1214 OPALIBNAME=${OPALIBNAME:-"opa"}
1215 export OPALIBNAME
1216 AC_SUBST(OPALIBNAME)
1217 AC_ARG_WITH([openpa-prefix],
1218             [AS_HELP_STRING([[--with-openpa-prefix[=DIR]]],
1219                             [use the OpenPA atomics library installed in DIR,
1220                              rather than the one included in src/openpa.  Pass
1221                              "embedded" to force usage of the OpenPA source
1222                              distributed with MPICH.])],
1223             [],
1224             [# see if OPA is already installed on the system
1225              PAC_PUSH_FLAG([LIBS])
1226              PAC_PREPEND_FLAG([-l${OPALIBNAME}],[LIBS])
1227              AC_LINK_IFELSE([AC_LANG_PROGRAM([dnl
1228 #include "opa_primitives.h"
1229 ],[
1230 OPA_int_t i;
1231 OPA_store_int(i,10);
1232 OPA_fetch_and_incr_int(&i,5);
1233 ])dnl
1234                              ],
1235                             [with_openpa_prefix=system],[with_openpa_prefix=embedded])
1236              PAC_POP_FLAG([LIBS])
1237              ])
1238
1239 opasrcdir=""
1240 AC_SUBST([opasrcdir])
1241 opalibdir=""
1242 AC_SUBST([opalibdir])
1243 opalib=""
1244 AC_SUBST([opalib])
1245
1246 if test "$with_openpa_prefix" = "embedded" ; then
1247     if test -e "${use_top_srcdir}/src/openpa" ; then
1248         opasrcdir="src/openpa"
1249         opalib="src/openpa/src/lib${OPALIBNAME}.la"
1250         PAC_APPEND_FLAG([-I${use_top_srcdir}/src/openpa/src],[CPPFLAGS])
1251         PAC_APPEND_FLAG([-I${master_top_builddir}/src/openpa/src],[CPPFLAGS])
1252
1253         # OPA defaults to "auto", but in MPICH we want "auto_allow_emulation" to
1254         # easily permit using channels like ch3:sock that don't care about atomics
1255         AC_ARG_WITH([atomic-primitives],
1256                     [AS_HELP_STRING([--with-atomic-primitives],
1257                                     [Force OPA to use a specific atomic primitives
1258                                      implementation.  See the src/openpa directory
1259                                      for more info.])],
1260                     [],[with_atomic_primitives=not_specified])
1261         # no need for libtool versioning when embedding OPA
1262         opa_subdir_args="--disable-versioning --enable-embedded"
1263         if test "$with_atomic_primitives" = "not_specified" ; then
1264             PAC_APPEND_FLAG([--with-atomic-primitives=auto_allow_emulation], [opa_subdir_args])
1265         fi
1266         PAC_CONFIG_SUBDIR_ARGS([src/openpa],[$opa_subdir_args],[],[AC_MSG_ERROR([OpenPA configure failed])])
1267     else
1268         AC_MSG_WARN([Attempted to use the embedded OpenPA source tree in "src/openpa", but it is missing.  Configuration or compilation may fail later.])
1269     fi
1270 elif test "$with_openpa_prefix" = "system" ; then
1271     PAC_PREPEND_FLAG([-l${OPALIBNAME}],[WRAPPER_LIBS])
1272 elif test "$with_openpa_prefix" = "no" ; then
1273     # The user doesn't want to use OPA.  This may or may not cause MPICH to
1274     # fail to configure/build, depending on many other factors.
1275     :
1276 else
1277     # The user specified an already-installed OPA; just sanity check, don't
1278     # subconfigure it
1279     AS_IF([test -s "${with_openpa_prefix}/include/opa_primitives.h" -a -s "${with_openpa_prefix}/include/opa_config.h"],
1280           [:],[AC_MSG_ERROR([the OpenPA installation in "${with_openpa_prefix}" appears broken])])
1281     PAC_APPEND_FLAG([-I${with_openpa_prefix}/include],[CPPFLAGS])
1282     PAC_PREPEND_FLAG([-l${OPALIBNAME}],[WRAPPER_LIBS])
1283     if test -d ${with_openpa_prefix}/lib64 ; then
1284         PAC_APPEND_FLAG([-L${with_openpa_prefix}/lib64],[WRAPPER_LDFLAGS])
1285         opalibdir="-L${with_openpa_prefix}/lib64"
1286     else
1287         opalibdir="-L${with_openpa_prefix}/lib"
1288     fi
1289     PAC_APPEND_FLAG([-L${with_openpa_prefix}/lib],[WRAPPER_LDFLAGS])
1290 fi
1291
1292 # Izem
1293
1294 AC_ARG_ENABLE([izem],
1295 [  --enable-izem@<:@=ARGS@:>@   Enable features from the Izem library.
1296                           "ARGS" is a list of comma separated features.
1297                           Accepted arguments are:
1298                           sync     - use the Izem interface for sychronization objects
1299                                      (locks and condition variables) instead of the MPL interface
1300                           yes/all  - all of the above features are enabled
1301                           no/none  - none of the above features are enabled],,
1302 [enable_izem=no])
1303
1304 # strip off multiple options, separated by commas
1305 save_IFS="$IFS"
1306 IFS=","
1307 for option in $enable_izem ; do
1308     case "$option" in
1309         sync)
1310             izem_sync=yes
1311         ;;
1312         yes|all)
1313             izem_sync=yes
1314         ;;
1315         no|none)
1316         ;;
1317         *)
1318             IFS=$save_IFS
1319             AC_MSG_WARN([Unknown value $option for enable-debug])
1320             IFS=","
1321         ;;
1322     esac
1323 done
1324 IFS="$save_IFS"
1325
1326 if test "$izem_sync" = "yes" ; then
1327     AC_DEFINE(ENABLE_IZEM_SYNC,1,[Define to enable using Izem locks and condition variables])
1328 fi
1329
1330 AC_ARG_VAR([ZMLIBNAME],[can be used to override the name of the Izem library (default: "zm")])
1331 ZMLIBNAME=${ZMLIBNAME:-"zm"}
1332 export ZMLIBNAME
1333 AC_SUBST(ZMLIBNAME)
1334 AC_ARG_WITH([zm-prefix],
1335 [  --with-zm-prefix@<:@=ARG@:>@
1336                           specify the Izem library to use. No argument implies "yes".
1337                           Accepted values for ARG are:
1338                           yes|embedded - use the embedded Izem
1339                           system       - search system paths for an Izem installation
1340                           no           - disable Izem
1341                           <PATH>       - use the Izem at PATH],,
1342 [with_zm_prefix=no])
1343
1344 zmsrcdir=""
1345 AC_SUBST([zmsrcdir])
1346 zmlibdir=""
1347 AC_SUBST([zmlibdir])
1348 zmlib=""
1349 AC_SUBST([zmlib])
1350
1351 if test "$enable_izem" != "no" && test "$enable_izem" != "none"; then
1352     if test "$with_zm_prefix" = "yes" || test "$with_zm_prefix" = "embedded"; then
1353         if test -e "${use_top_srcdir}/src/izem" ; then
1354             zm_subdir_args="--enable-embedded"
1355             PAC_CONFIG_SUBDIR_ARGS([src/izem],[$zm_subdir_args],[],[AC_MSG_ERROR(Izem configure failed)])
1356             zmsrcdir="${master_top_builddir}/src/izem"
1357             zmlib="${master_top_builddir}/src/izem/src/lib${ZMLIBNAME}.la"
1358             PAC_APPEND_FLAG([-I${use_top_srcdir}/src/izem/src/include],[CPPFLAGS])
1359             PAC_APPEND_FLAG([-I${master_top_builddir}/src/izem/src/include],[CPPFLAGS])
1360         else
1361             AC_MSG_WARN([Attempted to use the embedded Izem source tree in "src/izem", but it is missing.  Configuration or compilation may fail later.])
1362         fi
1363     elif test "$with_zm_prefix" = "system"; then
1364         # check if an Izem installation exists on this system
1365         PAC_PUSH_FLAG([LIBS])
1366         PAC_PREPEND_FLAG([-l${ZMLIBNAME}],[LIBS])
1367         AC_LINK_IFELSE([AC_LANG_PROGRAM([#include "lock/zm_ticket.h"
1368                                         ],
1369                                         [zm_ticket_t lock;
1370                                          zm_ticket_init(&lock);
1371                                          zm_ticket_acquire(&lock);
1372                                          zm_ticket_release(&lock);])],
1373                        [AC_MSG_ERROR([No usable Izem installation was found on this system])],
1374                        [PAC_PREPEND_FLAG([-l${ZMLIBNAME}],[WRAPPER_LIBS])])
1375         PAC_POP_FLAG([LIBS])
1376     elif test "$with_zm_prefix" = "no"; then
1377         AC_MSG_ERROR([Izem features were requested with --enable-izem but Izem was disabled.])
1378     else
1379         # The user specified an already-installed Izem; just sanity check, don't
1380         # subconfigure it
1381
1382         AS_IF([test -s "${with_zm_prefix}/include/lock/zm_lock.h" -a -s "${with_zm_prefix}/include/cond/zm_cond.h"],
1383               [:],[AC_MSG_ERROR([Izem headers at "${with_zm_prefix}/include" are missing])])
1384         PAC_APPEND_FLAG([-I${with_zm_prefix}/include],[CPPFLAGS])
1385
1386         PAC_PUSH_FLAG([LIBS])
1387         PAC_PUSH_FLAG([LDFLAGS])
1388         PAC_PREPEND_FLAG([-l${ZMLIBNAME}],[LIBS])
1389         PAC_APPEND_FLAG([-L${with_zm_prefix}/lib],[LDFLAGS])
1390         AC_LINK_IFELSE([AC_LANG_PROGRAM([#include "lock/zm_ticket.h"
1391                                         ],
1392                                         [zm_ticket_t lock;
1393                                          zm_ticket_init(&lock);
1394                                          zm_ticket_acquire(&lock);
1395                                          zm_ticket_release(&lock);])],
1396                        [],[AC_MSG_ERROR([The Izem installation at "${with_zm_prefix}" seems broken])])
1397         PAC_POP_FLAG([LIBS])
1398         PAC_POP_FLAG([LDFLAGS])
1399         PAC_APPEND_FLAG([-L${with_zm_prefix}/lib],[WRAPPER_LDFLAGS])
1400         PAC_PREPEND_FLAG([-l${ZMLIBNAME}],[WRAPPER_LIBS])
1401         zmlibdir="-L${with_zm_prefix}/lib"
1402     fi
1403 fi
1404
1405
1406 # Set NEEDSPLIB to yes if link commands need both -l$MPILIBNAME
1407 # and -lp$MPILIBNAME.
1408 NEEDSPLIB=yes
1409 if test $enable_weak_symbols = yes ; then
1410     # Turn off weak symbols if they aren't available
1411     PAC_PROG_C_WEAK_SYMBOLS(,enable_weak_symbols=no)
1412 fi
1413 if test $enable_weak_symbols = "yes" ; then
1414     AC_DEFINE(USE_WEAK_SYMBOLS,1,[Define if weak symbols should be used])
1415     NEEDSPLIB=no
1416     # Check for the ability to support multiple weak symbols
1417     if test "$pac_cv_prog_c_weak_symbols" = "pragma weak" ; then
1418        PAC_PROG_C_MULTIPLE_WEAK_SYMBOLS(AC_DEFINE(HAVE_MULTIPLE_PRAGMA_WEAK,1,[Define if multiple weak symbols may be defined]))
1419     fi
1420 fi
1421 export NEEDSPLIB
1422
1423 AM_CONDITIONAL([BUILD_PROFILING_LIB],[test "$NEEDSPLIB" = "yes"])
1424
1425
1426 # ----------------------------------------------------------------------------
1427 # HWLOC
1428 # ----------------------------------------------------------------------------
1429 # Allow the user to override the hwloc location (from embedded to user
1430 # path)
1431 # HWLOC
1432 AC_ARG_WITH([hwloc-prefix],
1433             [AS_HELP_STRING([[--with-hwloc-prefix[=DIR]]],
1434                             [use the HWLOC library installed in DIR,
1435                              rather than the one included in src/hwloc.  Pass
1436                              "embedded" to force usage of the HWLOC source
1437                              distributed with MPICH.])],
1438             [],dnl action-if-given
1439             [with_hwloc_prefix=embedded]) dnl action-if-not-given
1440 hwlocsrcdir=""
1441 AC_SUBST([hwlocsrcdir])
1442 hwloclibdir=""
1443 AC_SUBST([hwloclibdir])
1444 hwloclib=""
1445 AC_SUBST([hwloclib])
1446
1447 if test "$with_hwloc_prefix" = "embedded" ; then
1448    # Disable visibility when setting up hwloc
1449    PAC_PUSH_FLAG([enable_visibility])
1450    enable_visibility=no;
1451    HWLOC_SETUP_CORE([src/hwloc],[have_hwloc=yes],[have_hwloc=no],[1])
1452    # Only build hwloc in embedded mode
1453    if test "$have_hwloc" = "yes" ; then
1454       use_embedded_hwloc=yes
1455       hwlocsrcdir="src/hwloc"
1456       hwloclib="$HWLOC_EMBEDDED_LDADD"
1457       PAC_PREPEND_FLAG([$HWLOC_EMBEDDED_LIBS], [WRAPPER_LIBS])
1458    fi
1459    PAC_POP_FLAG([enable_visibility])
1460 else
1461    AC_CHECK_HEADERS([hwloc.h])
1462    # hwloc_topology_set_pid was added in hwloc-1.0.0, which is our
1463    # minimum required version
1464    AC_CHECK_LIB([hwloc],[hwloc_topology_set_pid])
1465    AC_MSG_CHECKING([if non-embedded hwloc works])
1466    if test "$ac_cv_header_hwloc_h" = "yes" -a "$ac_cv_lib_hwloc_hwloc_topology_set_pid" = "yes" ; then
1467       have_hwloc=yes
1468    else
1469       have_hwloc=no
1470    fi
1471    AC_MSG_RESULT([$have_hwloc])
1472
1473    # FIXME: Disable hwloc on Cygwin for now. The hwloc package,
1474    # atleast as of 1.0.2, does not install correctly on Cygwin
1475    AS_CASE([$host], [*-*-cygwin], [have_hwloc=no])
1476
1477    if test "$have_hwloc" = "yes" ; then
1478       hwloclib="-lhwloc"
1479       if test -d ${with_hwloc_prefix}/lib64 ; then
1480          PAC_APPEND_FLAG([-L${with_hwloc_prefix}/lib64],[WRAPPER_LDFLAGS])
1481          hwloclibdir="-L${with_hwloc_prefix}/lib64"
1482       else
1483          hwloclibdir="-L${with_hwloc_prefix}/lib"
1484       fi
1485    fi
1486 fi
1487
1488 if test "$have_hwloc" = "yes" ; then
1489    AC_DEFINE(HAVE_HWLOC,1,[Define if hwloc is available])
1490 fi
1491
1492 HWLOC_DO_AM_CONDITIONALS
1493 AM_CONDITIONAL([have_hwloc], [test "${have_hwloc}" = "yes"])
1494 AM_CONDITIONAL([use_embedded_hwloc], [test "${use_embedded_hwloc}" = "yes"])
1495
1496
1497 # ----------------------------------------------------------------------------
1498 # Threads
1499 # ----------------------------------------------------------------------------
1500 #
1501 # Threads must be supported by the device.  First, set the default to
1502 # be the highest supported by the device
1503 # "runtime" was an old (now deprecated) option; just map it to multiple
1504 if test "$enable_threads" = "runtime" ; then enable_threads=multiple ; fi
1505 if test "$enable_threads" = "yes" ; then enable_threads=default ; fi
1506 if test "$enable_threads" = "no" ; then enable_threads=single ; fi
1507 if test "$enable_threads" = default ; then
1508     # XXX DJG bug is here, PREREQ is not being used right now
1509     if test -n "$MPID_MAX_THREAD_LEVEL" ; then
1510         case $MPID_MAX_THREAD_LEVEL in
1511             MPI_THREAD_SINGLE)     enable_threads=single ;;
1512             MPI_THREAD_FUNNELED)   enable_threads=funneled ;;
1513             MPI_THREAD_SERIALIZED) enable_threads=serialized ;;
1514             MPI_THREAD_MULTIPLE)   enable_threads=multiple ;;
1515             *) AC_MSG_ERROR([Unrecognized thread level from device $MPID_MAX_THREAD_LEVEL])
1516             ;;
1517         esac
1518     else
1519         enable_threads=single
1520     fi
1521 fi
1522
1523 MPICH_THREAD_LEVEL=MPI_THREAD_FUNNELED
1524 case "$enable_threads" in 
1525     single)
1526     thread_pkg_required=no
1527     MPICH_THREAD_LEVEL=MPI_THREAD_SINGLE
1528     ;;
1529     funneled)
1530     thread_pkg_required=no
1531     MPICH_THREAD_LEVEL=MPI_THREAD_FUNNELED
1532     ;;
1533     serialized)
1534     thread_pkg_required=no
1535     MPICH_THREAD_LEVEL=MPI_THREAD_SERIALIZED
1536     ;;
1537     multiple)
1538     thread_pkg_required=yes
1539     MPICH_THREAD_LEVEL=MPI_THREAD_MULTIPLE
1540     ;;
1541     *)
1542     AC_MSG_ERROR(["$enable_threads" is not a valid value for --enable-threads])     
1543     ;;
1544 esac
1545 # Check that the requested thread level is available.
1546 threadLevelOK=yes
1547 if test ! -z "$MPID_MAX_THREAD_LEVEL" ; then
1548     # Check that MPID_MAX_THREAD_LEVEL is at least as large as the
1549     # selected MPICH_THREAD_LEVEL
1550     case $MPICH_THREAD_LEVEL in 
1551         MPI_THREAD_MULTIPLE)
1552         if test "$MPID_MAX_THREAD_LEVEL" != "MPI_THREAD_MULTIPLE" ; then
1553             threadLevelOK=no
1554         fi
1555         ;;
1556         MPI_THREAD_SERIALIZED)
1557         if test "$MPID_MAX_THREAD_LEVEL" != "MPI_THREAD_MULTIPLE" -a \
1558                 "$MPID_MAX_THREAD_LEVEL" != "MPI_THREAD_SERIALIZED" ; then
1559             threadLevelOK=no
1560         fi
1561         ;;
1562         MPI_THREAD_FUNNELED)
1563         if test "$MPID_MAX_THREAD_LEVEL" = "MPI_THREAD_SINGLE" ; then
1564             threadLevelOK=no
1565         fi
1566         ;;
1567         MPI_THREAD_SINGLE)
1568         ;;
1569     esac
1570 fi
1571 if test "$threadLevelOK" != yes ; then
1572    AC_MSG_ERROR([The device $with_device does not support $MPICH_THREAD_LEVEL])
1573 fi
1574
1575 export MPICH_THREAD_LEVEL
1576 AC_DEFINE_UNQUOTED(MPICH_THREAD_LEVEL,$MPICH_THREAD_LEVEL,[Level of thread support selected at compile time])
1577
1578 if test "$MPICH_THREAD_LEVEL" = "MPI_THREAD_MULTIPLE" ; then
1579    AC_DEFINE([MPICH_IS_THREADED],[1],[MPICH is configured to require thread safety])
1580 fi
1581
1582 # If not in MPI_THREAD_SINGLE, we need -D_REENTRANT to get thread-safe "errno".
1583 # Most POSIX systems provide this by default when using -lpthread, but we only use it in MPI_THREAD_MULTIPLE.
1584 # Some systems (Solaris) still require an explicit define in any case.
1585 if test "$MPICH_THREAD_LEVEL" != "MPI_THREAD_SINGLE"; then
1586     PAC_APPEND_FLAG([-D_REENTRANT], [CPPFLAGS])
1587 fi
1588
1589 # Check for value thread_cs choice; set the refcount default if necessary
1590 thread_granularity=MPICH_THREAD_GRANULARITY__SINGLE
1591 thread_refcount=MPICH_REFCOUNT__NONE
1592 if test "$enable_threads" = "multiple" ; then
1593     case $enable_thread_cs in 
1594     global)
1595     thread_granularity=MPICH_THREAD_GRANULARITY__GLOBAL
1596     if test "$enable_refcount" = "default" ; then enable_refcount=none ; fi
1597     ;;
1598     per-object|per_object)
1599     thread_granularity=MPICH_THREAD_GRANULARITY__POBJ
1600     if test "$enable_refcount" = "default" ; then enable_refcount=lock-free ; fi
1601     ;;
1602     lock-free|lock_free|lockfree)
1603     thread_granularity=MPICH_THREAD_GRANULARITY__LOCKFREE
1604     if test "$enable_refcount" = "default" ; then enable_refcount=lock-free ; fi
1605     if test "$enable_predefined_refcount" = "default" ; then enable_predefined_refcount=no ; fi
1606     AC_MSG_ERROR([--enable-thread-cs=lock-free is not supported yet, please select a different granularity])
1607     ;;
1608     *)
1609     AC_MSG_ERROR([Unrecognized value $enable_thread_cs for --enable-thread-cs])
1610     ;;
1611     esac
1612
1613     case $enable_refcount in
1614     lock-free|lock_free|lockfree)
1615     thread_refcount=MPICH_REFCOUNT__LOCKFREE
1616     ;;
1617     none)
1618     thread_refcount=MPICH_REFCOUNT__NONE
1619     ;;
1620     *)
1621     AC_MSG_ERROR([Unrecognized value $enable_refcount for --enable-refcount])
1622     ;;
1623     esac
1624 fi
1625 AC_DEFINE_UNQUOTED([MPICH_THREAD_GRANULARITY],$thread_granularity,[Method used to implement atomic updates and access])
1626
1627 if test "$enable_predefined_refcount" = "no" ; then
1628     AC_DEFINE([MPICH_THREAD_SUPPRESS_PREDEFINED_REFCOUNTS],[1],[define to disable reference counting predefined objects like MPI_COMM_WORLD])
1629 fi
1630
1631 AC_DEFINE_UNQUOTED([MPICH_THREAD_REFCOUNT],$thread_refcount,[Method used to implement refcount updates])
1632
1633 # enable-g
1634 # strip off multiple options, separated by commas
1635 save_IFS="$IFS"
1636 IFS=","
1637 for option in $enable_g ; do
1638     case "$option" in 
1639         debug|dbg)
1640         enable_append_g=yes
1641         ;;
1642         no|none)
1643         ;;
1644         handlealloc)
1645         perform_handlealloc=yes
1646         ;;
1647         handle)
1648         perform_handle=yes
1649         ;;
1650         meminit)
1651         perform_meminit=yes
1652         ;;
1653         memarena)
1654         perform_memarena=yes
1655         perform_memtracing=yes
1656         ;;
1657         mem)
1658         perform_memtracing=yes
1659         ;;
1660         mutex)
1661         perform_dbgmutex=yes
1662         ;;
1663         mutexnesting)
1664         perform_mutexnesting=yes
1665         ;;
1666         most|yes)
1667         perform_memtracing=yes
1668         enable_append_g=yes
1669         perform_meminit=yes
1670         perform_dbgmutex=yes
1671         perform_mutexnesting=yes
1672         perform_handlealloc=yes
1673         perform_handle=yes
1674         ;;
1675         all)
1676         perform_memarena=yes
1677         perform_memtracing=yes
1678         enable_append_g=yes
1679         perform_meminit=yes
1680         perform_dbgmutex=yes
1681         perform_mutexnesting=yes
1682         perform_handlealloc=yes
1683         perform_handle=yes
1684         ;;
1685         *)
1686         IFS=$save_IFS
1687         AC_MSG_WARN([Unknown value $option for enable-g])
1688         IFS=","
1689         ;;
1690     esac
1691 done
1692 IFS="$save_IFS"
1693
1694 if test "$enable_append_g" = "yes" ; then
1695     PAC_APPEND_FLAG([-g],[CFLAGS])
1696     PAC_APPEND_FLAG([-g],[CXXFLAGS])
1697     PAC_APPEND_FLAG([-g],[FFLAGS])
1698     PAC_APPEND_FLAG([-g],[FCFLAGS])
1699     PAC_APPEND_FLAG([-g],[WRAPPER_CFLAGS])
1700     PAC_APPEND_FLAG([-g],[WRAPPER_CXXFLAGS])
1701     PAC_APPEND_FLAG([-g],[WRAPPER_FFLAGS])
1702     PAC_APPEND_FLAG([-g],[WRAPPER_FCFLAGS])
1703 fi
1704 if test -n "$perform_meminit" ; then
1705     AC_DEFINE(MPICH_DEBUG_MEMINIT,1,[Define to enable preinitialization of memory used by structures and unions])
1706 fi
1707 if test "$perform_handlealloc" = yes ; then
1708     AC_DEFINE(MPICH_DEBUG_HANDLEALLOC,1,[Define to enable checking of handles still allocated at MPI_Finalize])
1709 fi
1710 AS_IF([test "X$perform_handle" = "Xyes"],
1711       [AC_DEFINE(MPICH_DEBUG_HANDLES,1,[Define to enable handle checking])])
1712
1713 if test -n "$perform_memtracing" ; then
1714     enable_g_mem=yes
1715     AC_DEFINE(USE_MEMORY_TRACING,1,[Define to enable memory tracing])
1716     if test -n "$perform_memarena" ; then
1717         AC_DEFINE(MPICH_DEBUG_MEMARENA,1,[Define if each function exit should confirm memory arena correctness])
1718     fi
1719 fi
1720
1721 if test -n "$perform_dbgmutex" ; then 
1722    AC_DEFINE(MPICH_DEBUG_MUTEX,1,[Define to enable mutex debugging])
1723 fi
1724
1725 pac_cross_compiling=no
1726 if test "$with_cross" != "no" ; then
1727     if test -s "$with_cross" ; then
1728         AC_MSG_RESULT([Reading values from cross-compilation file $with_cross])
1729         . $with_cross
1730         # Autoconf 2.52 no longer sets cross_compiling except with the
1731         # awkward "targethost" options.
1732         pac_cross_compiling=yes
1733         cross_compiling=yes
1734         ac_cv_prog_cc_cross=yes
1735         ac_cv_prog_f77_cross=yes
1736         ac_cv_prog_fc_cross=yes
1737         ac_cv_prog_cxx_cross=yes
1738         export cross_compiling
1739         # Export all cross variables.  Any subsidiary configure should also
1740         # export CROSS_xxx
1741         rm -f confcross
1742         (set) 2>&1 | grep CROSS_ | \
1743               sed -e 's/^/export /g' -e 's/=.*//g' > confcross
1744         . confcross
1745         rm -f confcross      
1746     fi
1747 fi
1748
1749 # This goes here because we need the top_srcdir
1750 if test "$enable_romio" = "yes" ; then
1751    if test -d $use_top_srcdir/src/mpi/romio ; then
1752        subsystems="$subsystems src/mpi/romio"
1753        AC_DEFINE(HAVE_ROMIO,1,[Define if ROMIO is enabled])
1754
1755        # make it possible to "#include" mpio.h at build time
1756        #
1757        # This ought to be sufficient, but there is also a symlink setup in
1758        # src/include to accomodate current mpicc limitations.  See
1759        # src/mpi/Makefile.mk for more info.
1760        PAC_APPEND_FLAG([-I${master_top_builddir}/src/mpi/romio/include],[CPPFLAGS])
1761
1762        # Set environment variables that the romio configure expects
1763        export use_top_srcdir
1764        top_build_dir=`pwd`
1765        export top_build_dir
1766        # if there is no $top_build_dir/lib, romio puts lib in wrong place
1767        # This test used -e under Linux, but not all test programs understand
1768        # -e
1769        if test ! -d lib ; then mkdir lib ; fi
1770        # tell mpi.h to include mpio.h
1771        PAC_HAVE_ROMIO
1772    else
1773        AC_MSG_WARN([ROMIO src directory is not available])
1774    fi
1775 fi
1776
1777 AM_CONDITIONAL([BUILD_ROMIO], [test x$enable_romio = xyes])
1778
1779 #
1780 # FIXME: If an external device, don't necessarily complain (e.g.,
1781 # if the device is already built)
1782 if test ! -d $devicedir ; then
1783     AC_MSG_ERROR([Device $device_name is unknown])
1784 elif test -f $devicedir/subconfigure.m4 ; then
1785     # this is a new-style subconfigure device, don't add it as a subsystem
1786     :
1787 elif test ! -x $devicedir/configure ; then
1788     if test -s $devicedir/configure ; then
1789         AC_MSG_WARN([The configure in $devicedir exists but is not executable])
1790     else
1791         AC_MSG_WARN([Device $device_name has no configure])
1792     fi
1793     device_name=""
1794 else 
1795     # Add the device to the configure list
1796     devsubsystems="$devsubsystems $devicereldir"
1797     # Make device_name available to subdirs
1798 fi
1799
1800 # with-pm
1801 if test "$with_pm" = "none" ; then
1802     # add "none" as synonym for "no" to agree with older erroneous docs
1803     with_pm="no"
1804 fi
1805 if test "$MPID_NO_PM" = yes ; then
1806     if test "$with_pm" != "default" -a "$with_pm" != no ; then
1807         AC_MSG_ERROR([The PM chosen ($with_pm) is is not valid for the selected device ($with_device)])
1808     fi
1809     # This is used to change with_pm=default to with_pm=no in the case
1810     # where the device does not want a PM
1811     with_pm=no
1812 fi
1813 if test -z "$with_pm" ; then
1814     with_pm="no"
1815 fi
1816 if test "$with_pmi" = "uni" -a "$with_pm" = "default" ; then
1817     with_pm="no"
1818 fi
1819 if test "$with_pm" = "default" -o "$with_pm" = "yes" ; then
1820    if test ! -z "$MPID_DEFAULT_PM" ; then
1821       with_pm=${MPID_DEFAULT_PM}
1822    else
1823       with_pm=hydra
1824    fi
1825 fi
1826
1827 # We allow multiple pm names, separated by : or ,
1828 if test "$with_pm" != "no" ; then
1829     pm_names="`echo $with_pm | sed -e 's/:/ /g' -e 's/,/ /g'`"
1830 else
1831     pm_names=""
1832 fi
1833 #
1834 hasError=no
1835 # We need to be careful about PM's that have either conflicting 
1836 # requirements (e.g., different PMI implementations) or different
1837 # optional features (e.g., MPID_PM_NAMESERVER).
1838 # In addition, we need to interleave the setup of the PMI and PM
1839 # modules.  The order is as follows:
1840 #
1841 # For each PM, execute the mpichprereq script for that pm (if present).  
1842 # This script provides information about the PM, including which PMI
1843 # implementations are supported.
1844
1845 # Then, for the selected PMI, the setup script (if any) is run.  This is
1846 # necessary because the setup of the PM may require information discovered
1847 # or provided duing the PMI setup step.
1848 #
1849 # Finally, for each PM, the setup script is executed.
1850
1851 # Step 1: invoke the mpichprereq for each PM
1852 for pm_name in $pm_names ; do
1853     if test -z "$first_pm_name" ; then
1854        first_pm_name=$pm_name
1855        export first_pm_name
1856     fi
1857     if test ! -d $use_top_srcdir/src/pm/$pm_name ; then
1858         AC_MSG_WARN([$use_top_srcdir/src/pm/$pm_name does not exist. PM is unknown])
1859         hasError=yes
1860     elif test ! -x $use_top_srcdir/src/pm/$pm_name/configure -a \
1861               ! -f $use_top_srcdir/src/pm/$pm_name/subconfigure.m4 ; then
1862         if test -s $use_top_srcdir/src/pm/$pm_name/configure ; then
1863             AC_MSG_WARN([The configure in $use_top_srcdir/src/pm/$pm_name exists but is not executable])
1864         else
1865             AC_MSG_WARN([pm $pm_name has no configure or subconfigure.m4])
1866         fi
1867         pm_name=""
1868         hasError=yes
1869     else
1870         nameserver=$MPID_PM_NAMESERVER
1871         if test -f $use_top_srcdir/src/pm/$pm_name/mpichprereq ; then 
1872             echo sourcing $use_top_srcdir/src/pm/$pm_name/mpichprereq
1873             . $use_top_srcdir/src/pm/$pm_name/mpichprereq
1874         fi
1875         # Check for a change; if found, we'll take the default
1876         if test "$MPID_PM_NAMESERVER" != "$nameserver" ; then
1877             if test "$first_pm_name" != "$pm_name" ; then
1878                 # Reject suggestion (use the default, common mode)
1879                 MPID_PM_NAMESERVER=""
1880             fi
1881         fi
1882     fi
1883 done
1884 if test "$hasError" != no ; then
1885     AC_MSG_ERROR([Aborting configure because an error was seen in the selection of process managers])
1886 fi
1887 #
1888 # pm_name is the *primary* pm
1889 pm_name=$first_pm_name
1890 AC_SUBST(pm_name)
1891
1892 # Step 2:
1893 # Once we've selected the process manager (or managers), we can
1894 # check that we have a compatible PMI implemenatation.
1895 # with-pmi
1896 if test "$with_pmi" != "no" ; then
1897     if test "$with_pmi" = "default" -o "$with_pmi" = "yes" ; then
1898         if test -n "$PM_REQUIRES_PMI" ; then
1899             with_pmi=$PM_REQUIRES_PMI
1900         else
1901             with_pmi=simple
1902         fi
1903     elif test -n "$PM_REQUIRES_PMI" ; then
1904         # Test for compatibility between pm and pmi choices
1905         if test "$PM_REQUIRES_PMI" != "$with_pmi" ; then
1906             AC_MSG_ERROR([The PM chosen ($with_pm) requires the PMI implementation $PM_REQUIRES_PMI but $with_pmi was selected as the PMI implementation.])
1907         fi
1908     fi
1909     pmi_name=$with_pmi
1910     
1911     if test ! -d $use_top_srcdir/src/pmi/$pmi_name ; then
1912         AC_MSG_WARN([$use_top_srcdir/src/pmi/$pmi_name does not exist. PMI is unknown])
1913     elif test ! -x $use_top_srcdir/src/pmi/$pmi_name/configure ; then
1914         if test ! -f $use_top_srcdir/src/pmi/$pmi_name/subconfigure.m4 ; then
1915             AC_MSG_WARN([pmi $pmi_name has no configure or subconfigure.m4])
1916             pmi_name=""
1917         fi
1918     else
1919         # only add to subsystems if a full configure is present
1920         subsystems="$subsystems src/pmi/$pmi_name"
1921     fi
1922 fi
1923
1924 # Step 3: complete pm setup.
1925 # Note that checks for errors have already been performed, so this
1926 # loop does not need to perform any extra error checks.
1927 # Note that this uses this_pm_name because pm_name must be the *first*
1928 # of the PM names
1929 for this_pm_name in $pm_names ; do
1930     # only add the PM to the subsystems if it has a full configure to be
1931     # executed
1932     if test -f $use_top_srcdir/src/pm/$this_pm_name/configure ; then
1933         subsystems="$subsystems src/pm/$this_pm_name"
1934     fi
1935     if test -f $use_top_srcdir/src/pm/$this_pm_name/setup_pm ; then 
1936         echo sourcing $use_top_srcdir/src/pm/$this_pm_name/setup_pm
1937         . $use_top_srcdir/src/pm/$this_pm_name/setup_pm
1938     fi
1939 done
1940
1941 # Check for whether the compiler defines a symbol that contains the 
1942 # function name.  The MPICH code, for greater portability, defines
1943 # its own symbols, FCNAME (a string) and FUNCNAME (a token that is not a 
1944 # string).  Code should use these symbols where possible.  However, 
1945 # some debugging macros may want to use a compiler-provided symbol
1946 # for the function name, and this check makes it possible to 
1947 # define such macros in a way that is always correct.
1948 PAC_CC_FUNCTION_NAME_SYMBOL
1949
1950 # Check if $MPI_DEFAULT_COPTS is valid with $CC
1951 if test -n "$MPI_DEFAULT_COPTS" ; then
1952     if test "$enable_check_compiler_flags" = "yes" ; then
1953         PAC_C_CHECK_COMPILER_OPTION( [$MPI_DEFAULT_COPTS], [
1954         CFLAGS="$CFLAGS $MPI_DEFAULT_COPTS"
1955                                    ] )
1956     else
1957         CFLAGS="$CFLAGS $MPI_DEFAULT_COPTS"
1958     fi
1959 fi
1960
1961 # ---------------------------------------------------------------------------
1962 # determine rpath and other shared library flags for CC
1963 # src/env may not exist yet in a vpath build
1964 $MKDIR_P src/env
1965 cc_shlib_conf=src/env/cc_shlib.conf
1966 PAC_COMPILER_SHLIB_FLAGS([CC],[$cc_shlib_conf])
1967 AC_SUBST_FILE([cc_shlib_conf])
1968
1969 # output rpath flags in a usable format for mpich.pc (pkg-config)
1970 if test "X$enable_wrapper_rpath" = "Xyes"; then
1971     eval WRAPPER_RPATH_LDFLAGS=\"$hardcode_libdir_flag_spec\"
1972 fi
1973 AC_SUBST(WRAPPER_RPATH_LDFLAGS)
1974
1975 # ---------------------------------------------------------------------------
1976 # Support for MPI_T performance variables
1977
1978 # enable-mpit-pvars
1979 # strip off multiple options, separated by commas
1980 save_IFS="$IFS"
1981 IFS=","
1982 for var in $enable_mpit_pvars ; do
1983     AS_CASE(["$var"],
1984             [nem],[enable_pvar_nem=yes],
1985             [recvq],[enable_pvar_recvq=yes],
1986             [rma],[enable_pvar_rma=yes],
1987             [dims],[enable_pvar_dims=yes],
1988             [all|yes],
1989             [enable_pvar_nem=yes
1990              enable_pvar_recvq=yes
1991              enable_pvar_rma=yes
1992              enable_pvar_dims=yes
1993              ],
1994             [no|none],[],
1995             [IFS=$save_IFS
1996              AC_MSG_WARN([Unknown value ($option) for enable-mpit-pvars])
1997              IFS=","])
1998 done
1999 IFS="$save_IFS"
2000
2001 if test -n "$enable_pvar_nem" ; then
2002     status_nem_pvars=1
2003 else
2004     status_nem_pvars=0
2005 fi
2006 AC_DEFINE_UNQUOTED(ENABLE_PVAR_NEM,$status_nem_pvars,
2007           [Define to 1 to enable nemesis-related MPI_T performance variables])
2008
2009 if test -n "$enable_pvar_recvq" ; then
2010     status_recvq_pvars=1
2011 else
2012     status_recvq_pvars=0
2013 fi
2014 AC_DEFINE_UNQUOTED(ENABLE_PVAR_RECVQ,$status_recvq_pvars,
2015           [Define to 1 to enable message receive queue-related MPI_T performance variables])
2016
2017 if test -n "$enable_pvar_rma" ; then
2018     status_rma_pvars=1
2019 else
2020     status_rma_pvars=0
2021 fi
2022 AC_DEFINE_UNQUOTED(ENABLE_PVAR_RMA,$status_rma_pvars,
2023           [Define to 1 to enable rma-related MPI_T performance variables])
2024
2025 if test -n "$enable_pvar_dims" ; then
2026     status_dims_pvars=1
2027 else
2028     status_dims_pvars=0
2029 fi
2030 AC_DEFINE_UNQUOTED(ENABLE_PVAR_DIMS,$status_dims_pvars,
2031           [Define to 1 to enable getdims-related MPI_T performance variables])
2032 # ---------------------------------------------------------------------------
2033 # Support for the language bindings: Fortran 77, Fortran 90, and C++
2034 #
2035 # First, we handle the case of no explicit enable/disable option.  In that
2036 # case, we look for a usable compiler.  We cannot use the ac macros for this
2037 # because they abort the configure step if they fail to find a compiler 
2038 # (earlier versions of autoconf did not have this behavior!).
2039 #
2040 # Second, we perform the langugage-specific tests, if necessary.  This may
2041 # be relatively simple (C++) or complex (Fortran 77, including formation of 
2042 # the encoded MPI handles).
2043 #
2044 # Note that the bindings support needs to know some of the properties of
2045 # the C compiler, so those tests (particularly for weak symbols)
2046 # must come first.
2047 # ----------------------------------------------------------------------------
2048
2049 #
2050 # First, determine whether we are/can support the language bindings
2051 #
2052 # Since F90/F90FLAGS are replaced by FC/FCFLAGS, rather than silently
2053 # substituting them, i.e. FC=$F90 and FCFLAGS=$F90FLAGS, we choose to emit
2054 # an error message and abort to avoid any ambiguous/hidden bug in choosing
2055 # Fortran90 compilers.
2056 if test -n "$F90" -o -n "$F90FLAGS" ; then
2057     AC_MSG_ERROR([F90 and F90FLAGS are replaced by FC and FCFLAGS respectively in this configure, please unset F90/F90FLAGS and set FC/FCFLAGS instead and rerun configure again.])
2058 fi
2059 # ----------------------------------------------------------------------------
2060 # Handle default choices for the Fortran compilers
2061 # Note that these have already been set above
2062
2063 if test "$enable_f77" = "yes"; then
2064     if test "$F77" = "" -o "$F77" = "no"; then
2065         # No Fortran 77 compiler found; abort
2066         AC_MSG_ERROR([No Fortran 77 compiler found. If you don't need to
2067         build any Fortran programs, you can disable Fortran support using
2068         --disable-fortran. If you do want to build Fortran
2069         programs, you need to install a Fortran compiler such as gfortran
2070         or ifort before you can proceed.])
2071     fi
2072 fi
2073
2074 if test "$enable_f77" = yes ; then
2075     # Check if $MPI_DEFAULT_FOPTS is valid with $F77
2076     if test -n "$MPI_DEFAULT_FOPTS" ; then
2077         if test "$enable_check_compiler_flags" = "yes" ; then
2078             PAC_F77_CHECK_COMPILER_OPTION( [$MPI_DEFAULT_FOPTS], [
2079             FFLAGS="$FFLAGS $MPI_DEFAULT_FOPTS"
2080                                          ] )
2081         else
2082             FFLAGS="$FFLAGS $MPI_DEFAULT_FOPTS"
2083         fi
2084     fi
2085 fi
2086
2087 #
2088 # We need to know the name mangling for Fortran before testing for FC
2089 # compatibility (we need this because of the way we decide to generate
2090 # the Fortran 77 bindings)
2091 if test "$enable_f77" = yes ; then
2092     FLIBS_save="$FLIBS"
2093     FLIBS=""
2094     AC_F77_LIBRARY_LDFLAGS
2095     # The autoconf macro for finding FLIBS sometimes makes mistakes
2096     # (particularly with the Fujitsu frt compiler).  This next step
2097     # first sees if the FLIBS is valid with the Fortran compiler
2098     PAC_PROG_F77_FLIBS_VALID
2099     # Now see if FLIBS works with the C compiler
2100     PAC_PROG_F77_CHECK_FLIBS
2101
2102     # Check F77+FLAGS is compatible with CC+CFLAGS before using F77+CC.
2103     PAC_PROG_F77_OBJ_LINKS_WITH_C
2104
2105     PAC_PROG_F77_LINKER_WITH_C
2106     # For name mangle, we need the library flags
2107     PAC_PROG_F77_NAME_MANGLE
2108     # Check whether additional libraries are needed when linking with C
2109     PAC_PROG_F77_AND_C_STDIO_LIBS
2110     AC_SUBST(F77_OTHER_LIBS)
2111
2112     # Warn about mixed name mangling, since many of the tests will fail
2113     if test "$pac_cv_prog_f77_name_mangle" = "mixed" ; then
2114         AC_MSG_WARN([The compiler $F77 uses mixed case names.  Fortran is monocase
2115 and many Fortran programs may use either upper or lower case names for MPI
2116 calls.  Consider specifying a particular parameter to your Fortran compiler
2117 to select either upper or lower case names.  For the Absoft compiler, 
2118 -f selects lower case and -N109 selects upper case (if you use -f, also use 
2119 -B108 to enable the iargc and getarg routines, which are needed for some
2120 tests and by many user programs).  Specify new command
2121 line options by setting the environment variable FFLAGS to include
2122 the options (e.g., setenv FFLAGS "-f -B108").  In addition, make sure that your
2123 Fortran 90 compiler uses a compatible naming choice.  For the 
2124 Absoft Fortran 90, -YALL_NAMES=LCS selects lower case names and -B108 
2125 adds underscores to names, as required for iargc and getarg.  Pass this
2126 information to configure with the FCFLAGS environment variable.])
2127         # If Fortran implicitly enabled, disable it now.  Otherwise,
2128         # abort the configure since warning messages are often lost in
2129         # the output.
2130         AC_MSG_ERROR([Aborting configure because of mixed case names in Fortran.  Either select --disable-fortran or set FCFLAGS to force the compiler to select monocase names])
2131     fi
2132
2133     # The MPI standard requires that MPI_Init in any language initialize
2134     # MPI in all languages.  This can be a problem when objects produced 
2135     # by the Fortran compiler require symbols from the Fortran runtime
2136     # (making linking C-only programs unnecessarily difficult).  What we test 
2137     # here is whether the much more restricted needs of the Fortran 
2138     # initialize can be met with no special use of the Fortran runtime
2139    PAC_F77_INIT_WORKS_WITH_C
2140    if test "$pac_f_init_works_with_c" = "yes" ; then
2141        AC_DEFINE(HAVE_MPI_F_INIT_WORKS_WITH_C,1,[Define if the Fortran init code for MPI works from C programs without special libraries])
2142    fi
2143
2144    #
2145    # Some Fortran compilers now pass CHARACTER length as a size_t instead
2146    # of as an int.  This is hard to test for, since the data is passed by
2147    # value and for characters less than about 2GB long, the correct
2148    # value will be used.  In this case, we must use an approach similar to
2149    # the one used by libtool for shared library options - look at the
2150    # compiler name or vendor.
2151    # Known compilers that use size_t instead of int:
2152    #    Intel Fortran
2153    #    gfortran
2154    # Add others as they become known
2155    AC_ARG_ENABLE(f77characterlen,
2156        AC_HELP_STRING([--enable-f77characterlen],
2157            [Select between int and size_t for the length of a Fortran CHARACTER, depending on the F77 compiler.  If --enable-f77characterlen=size_t is given, force the use of size_t.  This is used for passing Fortran CHARACTER data between C and Fortran, and is provided for experts.  Note that the documentation provided by compiler vendors on the calling convention may not be accurate.]),,enable_f77characterlen=no)
2158
2159    # Set the default
2160    f77_uses_int_for_str=default
2161
2162    case "$enable_f77characterlen" in
2163       yes|no)
2164       ;;
2165       size_t)
2166          f77_uses_int_for_str=no
2167          enable_f77characterlen=yes
2168       ;;
2169       int)
2170          f77_uses_int_for_str=yes
2171          enable_f77characterlen=yes
2172       ;;
2173       *)
2174       AC_MSG_ERROR([Invalid value provided for --enable-f77characterlen])
2175       ;;
2176    esac
2177
2178    # If we might change the size (enable) and we haven't set the choice,
2179    # attempt to determine it from the compiler name.  Risky, but we haven't
2180    # found a reliable way to do this with test codes.
2181    if test "$enable_f77characterlen" = "yes" -a \
2182            "$f77_uses_int_for_str" = "default" ; then
2183        f77_uses_int_for_str=yes
2184        f77Basename=`basename $F77`
2185        case $f77Basename in
2186        ifort*)
2187        f77_uses_int_for_str=no
2188        ;;
2189        gfortran*)
2190        f77_uses_int_for_str=no
2191        ;;
2192        esac
2193    fi
2194    # This test is disabled for now.  Despite information in documentation
2195    # on gfortran, it appears to pass lengths as int, at least in some
2196    # builds (it used movl when tested in 2/2013).  Tests that failed
2197    # included infotestf.f, in a call to mpi_info_get.
2198    # Leave this as a place holder until a proper test can be determined.
2199    if test  "$enable_f77characterlen" = "yes" -a \
2200             "$f77_uses_int_for_str" = "no" ; then
2201        AC_DEFINE(USE_FORT_STR_LEN_SIZET,1,[Define if the length of a CHARACTER*(*) string in Fortran should be passed as size_t instead of int] )
2202    fi
2203
2204 fi
2205
2206 # FC requires F77 as well.  If the user disabled f77, do not run the
2207 # next test; instead, drop into the warning message
2208 # Set a default value for fc works with f77.  This value is
2209 # set to no *only* if fc was selected but was not compatible with f77
2210 fc_with_f77=yes
2211 if test "$enable_fc" = "yes" -a "$enable_f77" = yes ; then
2212     enable_fc=no
2213     if test "$FC" != "no" ; then
2214         # If we allow multiple weak symbols, we should test a name
2215         # that does not contain an underscore.  The Fortran binding uses
2216         # this rule for enabling multiple weak symbols:
2217         # if defined(USE_WEAK_SYMBOLS) && !defined(USE_ONLY_MPI_NAMES) &&
2218         #    defined(HAVE_MULTIPLE_PRAGMA_WEAK) && 
2219         #    defined(F77_NAME_LOWER_2USCORE)
2220         # 
2221         testRoutine="t1_2"
2222         if test "$pac_cv_prog_c_multiple_weak_symbols" = "yes" -a \
2223                "$enable_weak_symbols" = "yes" -a \
2224                "$pac_cv_prog_f77_name_mangle" = "lower doubleunderscore" ; then
2225             testRoutine="t12"
2226         fi
2227         PAC_FC_AND_F77_COMPATIBLE(fc_with_f77=yes,fc_with_f77=no,$testRoutine)
2228         if test "$fc_with_f77" != yes ; then
2229             enable_fc=no
2230             AC_MSG_ERROR([The selected Fortran 90 compiler $FC does not work with the selected Fortran 77 compiler $F77.  Use the environment variables FC and F77 respectively to select compatible Fortran compilers.  The check here tests to see if a main program compiled with the Fortran 90 compiler can link with a subroutine compiled with the Fortran 77 compiler.])
2231         elif test "$fc_with_f77" = "yes" ; then
2232             # If we got here, there is a Fortran 90 compiler that we can use
2233             enable_fc=yes
2234         fi
2235     elif test "$pac_cv_prog_fc_works" = no; then
2236         AC_MSG_WARN([Use --disable-fc to keep configure from searching for a Fortran 90 compiler])
2237     fi
2238
2239     if test "$enable_fc" = "yes"; then
2240         if test "$FC" = "no" -o "$FC" = ""; then
2241             # No Fortran 90 compiler found; abort
2242             AC_MSG_ERROR([No Fortran 90 compiler found. If you don't need
2243             to build any Fortran 90 programs, you can disable Fortran 90
2244             support using --disable-fc. If you do want to build Fortran 90
2245             programs, you need to install a Fortran 90 compiler such as
2246             gfortran or ifort before you can proceed.])
2247         fi
2248     fi
2249 fi
2250
2251 if test "$enable_fc" = "yes" -a "$enable_f77" != "yes" ; then
2252    # Fortran 90 support requires compatible Fortran 77 support
2253    AC_MSG_ERROR([
2254 Fortran 90 support requires compatible Fortran 77 support.
2255 To force the use of the Fortran 90 compiler for Fortran 77,
2256 do not use configure option --disable-fortran, and set the environment
2257 variable F77 to the name of the Fortran 90 compiler, or \$FC.
2258 If you do not want any Fortran support, use configure options
2259 --disable-fortran.])
2260    # We should probably do the compatibility test as well
2261    enable_f77=yes
2262 fi
2263
2264 # ----------------------------------------------------------------------------
2265 # Now test for Fortran compiler characteristics
2266 # ----------------------------------------------------------------------------
2267 if test "$enable_f77" = "yes" ; then
2268     # determine rpath and other shared library flags for F77
2269     f77_shlib_conf=src/env/f77_shlib.conf
2270     PAC_COMPILER_SHLIB_FLAGS([F77],[$f77_shlib_conf])
2271     AC_SUBST_FILE([f77_shlib_conf])
2272
2273     AC_LANG_FORTRAN77
2274     PAC_PROG_F77_EXCLAIM_COMMENTS(has_exclaim="yes",has_exclaim="no")
2275     PAC_PROG_F77_HAS_INCDIR(src)
2276     PAC_PROG_F77_LIBRARY_DIR_FLAG
2277
2278     AC_SUBST(MPIFPMPI)
2279     if test "$MPI_WITH_PMPI" = "no" ; then
2280         # If the PMPI routines are not in the same library with the MPI
2281         # routines, we may need to remove the pmpi declarations
2282         PAC_PROG_F77_ALLOWS_UNUSED_EXTERNALS([MPIFPMPI=",PMPI_WTIME,PMPI_WTICK"],[
2283         MPIFPMPI=""; 
2284         AC_MSG_WARN([Removed PMPI_WTIME and PMPI_WTICK from mpif.h])])
2285     else
2286         MPIFPMPI=",PMPI_WTIME,PMPI_WTICK"
2287     fi
2288
2289     # Once we have name mangle, we can try to limit the number of needed libs
2290     dnl F77_IN_C_LIBS is not needed currently because mpirinitf_() in setbotf.f
2291     dnl is called in initthread.c only when FLIBS is not needed to initialize
2292     dnl Fortran constants from a C main, See PAC_F77_INIT_WORKS_WITH_C.
2293     dnl PAC_PROG_F77_IN_C_LIBS
2294     dnl AC_SUBST(F77_IN_C_LIBS)
2295
2296     # Most systems allow the Fortran compiler to process .F and .F90 files
2297     # using the C preprocessor.  However, some systems either do not
2298     # allow this or have serious bugs (OSF Fortran compilers have a bug
2299     # that generates an error message from cpp).  The following test
2300     # checks to see if .F works, and if not, whether "cpp -P -C" can be used
2301     # This is needed for Mac OSX 10.5
2302     PAC_F77_WORKS_WITH_CPP([F77CPP])
2303     AC_SUBST(F77CPP)
2304
2305     # Check that the Fortran compiler will allow us to pass arguments
2306     # of different types (e.g., for MPI_Send)
2307     PAC_PROG_F77_MISMATCHED_ARGS(addarg,yes)
2308     if test "X$addarg" != "X" ; then
2309         # We could add the names of all of the MPI routines that 
2310         # accept different types.  Instead, we fail cleanly.  
2311         # Some Fortran compilers allow you to turn off checking for 
2312         # mismatched arguments for *all* routines.  Adding an argument
2313         # that turns off checking for *everything* is not something that 
2314         # configure should do - if the user wants this, they can follow
2315         # the instructions in the following error message.
2316         AC_MSG_ERROR([The Fortran compiler $F77 does not accept programs that call the same routine with arguments of different types without the option $addarg.  Rerun configure with FFLAGS=$addarg])
2317     fi
2318
2319     bindings="$bindings f77"
2320     AC_DEFINE(HAVE_FORTRAN_BINDING,1,[Define if Fortran is supported])
2321     # Also define the name FORTRAN_BINDING for use in #if @FORTRAN_BINDING@..
2322     FORTRAN_BINDING=1
2323
2324 fi
2325
2326 dnl By modifying mpif.h to use ! for comments, it can work with many f90 
2327 dnl compilers without creating a separate version.  
2328 dnl Note that this is run AFTER the AC_OUTPUT actions
2329 AC_OUTPUT_COMMANDS([if test "$enable_f77" = yes ; then 
2330 if test "$has_exclaim" = "yes" ; then
2331     sed -e 's/^C/\!/g' src/binding/fortran/mpif_h/mpif.h > src/include/mpif.h
2332         cp src/include/mpif.h src/binding/fortran/mpif_h/mpif.h
2333 else
2334     cp src/binding/fortran/mpif_h/mpif.h src/include
2335 fi
2336 if test "$has_fort_real8" = "yes" ; then
2337     sed -e 's/DOUBLE PRECISION/REAL*8/g' src/include/mpif.h > src/include/mpif.h.new
2338     mv src/include/mpif.h.new src/include/mpif.h
2339     cp src/include/mpif.h src/binding/fortran/mpif_h/mpif.h
2340 fi
2341 fi],
2342 master_top_srcdir=$master_top_srcdir
2343 enable_f77=$enable_f77
2344 enable_fc=$enable_fc
2345 has_exclaim=$has_exclaim
2346 has_fort_real8=$pac_cv_fort_real8
2347 includebuild_dir=$includebuild_dir
2348 libbuild_dir=$libbuild_dir
2349 bashWorks=$bashWorks)
2350
2351 if test "$enable_fc" = "yes" ; then
2352     if test "$enable_f77" != "yes" ; then
2353         AC_MSG_WARN([Fortran 90 requires Fortran 77])
2354         enable_fc=no
2355     else 
2356         bindingsubsystems="$bindingsubsystems src/binding/fortran/use_mpi"
2357         bindings="$bindings f90"
2358     fi
2359 fi
2360
2361 f08_works=no
2362 if test "$enable_fc" = "yes" ; then
2363     PAC_FC_2008_SUPPORT([f08_works=yes],[f08_works=no])
2364 fi
2365 AM_CONDITIONAL([BUILD_F08_BINDING], [test "$f08_works" = "yes"])
2366
2367 if test "$f08_works" = "yes" ; then
2368     status_f08_works=1
2369     bindings="$bindings f08"
2370 else
2371     status_f08_works=0
2372 fi
2373 AC_DEFINE_UNQUOTED(HAVE_F08_BINDING, $status_f08_works, [Define to 1 to enable Fortran 2008 binding])
2374
2375 # Set defaults for these values so that the Makefile in src/bindings/f90
2376 # is valid even if fc is not enabled (this is necessary for the 
2377 # distclean target)
2378 MPIMODNAME=mpi
2379 MPICONSTMODNAME=mpi_constants
2380 MPISIZEOFMODNAME=mpi_sizeofs
2381 MPIBASEMODNAME=mpi_base
2382
2383 # F08 binding stuff
2384 MPI_F08_LINK_CONSTANTS_NAME=mpi_f08_link_constants
2385 PMPI_F08_NAME=pmpi_f08
2386 MPI_F08_CALLBACKS_NAME=mpi_f08_callbacks
2387 MPI_C_INTERFACE_NAME=mpi_c_interface
2388 MPI_C_INTERFACE_GLUE_NAME=mpi_c_interface_glue
2389 MPI_F08_TYPES_NAME=mpi_f08_types
2390 MPI_C_INTERFACE_NOBUF_NAME=mpi_c_interface_nobuf
2391 MPI_F08_COMPILE_CONSTANTS_NAME=mpi_f08_compile_constants
2392 MPI_F08_NAME=mpi_f08
2393 MPI_C_INTERFACE_TYPES_NAME=mpi_c_interface_types
2394 MPI_C_INTERFACE_CDESC_NAME=mpi_c_interface_cdesc
2395
2396 if test "$enable_fc" = "yes" ; then
2397     # determine rpath and other shared library flags for FC
2398     fc_shlib_conf=src/env/fc_shlib.conf
2399     PAC_COMPILER_SHLIB_FLAGS([FC],[$fc_shlib_conf])
2400     AC_SUBST_FILE([fc_shlib_conf])
2401
2402     # Determine characteristics of the Fortran 90 compiler
2403     # Find a Fortran 90 compiler.  Sets FC
2404     # Work around bug in autoconf that adds -g to FCFLAGS
2405     saveFCFLAGS="$FCFLAGS"
2406     dnl FIXME XXX DJG this needs to be reconciled with our separate use of
2407     dnl AC_PROG_FC earlier
2408     dnl PAC_PROG_FC
2409     PAC_PROG_FC_WORKS
2410     FCFLAGS=$saveFCFLAGS
2411     if test "$pac_cv_prog_fc_works" = no ; then 
2412         # Reject this compiler
2413         if test "$FC" != "no" ; then
2414             fc_rejected=yes
2415             oldFC="$FC"
2416             FC="no"
2417         fi
2418     fi
2419
2420     # Determine the extension for Fortran 90 files (it isn't always .f90)
2421     FCEXT=$ac_fc_srcext
2422     AC_SUBST(FCEXT)
2423
2424     if test "$FC" = "no" ; then
2425         if test "$fc_rejected" = "yes" ; then
2426             AC_MSG_ERROR([Could not find a usable Fortran 90 compiler.  The compiler $oldFC may be incompatible with the Fortran 77 compiler $F77; check the output of configure and consult the installation manuals])
2427         else
2428             AC_MSG_ERROR([Could not find a usable Fortran 90 compiler.])
2429         fi
2430     fi
2431
2432     # Find the extension that this compiler uses for modules.
2433     # Sets FCMODEXT (and adds it to the list substed)
2434     # Sets FCMODINCFLAG (and adds it to the list substed)
2435     PAC_FC_MODULE
2436     AC_SUBST(FCMODINCSPEC)
2437     if test -z "$FCMODOUTFLAG" ; then
2438         AC_MSG_ERROR([FCMODOUTFLAG could not be determined but is critical for the current Fortran build system])
2439     fi
2440
2441     if test "$pac_cv_fc_module_case" = "upper" ; then
2442         MPIMODNAME=MPI
2443         MPICONSTMODNAME=MPI_CONSTANTS
2444         MPISIZEOFMODNAME=MPI_SIZEOFS
2445         MPIBASEMODNAME=MPI_BASE
2446         MPI_F08_NAME=MPI_F08
2447         MPI_F08_LINK_CONSTANTS_NAME=MPI_F08_LINK_CONSTANTS
2448         MPI_F08_CALLBACKS_NAME=MPI_F08_CALLBACKS
2449         MPI_F08_TYPES_NAME=MPI_F08_TYPES
2450         MPI_F08_COMPILE_CONSTANTS_NAME=MPI_F08_COMPILE_CONSTANTS
2451         PMPI_F08_NAME=PMPI_F08
2452         MPI_C_INTERFACE_NAME=MPI_C_INTERFACE
2453         MPI_C_INTERFACE_NOBUF_NAME=MPI_C_INTERFACE_NOBUF
2454         MPI_C_INTERFACE_GLUE_NAME=MPI_C_INTERFACE_GLUE
2455         MPI_C_INTERFACE_TYPES_NAME=MPI_C_INTERFACE_TYPES
2456         MPI_C_INTERFACE_CDESC_NAME=MPI_C_INTERFACE_CDESC
2457     else
2458         MPIMODNAME=mpi
2459         MPICONSTMODNAME=mpi_constants
2460         MPISIZEOFMODNAME=mpi_sizeofs
2461         MPIBASEMODNAME=mpi_base
2462         MPI_F08_NAME=mpi_f08
2463         MPI_F08_LINK_CONSTANTS_NAME=mpi_f08_link_constants
2464         MPI_F08_CALLBACKS_NAME=mpi_f08_callbacks
2465         MPI_F08_TYPES_NAME=mpi_f08_types
2466         MPI_F08_COMPILE_CONSTANTS_NAME=mpi_f08_compile_constants
2467         PMPI_F08_NAME=pmpi_f08
2468         MPI_C_INTERFACE_NAME=mpi_c_interface
2469         MPI_C_INTERFACE_NOBUF_NAME=mpi_c_interface_nobuf
2470         MPI_C_INTERFACE_GLUE_NAME=mpi_c_interface_glue
2471         MPI_C_INTERFACE_TYPES_NAME=mpi_c_interface_types
2472         MPI_C_INTERFACE_CDESC_NAME=mpi_c_interface_cdesc
2473     fi
2474     AC_SUBST(MPIMODNAME)
2475     AC_SUBST(MPICONSTMODNAME)
2476     AC_SUBST(MPISIZEOFMODNAME)
2477     AC_SUBST(MPIBASEMODNAME)
2478
2479     AC_SUBST(MPI_F08_NAME)
2480     AC_SUBST(MPI_F08_LINK_CONSTANTS_NAME)
2481     AC_SUBST(MPI_F08_CALLBACKS_NAME)
2482     AC_SUBST(MPI_F08_TYPES_NAME)
2483     AC_SUBST(MPI_F08_COMPILE_CONSTANTS_NAME)
2484     AC_SUBST(PMPI_F08_NAME)
2485     AC_SUBST(MPI_C_INTERFACE_NAME)
2486     AC_SUBST(MPI_C_INTERFACE_NOBUF_NAME)
2487     AC_SUBST(MPI_C_INTERFACE_GLUE_NAME)
2488     AC_SUBST(MPI_C_INTERFACE_TYPES_NAME)
2489     AC_SUBST(MPI_C_INTERFACE_CDESC_NAME)
2490
2491     # Assume that all Fortran 90 compilers accept -I for include directories
2492     FCINC=-I
2493     AC_SUBST(FCINC)
2494     FCINCFLAG=-I
2495     AC_SUBST(FCINCFLAG)
2496
2497     # Check if $MPI_DEFAULT_FCOPTS is valid with $F90
2498     if test -n "$MPI_DEFAULT_FCOPTS" ; then
2499         if test "$enable_check_compiler_flags" = "yes" ; then
2500             PAC_FC_CHECK_COMPILER_OPTION( [$MPI_DEFAULT_FCOPTS], [
2501             FCFLAGS="$FCFLAGS $MPI_DEFAULT_FCOPTS"
2502                                      ] )
2503         else
2504             FCFLAGS="$FCFLAGS $MPI_DEFAULT_FCOPTS"
2505         fi
2506     fi
2507
2508     # Most systems allow the Fortran compiler to process .F and .F90 files
2509     # using the C preprocessor.  However, some systems either do not
2510     # allow this or have serious bugs (OSF Fortran compilers have a bug
2511     # that generates an error message from cpp).  The following test
2512     # checks to see if .F works, and if not, whether "cpp -P -C" can be used
2513     PAC_FC_WORKS_WITH_CPP([FCCPP])
2514     AC_SUBST(FCCPP)
2515
2516     # Check whether additional libraries are needed when linking with C
2517     PAC_PROG_FC_AND_C_STDIO_LIBS
2518     AC_SUBST(FC_OTHER_LIBS)
2519     # ------------------------------------------------
2520 fi
2521
2522 if test "X$modincdir" = "X" ; then
2523   modincdir=$includedir
2524 fi
2525 export modincdir
2526 AC_SUBST(modincdir)
2527
2528 AC_LANG_PUSH([C])
2529 AC_MSG_CHECKING([whether TRUE has been defined])
2530 AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,[return TRUE;])],
2531                   [has_true_upper_case=yes],
2532                   [has_true_upper_case=no])
2533 AC_MSG_RESULT($has_true_upper_case)
2534 if test "$has_true_upper_case" = "no" ; then
2535    AC_DEFINE(TRUE,1,[Define TRUE])
2536    AC_DEFINE(FALSE,0,[Define FALSE])
2537 fi
2538 AC_LANG_POP([C])
2539
2540 # ----------------------------------------------------------------------------
2541 # We previously allowed "default" as a valid value for $enable_cxx.  Now we
2542 # assume its available by default and error out if it doesn't work (just like
2543 # F77 & FC).  The user must pass "--disable-cxx" in order to successfully
2544 # complete configure in this case.
2545 if test "$enable_cxx" = "default" ; then
2546     AC_MSG_ERROR([aborting because "--enable-cxx=default" is no longer a supported value])
2547 fi
2548
2549 if test "$enable_cxx" = "yes" ; then
2550     # Another bug in autoconf.  The checks for the C++ compiler do not
2551     # ensure that you can link a program that is built with the C++ 
2552     # compiler.  We've seen this error with gcc and icc, particularly
2553     # when those compilers accept C++ language elements but are unable
2554     # to link programs that are really C++.  For that reason,
2555     # we've added a test to see if the C++ compiler can produce
2556     # an executable.
2557     AC_CACHE_CHECK([whether the C++ compiler $CXX can build an executable],
2558     pac_cv_cxx_builds_exe,[
2559  AC_LANG_PUSH([C++])
2560  AC_TRY_LINK([
2561 class mytest { 
2562   int a;
2563 public:
2564   mytest(void) : a(1) {}
2565   ~mytest(void) {}
2566 };],[mytest a;],
2567  pac_cv_cxx_builds_exe=yes, pac_cv_cxx_builds_exe=no)
2568  AC_LANG_POP([C++])
2569 ])
2570     if test "$pac_cv_cxx_builds_exe" != yes ; then
2571         AC_MSG_ERROR([Aborting because C++ compiler does not work.  If you do not need a C++ compiler, configure with --disable-cxx])
2572     fi
2573     # Recent failures have come when a standard header is loaded
2574     # The Intel icpc 10.x compiler fails with <string> if gcc 4.2 is installed. 
2575     AC_CACHE_CHECK([whether C++ compiler works with string],pac_cv_cxx_compiles_string,[
2576     AC_LANG_PUSH([C++])
2577     AC_TRY_COMPILE([#include <string>],[return 0;],pac_cv_cxx_compiles_string=yes,pac_cv_cxx_compiles_string=no)
2578     AC_LANG_POP([C++])
2579 ])
2580     if test "$pac_cv_cxx_compiles_string" != yes ; then 
2581         AC_MSG_WARN([The C++ compiler $CXX cannot compile a program containing the <string> header - this may indicate a problem with the C++ installation.  Consider configuing with --disable-cxx])
2582     fi
2583
2584     AC_LANG_CPLUSPLUS
2585     AX_CXX_EXCEPTIONS
2586     AX_CXX_BOOL
2587     AX_CXX_NAMESPACES
2588     if test "$ac_cv_cxx_namespaces" != "yes" ; then
2589         AC_MSG_ERROR([Namespaces are required for the MPI C++ interface])
2590     fi
2591     HAVE_CXX_EXCEPTIONS=0
2592     AC_SUBST(HAVE_CXX_EXCEPTIONS)
2593     if test "$ac_cv_cxx_exceptions" = "yes" ; then
2594         HAVE_CXX_EXCEPTIONS=1
2595     fi
2596     # iostream and math are needed for examples/cxx/cxxpi.cxx
2597     AC_CACHE_CHECK([whether <iostream> available],pac_cv_cxx_has_iostream,[
2598     AC_TRY_COMPILE([
2599 #include <iostream>
2600 ],[using namespace std;],pac_cv_cxx_has_iostream=yes,pac_cv_cxx_has_iostream=no)])
2601     AX_CXX_NAMESPACE_STD
2602    
2603     AC_CACHE_CHECK([whether <math> available],pac_cv_cxx_has_math,[
2604     AC_TRY_COMPILE([
2605 #include <math>
2606 ],[using namespace std;],pac_cv_cxx_has_math=yes,pac_cv_cxx_has_math=no)])
2607
2608     # GNU changed the calling conventions between minor releases (!!!)
2609     # This is too hard to detect, but we should be able to detect
2610     # the version mismatch.  By default, we set the GNU version to 0.
2611     # In a cross-compiling environment, these can be set with environment
2612     # variables, either directly or through the standard "CROSS" variable.
2613     if test -z "$GNUCXX_VERSION" ; then
2614         if test -n "$CROSS_GNUCXX_VERSION" ; then 
2615              GNUCXX_VERSION=$CROSS_GNUCXX_VERSION
2616         else
2617              GNUCXX_VERSION=0
2618         fi
2619     fi
2620     if test -z "$GNUCXX_MINORVERSION" ; then 
2621         if test -n "$CROSS_GNUCXX_MINORVERSION" ; then
2622              GNUCXX_MINORVERSION=$CROSS_GNUCXX_MINORVERSION
2623         else
2624              GNUCXX_MINORVERSION=0
2625         fi
2626     fi
2627     if test "$cross_compiling" = "no" -a "$ac_compiler_gnu" = "yes" -a \
2628        "$GNUCXX_VERSION" = 0 -a "$GNUCXX_MINORVERSION" = 0 ; then
2629          ac_vals=""
2630          AC_MSG_CHECKING([for GNU g++ version])
2631          AC_TRY_RUN([#include <stdio.h>
2632 int main() {
2633     int v = -1, m = -1;
2634     FILE *fp = fopen("conftest.out","w");
2635 #ifdef __GNUC_MINOR__
2636     m = __GNUC_MINOR__;
2637 #endif
2638 #ifdef __GNUC__
2639     v = __GNUC__;
2640 #endif
2641     fprintf( fp, "v=%d, m=%d\n", v, m );
2642     fclose( fp );
2643     return 0;
2644 }],ac_vals=`cat conftest.out`)
2645          if test -n "$ac_vals" ; then
2646              v=`echo "$ac_vals" | sed -e 's/v=\(.*\),.*/\1/'`
2647              m=`echo "$ac_vals" | sed -e 's/.*m=\(.*\)/\1/'`
2648              AC_MSG_RESULT([$v . $m])
2649              GNUCXX_VERSION=$v
2650              GNUCXX_MINORVERSION=$m
2651          else
2652              AC_MSG_RESULT([unknown])
2653          fi 
2654     fi    
2655     AC_SUBST(GNUCXX_VERSION)
2656     AC_SUBST(GNUCXX_MINORVERSION)
2657
2658     bindings="$bindings cxx"
2659     AC_DEFINE(HAVE_CXX_BINDING,1,[Define if C++ is supported])
2660     INCLUDE_MPICXX_H='#include "mpicxx.h"'
2661     AC_SUBST(INCLUDE_MPICXX_H)
2662
2663     # In order to support the Fortran datatypes within C++, 
2664     # 
2665     # FORTRAN_BINDING always has a CPP-time value of either 0 or 1,
2666     # so that it may be used in #if statements without adding to 
2667     # the CPP name space
2668     AC_SUBST(FORTRAN_BINDING)
2669
2670     # Special C++ datatypes.  Set to DATATYPE NULL first; we'll 
2671     # replace the ones that we have later, after we have determined
2672     # the C datatypes
2673     MPIR_CXX_BOOL=0x0c000000
2674     MPIR_CXX_COMPLEX=0x0c000000
2675     MPIR_CXX_DOUBLE_COMPLEX=0x0c000000
2676     MPIR_CXX_LONG_DOUBLE_COMPLEX=0x0c000000
2677     AC_SUBST(MPIR_CXX_BOOL)
2678     AC_SUBST(MPIR_CXX_COMPLEX)
2679     AC_SUBST(MPIR_CXX_DOUBLE_COMPLEX)
2680     AC_SUBST(MPIR_CXX_LONG_DOUBLE_COMPLEX)
2681
2682     # determine rpath and other shared library flags for CXX
2683     cxx_shlib_conf=src/env/cxx_shlib.conf
2684     PAC_COMPILER_SHLIB_FLAGS([CXX],[$cxx_shlib_conf])
2685     AC_SUBST_FILE([cxx_shlib_conf])
2686 fi
2687
2688 if test "$enable_cxx" = yes; then
2689     # Check if $MPI_DEFAULT_CXXOPTS is valid with $CXX
2690     if test -n "$MPI_DEFAULT_CXXOPTS" ; then
2691         if test "$enable_check_compiler_flags" = "yes" ; then
2692             PAC_CXX_CHECK_COMPILER_OPTION( [$MPI_DEFAULT_CXXOPTS], [
2693             CXXFLAGS="$CXXFLAGS $MPI_DEFAULT_CXXOPTS"
2694                                      ] )
2695         else
2696             CXXFLAGS="$CXXFLAGS $MPI_DEFAULT_CXXOPTS"
2697         fi
2698     fi
2699 fi
2700
2701 AC_SUBST(bindings)
2702
2703 # ----------------------------------------------------------------------------
2704 # End of the bindings support
2705 # ----------------------------------------------------------------------------
2706
2707 AC_LANG_C
2708 #
2709 # ----------------------------------------------------------------------------
2710 # Done with the basic argument processing and decisions about which 
2711 # subsystems to build
2712 # ----------------------------------------------------------------------------
2713
2714 # Look for perl.  Perl is used *only* in the tests of the commands such as
2715 # mpiexec, mpicc, etc, in test/commands, and in some of the utility
2716 # programs for processing log files .  If perl is not found,
2717 # MPICH may still be built and used.
2718 # We need the full path to perl since we'll use it as the interpreter for
2719 # a shell script.
2720 AC_PATH_PROG(PERL,perl)
2721 # Look for ar.  If we fail, abort
2722 AC_CHECK_PROGS(AR,ar)
2723 if test -z "$AR" ; then
2724     AC_MSG_ERROR([The program ar is required for building MPICH.  Make sure that your path includes ar])
2725 fi
2726
2727 # FIXME: this is probably unnecessary now that we only do one "ar" at the end
2728 # (via libtool).  If anything, it's likely to cause problems instead.
2729 # AR_FLAGS provides a way to potentially improve build performance on Mac OSX
2730 AR_FLAGS=cr
2731 # this logic is lame, should really write a real test at some point
2732 AS_CASE([$host],
2733     # Barry proposes AR_FLAGS="Scq" in trac#754, but that won't work correctly for re-builds
2734     [*-*-darwin*], [AR_FLAGS=Scr]
2735 )
2736 AC_ARG_VAR(AR_FLAGS,[AR command flags]) # causes AC_SUBST too
2737
2738 # Note that we set RANLIB to true if we don't find it (some systems neither
2739 # need it nor provide it)
2740 AC_CHECK_PROGS(RANLIB,ranlib,true)
2741
2742 # Check for the killall program; this can be used in some of the tests
2743 # in test/commands
2744 AC_CHECK_PROGS(KILLALL,killall,true)
2745
2746 # Does xargs need the -r option to handle the case where the input 
2747 # is empty (gnu utils do, Mac OSX does not accept -r)
2748 xargs_out=`echo "" | xargs ls | wc -l | sed -e 's/ //g'`
2749 if test "$xargs_out" != "0" ; then
2750     XARGS_NODATA_OPT=-r
2751 fi
2752 AC_SUBST(XARGS_NODATA_OPT)
2753
2754 AC_PROG_INSTALL
2755 PAC_PROG_CHECK_INSTALL_WORKS
2756 #
2757 # On Mac OS/X, install breaks libraries unless used with the -p switch
2758 dnl FIXME not necessary now that we are using libtool
2759 dnl PAC_PROG_INSTALL_BREAKS_LIBS
2760 # We also need mkdir -p.
2761 PAC_PROG_MKDIR_P
2762 PAC_PROG_MAKE
2763
2764 #
2765 # Check for bash to allow more robust shell scripts
2766 AC_PATH_PROG(BASH_SHELL,bash)
2767 #
2768 # Confirm that bash has working arrays.  We can use this to 
2769 # build more robust versions of the scripts (particularly the 
2770 # compliation scripts) by taking advantage of the array features in 
2771 # bash.
2772 bashWorks=no
2773 if test -x "$BASH_SHELL" ; then
2774 changequote(%%,::)dnl
2775     cat >>conftest <<EOF
2776 #! $BASH_SHELL
2777 A[0]="b"
2778 A[1]="c"
2779 rc=1
2780 if test \${A[1]} != "c" ; then rc=2 ; else rc=0 ; fi
2781 exit \$rc
2782 EOF
2783 changequote([,])dnl
2784     AC_MSG_CHECKING([whether $BASH_SHELL supports arrays])
2785     chmod +x conftest
2786     if ./conftest 2>&1 >/dev/null ; then
2787         bashWorks=yes
2788     else
2789         bashWorks=no
2790     fi
2791     rm -f conftest*
2792     AC_MSG_RESULT($bashWorks)
2793 fi
2794 dnl BUILD_BASH_SCRIPTS used to be an AC_SUBST
2795 AM_CONDITIONAL([BUILD_BASH_SCRIPTS], [test "x$bashWorks" = xyes])
2796
2797 # ----------------------------------------------------------------------------
2798 # At this point, we've finally settled on the value of PMPILIBNAME.  We
2799 # can now set NEEDSPLIB.
2800 if test "$NEEDSPLIB" = yes -a "$PMPILIBNAME" = "$MPILIBNAME" ; then
2801     NEEDSPLIB=no
2802 fi
2803
2804 # We are cheating a bit here and reaching inside of the libtool macros to
2805 # extract the correct shared library extension.  It would be nice if this
2806 # were publicly available in at least the same way that $libext is.
2807 eval SHLIB_EXT='"'$shrext_cmds'"'
2808 export SHLIB_EXT
2809 AC_SUBST(SHLIB_EXT)
2810
2811 # ----------------------------------------------------------------------------
2812
2813 # Add the steps for debugger support
2814 BUILD_TVDLL=no
2815 if test "$enable_debuginfo" = "yes" ; then
2816    # We can build the Totalview interface DLL only if we know how to build
2817    # shared libraries.
2818    
2819    # FIXME is this really the right test?
2820    # No.  Before MPICH 1.5, there was the capability to build the debugger
2821    # libraries without forcing the build of shared libraries for everything.
2822    # There may be some way to restore this capability, but until then, we
2823    # at least cause the configure to cleanly fail with a clear error message 
2824    if test "X$enable_shared" = "Xyes" ; then
2825        BUILD_TVDLL=yes
2826    else
2827        AC_MSG_ERROR([Building with --enable-debuginfo now requires building with shared library support.  Add --enable-shared and reconfigure])
2828    fi
2829
2830    # One more nasty problem.  Totalview relies on debugger symbols 
2831    # being present in the executable.  Some experimental versions of
2832    # gcc (3.2 20020329 for ia64) do *not* include the object symbols
2833    # when debugging.  For HPUX, the necessary linking options are
2834    #    +noobjdebug
2835    # for C, Fortran, and C++.  We don't have a good test for this yet,
2836    # so we add a warning
2837    if test "$ac_cv_prog_gcc" = "yes" ; then
2838        AC_MSG_WARN([Some versions of gcc do not include debugging information
2839 within the executable.  Totalview requires this information to detect
2840 an MPICH code.  If you have trouble, try linking with the additional
2841 option 
2842     +noobjdebug
2843 on all link lines (consider adding it to LDFLAGS)])
2844    fi
2845
2846     # The debugger library name cannot be set until we know the extension
2847     # of shared libraries - the name is so on most Unix system, dylib on OS X.
2848     AC_DEFINE(HAVE_DEBUGGER_SUPPORT,1,[Define if debugger support is included])
2849     # The debugger support requires a shared library.  This is handled 
2850     # below, after we check for compiler support for shared libraries
2851     # Note: if libdir contains exec_prefix, handle the fact that the
2852     # default exec_prefix is NONE, which (much later in configure)
2853     # gets turned into the value of prefix
2854     ##ENVVAR: MPICH_DEBUGLIBNAME - Set this environment variable to 
2855     ## override the default name of the debugger support library.
2856     ## The default name is libtvmpich.$SHLIB_EXT (e.g., libtvmpich.so for
2857     ## most Unix versions, libtvmpich.dylib for Mac OSX).
2858     ##ENVVAR END:
2859
2860     if test -z "$MPICH_DEBUGLIBNAME" ; then
2861         DEBUGLIBNAME=libtvmpich$SHLIB_EXT
2862     else
2863         # FIXME DJG I don't think this can be supported arbitrarily by the new
2864         # build system (I'm not sure it was supported correctly by the old
2865         # system either)
2866         AC_MSG_WARN([overriding MPICH_DEBUGLIBNAME is currently untested and probably does not work])
2867         DEBUGLIBNAME=$MPICH_DEBUGLIBNAME
2868     fi
2869     if test "x$exec_prefix" = xNONE ; then
2870         saveExecPrefix=$exec_prefix
2871         exec_prefix=$prefix
2872         eval dlldir=$libdir/$DEBUGLIBNAME
2873         exec_prefix=$saveExecPrefix
2874     else
2875         eval dlldir=$libdir/$DEBUGLIBNAME
2876     fi
2877     dlldir='"'$dlldir'"'
2878     AC_DEFINE_UNQUOTED(MPICH_INFODLL_LOC,$dlldir,[Define as the name of the debugger support library])
2879 fi
2880
2881 # used by automakefiles to conditionally build the DLL
2882 AM_CONDITIONAL([BUILD_DEBUGGER_DLL], [test x$BUILD_TVDLL = xyes])
2883
2884 # ----------------------------------------------------------------------------
2885
2886 nameserv_name=""
2887 # Get the default nameserver, if no nameserver was selected.  A process
2888 # manager may advertise a nameserver name by setting the variable
2889 # MPID_PM_NAMESERVER.
2890 if test "$with_namepublisher" = "default" ; then
2891    if test -n "$MPID_PM_NAMESERVER" ; then
2892        with_namepublisher=$MPID_PM_NAMESERVER
2893    else
2894        # The default is to use pmi to communicate published names
2895        with_namepublisher=pmi
2896    fi
2897 fi
2898
2899 if test "$with_namepublisher" != no -a "$with_namepublisher" != "none" ; then
2900     case "$with_namepublisher" in 
2901     none|no) ;;
2902     # Removed ldap namepublisher hook - we no longer support or distribute
2903     # the ldap-based name server
2904     file*)
2905     # Note that we always build the Makefile for the file version because
2906     # this name publisher is really too simple to require a 
2907     # separate configure, and we might as well include a basic
2908     # name publisher with any MPICH distribution
2909     # We DO need to extract the directory name that is used for writing 
2910     # the files, with the User's home directory as the default
2911     nameserv_name="file"
2912     basedir=`echo $with_namepublisher | sed -e 's/file://'`
2913     if test "$basedir" = "$with_namepublisher" ; then
2914         # Reset since no directory was set.
2915         basedir='"."';
2916     fi
2917     AC_DEFINE_UNQUOTED(FILE_NAMEPUB_BASEDIR,$basedir,[Directory to use in namepub])
2918     AC_DEFINE(USE_FILE_FOR_NAMEPUB,1,[Define if file should be used for name publisher])
2919     ;;
2920
2921     *)
2922     # Check for a new namepublisher
2923     dir=$with_namepublisher
2924     # If we later need args, here is where we can strip them off of the
2925     # with argument
2926     if test -d "$use_top_srcdir/src/nameserv/$dir" ; then
2927         if test -x "$use_top_srcdir/src/nameserv/$dir/configure" ; then
2928             # Run the configure in this directory if necessary
2929             subsystems="$subsystems src/nameserv/$dir"
2930         fi
2931         nameserv_name=$dir
2932     else
2933         AC_MSG_WARN([Unknown name publisher $with_namepublisher])
2934     fi
2935     ;;
2936     esac    
2937 fi
2938 if test -n "$nameserv_name" ; then
2939    AC_DEFINE(HAVE_NAMEPUB_SERVICE,1,[Define if a name publishing service is available])
2940 fi
2941 export nameserv_name
2942 AM_CONDITIONAL([BUILD_NAMEPUB_FILE],[test "X$nameserv_name" = "Xfile"])
2943 AM_CONDITIONAL([BUILD_NAMEPUB_PMI],[test "X$nameserv_name" = "Xpmi"])
2944
2945 # In case the documentation targets are used, find doctext and attempt to 
2946 # find the source for the doctext LaTeX style files.  Use "false" if
2947 # doctext is not found
2948 AC_PATH_PROG(DOCTEXT,doctext,false)
2949 export DOCTEXT
2950 AC_SUBST(DOCTEXT)
2951
2952 # ----------------------------------------------------------------------------
2953 # Check for C compiler characteristics
2954 AC_C_CONST
2955 AC_C_VOLATILE
2956 AC_C_RESTRICT
2957 AC_C_INLINE
2958
2959 PAC_C_GNU_ATTRIBUTE
2960 PAC_C_BUILTIN_EXPECT
2961 PAC_CHECK_VISIBILITY
2962 AC_SUBST(VISIBILITY_CFLAGS)
2963 # disable visibility if building profiling library
2964 if test "$NEEDSPLIB" = "yes" ; then
2965     VISIBILITY_CFLAGS=""
2966 fi
2967
2968 # We need to check for the endianess in order to implement the
2969 # "external32" representations.  This defines "WORDS_BIGENDIAN when
2970 # the system is bigendian.
2971 # As of autoconf 2.62, this macro takes an additional argument for systems
2972 # that can produce object files for either endianess.  
2973 # With the as-always-incompatible-with-every-version autoconf, the 
2974 # arguments for this macro *changed* in 2.62 to
2975 # (if-bigendian,if-littleendian,unknown,universal)
2976 # The fourth argument is new.
2977 # Also note that the definition emitted by autoheader requires that gcc
2978 # be used to compile the programs - other compilers may not define the 
2979 # non-standard __BIG_ENDIAN__ or __LITTLE_ENDIAN__ CPP names on which 
2980 # autoconf 2.62 now depends.
2981 byteOrdering=unknown
2982 AC_C_BIGENDIAN(byteOrdering=big,byteOrdering=little,,byteOrdering=universal)
2983 case $byteOrdering in
2984     big)
2985     # Nothing to do - the c_bigendian macro takes care of it
2986     :
2987     ;;
2988     little)
2989     AC_DEFINE(WORDS_LITTLEENDIAN,1,[Define if words are little endian])
2990     ;;
2991     universal)
2992     AC_DEFINE(WORDS_UNIVERSAL_ENDIAN,1,[Define if configure will not tell us, for universal binaries])
2993     ;;
2994     unknown)
2995     AC_MSG_ERROR([Unable to determine endianess])
2996     ;;
2997 esac
2998
2999 # We only need this test if we are using Fortran
3000 if test "$enable_f77" ; then
3001     PAC_PROG_C_UNALIGNED_DOUBLES(,
3002 [AC_MSG_WARN(Your C compiler $CC does not support unaligned accesses
3003 to doubles.  This is required for interoperation with 
3004 Fortran (the Fortran standard requires it).
3005 You may need to specify an additional argument to your C compiler to 
3006 force it to allow unaligned accesses.)])
3007 fi
3008 # Check for __func__ (defined in C99) or __FUNCTION__ (defined in older GCC)
3009 AC_CACHE_CHECK([whether $CC supports __func__],pac_cv_cc_has___func__,
3010 [AC_TRY_COMPILE([],
3011  [const char *cp = __func__; ],pac_cv_cc_has___func__=yes,
3012 pac_cv_cc_has___func__=no)])
3013 if test "$pac_cv_cc_has___func__" != "yes" ; then
3014     AC_CACHE_CHECK([whether $CC supports __FUNCTION__],pac_cv_cc_has___FUNCTION__,
3015 [AC_TRY_COMPILE([],
3016  [const char *cp = __FUNCTION__;],pac_cv_cc_has___FUNCTION__=yes,
3017 pac_cv_cc_has___FUNCTION__=no)])
3018 fi
3019
3020 # ----------------------------------------------------------------------------
3021 # Check on support for long double and long long types.  Do this before the
3022 # structure alignment test because it will test for including those
3023 # types as well.  In addition, allow the device to suppress support for these
3024 # optional C types by setting MPID_NO_LONG_DOUBLE and/or MPID_NO_LONG_LONG
3025 # to yes.
3026 if test "$MPID_NO_LONG_DOUBLE" != "yes" && test "X$enable_long_double" != "Xno" ; then
3027     AC_CACHE_CHECK([whether long double is supported],
3028     pac_cv_have_long_double,[
3029     AC_TRY_COMPILE(,[long double a;],
3030     pac_cv_have_long_double=yes,pac_cv_have_long_double=no)])
3031     if test "$pac_cv_have_long_double" = "yes" ; then
3032         AC_DEFINE(HAVE_LONG_DOUBLE,1,[Define if long double is supported])
3033     fi
3034 fi
3035 if test "$MPID_NO_LONG_LONG" != "yes" ; then
3036     AC_CACHE_CHECK([whether long long is supported],
3037     pac_cv_have_long_long,[
3038     AC_TRY_COMPILE(,[long long a;],
3039     pac_cv_have_long_long=yes,pac_cv_have_long_long=no)])
3040     if test "$pac_cv_have_long_long" = "yes" ; then
3041         AC_DEFINE(HAVE_LONG_LONG_INT,1,[Define if long long is supported])
3042     fi
3043 fi
3044 # ----------------------------------------------------------------------------
3045 # Get default structure alignment for integers
3046 dnl PAC_C_MAX_INTEGER_ALIGN places the default alignment into
3047 dnl pac_cv_c_max_integer_align, with possible values including
3048 dnl packed (byte), largest, two, four, eight (or other failure message).
3049 PAC_C_MAX_INTEGER_ALIGN
3050
3051 if test "$pac_cv_c_max_integer_align" = "packed" ; then
3052     pac_cv_c_struct_align_nr=1
3053 elif test "$pac_cv_c_max_integer_align" = "two" ; then
3054     pac_cv_c_struct_align_nr=2
3055 elif test "$pac_cv_c_max_integer_align" = "four" ; then
3056     pac_cv_c_struct_align_nr=4
3057 elif test "$pac_cv_c_max_integer_align" = "eight" ; then
3058     pac_cv_c_struct_align_nr=8
3059 fi
3060
3061 if test -n "$pac_cv_c_struct_align_nr" ; then
3062     AC_DEFINE_UNQUOTED(HAVE_MAX_INTEGER_ALIGNMENT,$pac_cv_c_struct_align_nr,[Controls byte alignment of integer structures (for MPI structs)])
3063     AC_DEFINE_UNQUOTED(HAVE_MAX_STRUCT_ALIGNMENT,$pac_cv_c_struct_align_nr,[Controls byte alignment of structures (for aligning allocated structures)])
3064 fi
3065 # Get default structure alignment for floating point types
3066 dnl PAC_C_MAX_FP_ALIGN places the default alignment into
3067 dnl pac_cv_c_max_fp_align, with possible values including
3068 dnl packed (byte), largest, two, four, eight (or other failure message).
3069 PAC_C_MAX_FP_ALIGN
3070
3071 if test "$pac_cv_c_max_fp_align" = "packed" ; then
3072     pac_cv_c_fp_align_nr=1
3073 elif test "$pac_cv_c_max_fp_align" = "two" ; then
3074     pac_cv_c_fp_align_nr=2
3075 elif test "$pac_cv_c_max_fp_align" = "four" ; then
3076     pac_cv_c_fp_align_nr=4
3077 elif test "$pac_cv_c_max_fp_align" = "eight" ; then
3078     pac_cv_c_fp_align_nr=8
3079 elif test "$pac_cv_c_max_fp_align" = "sixteen" ; then
3080     pac_cv_c_fp_align_nr=16
3081 elif test "$pac_cv_c_max_fp_align" = "largest" ; then
3082     AC_MSG_ERROR([Configure detected unsupported structure alignment rules.])
3083 fi
3084
3085 if test -n "$pac_cv_c_fp_align_nr" ; then
3086     AC_DEFINE_UNQUOTED(HAVE_MAX_FP_ALIGNMENT,$pac_cv_c_fp_align_nr,[Controls byte alignment of structures with floats, doubles, and long doubles (for MPI structs)])
3087 fi
3088
3089 # Test for the alignment of structs containing only long doubles.
3090 if test "$pac_cv_have_long_double" = yes ; then
3091     # Check for alignment of just float and double (no long doubles)
3092     PAC_C_MAX_DOUBLE_FP_ALIGN
3093     PAC_C_MAX_LONGDOUBLE_FP_ALIGN
3094     # FIXME: If this alignment is not the same as that for all float types,
3095     # we need to do something else in the alignment rule code.
3096     if test "$pac_cv_c_max_fp_align" != "$pac_cv_c_max_longdouble_fp_align" -o \
3097             "$pac_cv_c_max_fp_align" != "$pac_cv_c_max_double_fp_align" ; then
3098         AC_MSG_WARN([Structures containing long doubles may be aligned differently from structures with floats or longs.  MPICH does not handle this case automatically and you should avoid assumed extents for structures containing float types.])
3099
3100         double_align=-1
3101         case $pac_cv_c_max_double_fp_align in 
3102         packed) double_align=1 ;;
3103         two)    double_align=2 ;;
3104         four)   double_align=4 ;;
3105         eight)  double_align=8 ;;
3106         esac
3107         longdouble_align=-1
3108         case $pac_cv_c_max_longdouble_fp_align in 
3109         packed) longdouble_align=1 ;;
3110         two)    longdouble_align=2 ;;
3111         four)   longdouble_align=4 ;;
3112         eight)  longdouble_align=8 ;;
3113         sixteen)longdouble_align=16 ;;
3114         esac
3115         
3116         AC_DEFINE_UNQUOTED(HAVE_MAX_DOUBLE_FP_ALIGNMENT,$double_align,[Controls byte alignment of structs with doubles])
3117         AC_DEFINE_UNQUOTED(HAVE_MAX_LONG_DOUBLE_FP_ALIGNMENT,$longdouble_align,[Controls byte alignment of structs with long doubles])
3118     fi
3119 fi
3120
3121 # Test for weird struct alignment rules that vary padding based on
3122 # size of leading type only.
3123 PAC_C_DOUBLE_POS_ALIGN
3124 if test "$pac_cv_c_double_pos_align" = "yes" ; then
3125     AC_DEFINE_UNQUOTED(HAVE_DOUBLE_POS_ALIGNMENT,1,[Controls how alignment is applied based on position of doubles in the structure])
3126 fi
3127
3128 # Test for same weird issues with long long int.
3129 PAC_C_LLINT_POS_ALIGN
3130 if test "$pac_cv_c_llint_pos_align" = "yes" ; then
3131    AC_DEFINE_UNQUOTED(HAVE_LLINT_POS_ALIGNMENT,1,[Controls how alignment is applied based on position of long long ints in the structure])
3132 fi
3133
3134 # Test for double alignment not following all our other carefully constructed rules
3135 PAC_C_DOUBLE_ALIGNMENT_EXCEPTION
3136 if test "$pac_cv_c_double_alignment_exception" = "four" ; then
3137    AC_DEFINE_UNQUOTED(HAVE_DOUBLE_ALIGNMENT_EXCEPTION,4,[Controls how alignment of doubles is performed, separate from other FP values])
3138 fi
3139
3140 # Test whether pointers can be aligned on a int boundary or require
3141 # a pointer boundary.
3142 AC_MSG_CHECKING([for alignment restrictions on pointers])
3143 AC_TRY_RUN(
3144 changequote(<<,>>)
3145 struct foo { int a; void *b; };
3146 int main() {
3147     int buf[10];
3148     struct foo *p1;
3149     p1=(struct foo*)&buf[0];
3150     p1->b = (void *)0;
3151     p1=(struct foo*)&buf[1];
3152     p1->b = (void *)0;
3153     return 0;
3154 changequote([,])
3155 },pac_cv_pointers_have_int_alignment=yes,pac_cv_pointers_have_int_alignment=no,pac_cv_pointers_have_int_alignment=unknown)
3156
3157 if test "$pac_cv_pointers_have_int_alignment" != "yes" ; then
3158    AC_DEFINE(NEEDS_POINTER_ALIGNMENT_ADJUST,1,[define if pointers must be aligned on pointer boundaries])
3159    AC_MSG_RESULT([pointer])
3160 else
3161    AC_MSG_RESULT([int or better])
3162 fi
3163
3164 # Require strict alignment memory access for alignment-sensitive platform (e.g., SPARC)
3165 if test "$host_cpu" = "sparc" ; then
3166     AC_DEFINE(NEEDS_STRICT_ALIGNMENT,1,[Define if strict alignment memory access is required])
3167 fi
3168
3169 # There are further alignment checks after we test for int64_t etc. below.
3170
3171 # Get the size of the C types for encoding in the basic datatypes and for
3172 # the specific-sized integers
3173 AC_CHECK_SIZEOF(char)
3174 AC_CHECK_SIZEOF(unsigned char)
3175 AC_CHECK_SIZEOF(short)
3176 AC_CHECK_SIZEOF(unsigned short)
3177 AC_CHECK_SIZEOF(int)
3178 AC_CHECK_SIZEOF(unsigned int)
3179 AC_CHECK_SIZEOF(long)
3180 AC_CHECK_SIZEOF(unsigned long)
3181 AC_CHECK_SIZEOF(long long)
3182 AC_CHECK_SIZEOF(unsigned long long)
3183 AC_CHECK_SIZEOF(float)
3184 AC_CHECK_SIZEOF(double)
3185 AC_CHECK_SIZEOF(long double)
3186 AC_CHECK_SIZEOF(void *)
3187
3188 AC_HEADER_STDC
3189 AC_CHECK_HEADERS([stddef.h])
3190 AC_CHECK_SIZEOF(wchar_t, 0, [
3191 #ifdef HAVE_STDDEF_H
3192 #include <stddef.h>
3193 #endif
3194 ])
3195
3196 AC_CHECK_SIZEOF(float_int, 0, [typedef struct { float a; int b; } float_int; ])
3197 AC_CHECK_SIZEOF(double_int, 0, [typedef struct { double a; int b; } double_int; ])
3198 AC_CHECK_SIZEOF(long_int, 0, [typedef struct { long a; int b; } long_int; ])
3199 AC_CHECK_SIZEOF(short_int, 0, [typedef struct { short a; int b; } short_int; ])
3200 AC_CHECK_SIZEOF(two_int, 0, [typedef struct { int a; int b; } two_int; ])
3201 AC_CHECK_SIZEOF(long_double_int, 0, [typedef struct { long double a; int b;} long_double_int; ])
3202
3203 # sys/bitypes.h defines the int16_t etc. on some systems (e.g., OSF1).
3204 # Include it when testing for these types
3205 AC_CHECK_HEADER(sys/bitypes.h,[use_bitypes="#include <sys/bitypes.h>"
3206 AC_DEFINE(HAVE_SYS_BITYPES_H,1,[Define if sys/bitypes.h exists])])
3207 # A C99 compliant compiler should have inttypes.h for fixed-size int types
3208 AC_CHECK_HEADERS(inttypes.h stdint.h)
3209
3210 # Check for types
3211 AC_TYPE_INT8_T
3212 AC_TYPE_INT16_T
3213 AC_TYPE_INT32_T
3214 AC_TYPE_INT64_T
3215
3216 # Temporary issue in autoconf integer type checking (remove when
3217 # autoconf fixes this or provides a workaround for it)
3218 if test "$ac_cv_c_int8_t" != no ; then
3219     AC_DEFINE(HAVE_INT8_T,1,[Define if int8_t is supported by the C compiler])
3220 fi
3221 if test "$ac_cv_c_int16_t" != no ; then
3222     AC_DEFINE(HAVE_INT16_T,1,[Define if int16_t is supported by the C compiler])
3223 fi
3224 if test "$ac_cv_c_int32_t" != no ; then
3225     AC_DEFINE(HAVE_INT32_T,1,[Define if int32_t is supported by the C compiler])
3226 fi
3227 if test "$ac_cv_c_int64_t" != no ; then
3228     AC_DEFINE(HAVE_INT64_T,1,[Define if int64_t is supported by the C compiler])
3229 fi
3230
3231 # The following make these definitions:
3232 #   define _UINT<n>_T 1 
3233 # if uint<n>_t is available.  E.g., define _UINT8_T as 1 if uint8_t is available
3234 # if not available, define uint<n>_t as the related C type, e.g.,
3235 #   define uint8_t unsigned char
3236 #
3237 AC_TYPE_UINT8_T
3238 AC_TYPE_UINT16_T
3239 AC_TYPE_UINT32_T
3240 AC_TYPE_UINT64_T
3241
3242 # Temporary issue in autoconf integer type checking (remove when
3243 # autoconf fixes this or provides a workaround for it)
3244 if test "$ac_cv_c_uint8_t" != no ; then
3245     AC_DEFINE(HAVE_UINT8_T,1,[Define if uint8_t is supported by the C compiler])
3246 fi
3247 if test "$ac_cv_c_uint16_t" != no ; then
3248     AC_DEFINE(HAVE_UINT16_T,1,[Define if uint16_t is supported by the C compiler])
3249 fi
3250 if test "$ac_cv_c_uint32_t" != no ; then
3251     AC_DEFINE(HAVE_UINT32_T,1,[Define if uint32_t is supported by the C compiler])
3252 fi
3253 if test "$ac_cv_c_uint64_t" != no ; then
3254     AC_DEFINE(HAVE_UINT64_T,1,[Define if uint64_t is supported by the C compiler])
3255 fi
3256
3257 # Other C99 types.
3258 AC_CHECK_HEADERS([stdbool.h complex.h])
3259 AC_CHECK_SIZEOF([_Bool],0,[
3260 #ifdef HAVE_STDBOOL_H
3261 #include <stdbool.h>
3262 #endif
3263 ])
3264 AC_CHECK_SIZEOF([float _Complex],0,[
3265 #ifdef HAVE_COMPLEX_H
3266 #include <complex.h>
3267 #endif
3268 ])
3269 AC_CHECK_SIZEOF([double _Complex],0,[
3270 #ifdef HAVE_COMPLEX_H
3271 #include <complex.h>
3272 #endif
3273 ])
3274 AS_IF([test "X$pac_cv_have_long_double" = "Xyes"],[
3275   AC_CHECK_SIZEOF([long double _Complex],0,[
3276 #ifdef HAVE_COMPLEX_H
3277 #include <complex.h>
3278 #endif
3279   ])
3280 ])
3281
3282 # we need really could just use the result of AC_CHECK_SIZEOF, but having a
3283 # HAVE_typename macro is useful for consistency
3284 AC_CHECK_TYPES([_Bool, float _Complex, double _Complex])
3285
3286 AS_IF([test "X$pac_cv_have_long_double" = "Xyes"],[
3287   AC_CHECK_TYPES([long double _Complex])
3288 ])
3289
3290 # Generate a hex version of the size of each type
3291 for type in short int long long_long float double long_double wchar_t \
3292     float_int double_int long_int short_int two_int long_double_int     \
3293     _Bool float__Complex double__Complex long_double__Complex ; do
3294     eval len=\$ac_cv_sizeof_$type
3295     if test -z "$len" ; then 
3296        len=0
3297        # Check for sizes from the CHECK_SIZEOF_DERIVED macro
3298        eval pclen=\$ac_cv_sizeof_$type
3299        if test -n "$pclen" ; then
3300            len=$pclen
3301        else
3302            # check for a non-optional type
3303            if test $type != long_long -a \
3304                    $type != long_double -a \
3305                    $type != long_double_int -a \
3306                    $type != _Bool -a \
3307                    $type != float__Complex -a \
3308                    $type != double__Complex -a \
3309                    $type != long_double__Complex ; then
3310                AC_MSG_ERROR([Configure was unable to determine the size of $type ; if cross compiling,
3311 use the environment variables CROSS_SIZEOF_typename, e.g., CROSS_SIZEOF_SHORT,
3312 or use the --with-cross=file configure option to specify a file containing
3313 Bourne (sh) shell assignments to CROSS_SIZEOF_typename for all datatype 
3314 types.  The program maint/getcross.c can be compiled and run on the target
3315 system; this program outputs an appropriate file for the --with-cross option])
3316            fi
3317        fi
3318     fi
3319     #
3320     # Take len and turn it into two hex digits (there are 8 bits available
3321     # in the built-in datatype handle for the length; see
3322     # src/mpid/common/datatype/mpidu_datatype.h)
3323     if test "$len" -gt 255 ; then
3324          AC_MSG_ERROR([Type sizes greater than 255 bytes are not supported (type $type is $len bytes)]) 
3325     fi
3326     tmplen=$len
3327     hexlen=""
3328     while test $tmplen -gt 0 ; do
3329         lowdigit=`expr $tmplen - 16 \* \( $tmplen / 16 \)`
3330         case $lowdigit in 
3331          10) char=a ;;
3332          11) char=b ;;
3333          12) char=c ;;
3334          13) char=d ;;
3335          14) char=e ;;
3336          15) char=f ;;
3337           *) char=$lowdigit ;;
3338         esac
3339         hexlen="$char$hexlen"
3340         tmplen=`expr $tmplen / 16`
3341     done
3342     if test $len -lt 16 ; then
3343         hexlen="0$hexlen"
3344     fi
3345     if test $len = 0 ; then
3346         # This sometimes happens for wchar_t
3347         hexlen="00";
3348     fi
3349     eval len_$type=$hexlen
3350 done
3351 # By definition, sizeof char is 1
3352 MPI_CHAR="0x4c000101"
3353 MPI_UNSIGNED_CHAR="0x4c000102"
3354 MPI_SHORT="0x4c00${len_short}03"
3355 MPI_UNSIGNED_SHORT="0x4c00${len_short}04"
3356 MPI_INT="0x4c00${len_int}05"
3357 MPI_UNSIGNED_INT="0x4c00${len_int}06"
3358 MPI_LONG="0x4c00${len_long}07"
3359 MPI_UNSIGNED_LONG="0x4c00${len_long}08"
3360 if test "$len_long_long" != 0 -a "$MPID_NO_LONG_LONG" != yes ; then
3361     MPI_LONG_LONG="0x4c00${len_long_long}09"
3362 else 
3363     MPI_LONG_LONG=MPI_DATATYPE_NULL;
3364 fi
3365 MPI_FLOAT="0x4c00${len_float}0a"
3366 MPI_DOUBLE="0x4c00${len_double}0b"
3367 if test "$len_long_double" != 0 -a "$MPID_NO_LONG_DOUBLE" != yes ; then
3368     MPI_LONG_DOUBLE="0x4c00${len_long_double}0c"
3369 else
3370     MPI_LONG_DOUBLE=MPI_DATATYPE_NULL
3371 fi
3372 # If you change MPI_BYTE, you must change it in src/binding/fortran/mpif_h/buildiface
3373 MPI_BYTE="0x4c00010d"
3374 MPI_WCHAR="0x4c00${len_wchar_t}0e"
3375 MPI_PACKED="0x4c00010f"
3376 MPI_LB="0x4c000010"
3377 MPI_UB="0x4c000011"
3378 #
3379 # These should define the mixed types *only* for contiguous data.
3380 # For example, MPI_SHORT_INT may have a gap; it will need to be defined
3381 # as a derived type instead.  For IA32, this only affects short_int.
3382 MPI_2INT="0x4c00${len_two_int}16"
3383 #
3384 # For now we aren't being too clever about figuring out which of these
3385 # are in fact contiguous, so these are all allocated as "real" types.
3386 #
3387 # These values correspond to direct types 0..5.
3388 #
3389 dnl MPI_FLOAT_INT="0x4c00${len_float_int}12"
3390 dnl MPI_DOUBLE_INT="0x4c00${len_double_int}13"
3391 dnl MPI_LONG_INT="0x4c00${len_long_int}14"
3392 dnl MPI_SHORT_INT="0x4c00${len_short_int}15"
3393 dnl MPI_LONG_DOUBLE_INT="0x4c00${len_long_double_int}17"
3394 MPI_FLOAT_INT="0x8c000000"
3395 MPI_DOUBLE_INT="0x8c000001"
3396 MPI_LONG_INT="0x8c000002"
3397 MPI_SHORT_INT="0x8c000003"
3398 if test "$MPID_NO_LONG_DOUBLE" != yes ; then
3399     MPI_LONG_DOUBLE_INT="0x8c000004"
3400 else
3401     MPI_LONG_DOUBLE_INT=MPI_DATATYPE_NULL
3402 fi
3403
3404 # 2 additional predefined types named in MPI-2
3405 MPI_SIGNED_CHAR="0x4c000118"
3406 if test "$len_long_long" != 0 -a "$MPID_NO_LONG_LONG" != yes ; then
3407     MPI_UNSIGNED_LONG_LONG="0x4c00${len_long_long}19"
3408 else
3409     MPI_UNSIGNED_LONG_LONG=MPI_DATATYPE_NULL
3410 fi
3411
3412 AC_SUBST(MPI_CHAR)
3413 AC_SUBST(MPI_UNSIGNED_CHAR)
3414 AC_SUBST(MPI_SHORT)
3415 AC_SUBST(MPI_UNSIGNED_SHORT)
3416 AC_SUBST(MPI_INT)
3417 AC_SUBST(MPI_UNSIGNED_INT)
3418 AC_SUBST(MPI_LONG)
3419 AC_SUBST(MPI_UNSIGNED_LONG)
3420 AC_SUBST(MPI_LONG_LONG)
3421 AC_SUBST(MPI_FLOAT)
3422 AC_SUBST(MPI_DOUBLE)
3423 AC_SUBST(MPI_LONG_DOUBLE)
3424 AC_SUBST(MPI_BYTE)
3425 AC_SUBST(MPI_WCHAR)
3426 AC_SUBST(MPI_PACKED)
3427 AC_SUBST(MPI_LB)
3428 AC_SUBST(MPI_UB)
3429 AC_SUBST(MPI_FLOAT_INT)
3430 AC_SUBST(MPI_DOUBLE_INT)
3431 AC_SUBST(MPI_LONG_INT)
3432 AC_SUBST(MPI_SHORT_INT)
3433 AC_SUBST(MPI_2INT)
3434 AC_SUBST(MPI_LONG_DOUBLE_INT)
3435 AC_SUBST(MPI_SIGNED_CHAR)
3436 AC_SUBST(MPI_UNSIGNED_LONG_LONG)
3437 #
3438 # FIXME: Leftover from separate fortran system
3439 ## Export the basic C types so that the Fortran system can use them
3440 #export MPI_CHAR
3441 #export MPI_SHORT
3442 #export MPI_INT
3443 #export MPI_LONG
3444 #export MPI_LONG_LONG
3445 #export MPI_FLOAT
3446 #export MPI_DOUBLE
3447 #export MPI_LONG_DOUBLE
3448 #
3449 # Size-specific types.  Initialize as NULL
3450 MPI_REAL4=MPI_DATATYPE_NULL
3451 MPI_REAL8=MPI_DATATYPE_NULL
3452 MPI_REAL16=MPI_DATATYPE_NULL
3453 MPI_COMPLEX8=MPI_DATATYPE_NULL
3454 MPI_COMPLEX16=MPI_DATATYPE_NULL
3455 MPI_COMPLEX32=MPI_DATATYPE_NULL
3456 MPI_INTEGER1=MPI_DATATYPE_NULL
3457 MPI_INTEGER2=MPI_DATATYPE_NULL
3458 MPI_INTEGER4=MPI_DATATYPE_NULL
3459 MPI_INTEGER8=MPI_DATATYPE_NULL
3460 MPI_INTEGER16=MPI_DATATYPE_NULL
3461 AC_SUBST(MPI_REAL4)
3462 AC_SUBST(MPI_REAL8)
3463 AC_SUBST(MPI_REAL16)
3464 AC_SUBST(MPI_COMPLEX8)
3465 AC_SUBST(MPI_COMPLEX16)
3466 AC_SUBST(MPI_COMPLEX32)
3467 AC_SUBST(MPI_INTEGER1)
3468 AC_SUBST(MPI_INTEGER2)
3469 AC_SUBST(MPI_INTEGER4)
3470 AC_SUBST(MPI_INTEGER8)
3471 AC_SUBST(MPI_INTEGER16)
3472 export MPI_REAL4
3473 export MPI_REAL8
3474 export MPI_REAL16
3475 export MPI_COMPLEX8
3476 export MPI_COMPLEX16
3477 export MPI_COMPLEX32
3478 export MPI_INTEGER1
3479 export MPI_INTEGER2
3480 export MPI_INTEGER4
3481 export MPI_INTEGER8
3482 export MPI_INTEGER16
3483 #
3484 # Try to find corresponding types for the size-specific types.
3485 #
3486 # Assume that the float/double/long double are simply spaced
3487 # Datatypes used up through 26 in Fortran
3488 # 27,28,29,2a,2b,2c
3489 if test "$ac_cv_sizeof_float" = "4" ; then
3490     MPI_REAL4="0x4c000427"
3491     MPI_COMPLEX8="0x4c000828"
3492     MPIR_REAL4_CTYPE=float
3493 fi
3494 if test "$ac_cv_sizeof_double" = "8" ; then
3495     MPI_REAL8="0x4c000829"
3496     MPI_COMPLEX16="0x4c00102a"
3497     MPIR_REAL8_CTYPE=double
3498 fi
3499 if test "$ac_cv_sizeof_long_double" = "16" -a "$MPID_NO_LONG_DOUBLE" != yes ; then
3500     MPI_REAL16="0x4c00102b"
3501     MPI_COMPLEX32="0x4c00202c"
3502     MPIR_REAL16_CTYPE="long double"
3503 fi
3504 if test -n "$MPIR_REAL4_CTYPE" ; then
3505     AC_DEFINE_UNQUOTED(MPIR_REAL4_CTYPE,$MPIR_REAL4_CTYPE,[C type to use for MPI_REAL4])
3506 fi
3507 if test -n "$MPIR_REAL8_CTYPE" ; then
3508     AC_DEFINE_UNQUOTED(MPIR_REAL8_CTYPE,$MPIR_REAL8_CTYPE,[C type to use for MPI_REAL8])
3509 fi
3510 if test -n "$MPIR_REAL16_CTYPE" ; then
3511     AC_DEFINE_UNQUOTED(MPIR_REAL16_CTYPE,$MPIR_REAL16_CTYPE,[C type to use for MPI_REAL16])
3512 fi
3513 # For complex 8/16/32, we assume that these are 2 consequetive real4/8/16
3514 #
3515 # Search for the integer types
3516 for type in char short int long long_long ; do
3517     # ctype is a valid C type which we can use to declare a C version of 
3518     # this item
3519     ctype=`echo $type | sed 's/_/ /'`
3520     eval len=\$ac_cv_sizeof_$type
3521     if test -n "$len" ; then 
3522     case $len in 
3523     1) if test "$MPI_INTEGER1" = "MPI_DATATYPE_NULL" ; then
3524            MPI_INTEGER1="0x4c00012d"
3525            MPIR_INTEGER1_CTYPE="$ctype"
3526        fi
3527        ;;
3528     2) if test "$MPI_INTEGER2" = "MPI_DATATYPE_NULL" ; then
3529            MPI_INTEGER2="0x4c00022f"
3530            MPIR_INTEGER2_CTYPE="$ctype"
3531        fi
3532        ;;
3533     4) if test "$MPI_INTEGER4" = "MPI_DATATYPE_NULL" ; then
3534            MPI_INTEGER4="0x4c000430"
3535            MPIR_INTEGER4_CTYPE="$ctype"
3536        fi
3537        ;;
3538     8) if test "$MPI_INTEGER8" = "MPI_DATATYPE_NULL" ; then
3539            MPI_INTEGER8="0x4c000831"
3540            MPIR_INTEGER8_CTYPE="$ctype"
3541        fi
3542        ;;
3543     16) if test "$MPI_INTEGER16" = "MPI_DATATYPE_NULL" ; then
3544            MPI_INTEGER16="0x4c001032"
3545            MPIR_INTEGER16_CTYPE="$ctype"
3546        fi
3547        ;;
3548     *)
3549     ;;
3550     esac
3551     fi
3552 done
3553 #
3554 # Add the definitions of these types
3555 if test -n "$MPIR_INTEGER1_CTYPE" ; then
3556     AC_DEFINE_UNQUOTED(MPIR_INTEGER1_CTYPE,$MPIR_INTEGER1_CTYPE,[C type to use for MPI_INTEGER1])
3557 fi
3558 if test -n "$MPIR_INTEGER2_CTYPE" ; then
3559    AC_DEFINE_UNQUOTED(MPIR_INTEGER2_CTYPE,$MPIR_INTEGER2_CTYPE,[C type to use for MPI_INTEGER2])
3560 fi
3561 if test -n "$MPIR_INTEGER4_CTYPE" ; then
3562    AC_DEFINE_UNQUOTED(MPIR_INTEGER4_CTYPE,$MPIR_INTEGER4_CTYPE,[C type to use for MPI_INTEGER4])
3563 fi
3564 if test -n "$MPIR_INTEGER8_CTYPE" ; then
3565    AC_DEFINE_UNQUOTED(MPIR_INTEGER8_CTYPE,$MPIR_INTEGER8_CTYPE,[C type to use for MPI_INTEGER8])
3566 fi
3567 if test -n "$MPIR_INTEGER16_CTYPE" ; then
3568    AC_DEFINE_UNQUOTED(MPIR_INTEGER16_CTYPE,$MPIR_INTEGER16_CTYPE,[C type to use for MPI_INTEGER16])
3569 fi
3570
3571 # ----------------------------------------------------------------------------
3572
3573 # C99 types
3574 # The predefined types must be distinct types (as opposed to aliases to MPI_INT
3575 # or MPI_WHATEVER) in order to correctly support MPI_Type_{get,set}_name.
3576 #
3577 # FIXME the "basic id" portion should be automatically assigned.  It's too easy
3578 # to have a conflict when this is done by hand.
3579 #
3580 # Because we make up a matching type for the fixed-width types if one doesn't
3581 # exist, we don't ever set these to MPI_DATATYPE_NULL.  If we come across a
3582 # platform where 64-bit sizes aren't supported just add a test like the other
3583 # types.
3584 MPI_INT8_T=0x4c000137
3585 MPI_INT16_T=0x4c000238
3586 MPI_INT32_T=0x4c000439
3587 MPI_INT64_T=0x4c00083a
3588 MPI_UINT8_T=0x4c00013b
3589 MPI_UINT16_T=0x4c00023c
3590 MPI_UINT32_T=0x4c00043d
3591 MPI_UINT64_T=0x4c00083e
3592
3593 # The compiler may or may not support these types, depending on its level of C99
3594 # compliance.  We check for each one individually before assigning a handle
3595 # number.
3596 MPI_C_BOOL=MPI_DATATYPE_NULL
3597 MPI_C_FLOAT_COMPLEX=MPI_DATATYPE_NULL
3598 MPI_C_DOUBLE_COMPLEX=MPI_DATATYPE_NULL
3599 MPI_C_LONG_DOUBLE_COMPLEX=MPI_DATATYPE_NULL
3600 if test ${len__Bool} != 0 ; then
3601     MPI_C_BOOL=0x4c00${len__Bool}3f
3602 fi
3603 if test ${len_float__Complex} != 0 ; then
3604     MPI_C_FLOAT_COMPLEX=0x4c00${len_float__Complex}40
3605 fi
3606 if test ${len_double__Complex} != 0 ; then
3607     MPI_C_DOUBLE_COMPLEX=0x4c00${len_double__Complex}41
3608 fi
3609 if test ${len_long_double__Complex} != 0 ; then
3610     MPI_C_LONG_DOUBLE_COMPLEX=0x4c00${len_long_double__Complex}42
3611 fi
3612
3613 AC_SUBST(MPI_INT8_T)
3614 AC_SUBST(MPI_INT16_T)
3615 AC_SUBST(MPI_INT32_T)
3616 AC_SUBST(MPI_INT64_T)
3617 AC_SUBST(MPI_UINT8_T)
3618 AC_SUBST(MPI_UINT16_T)
3619 AC_SUBST(MPI_UINT32_T)
3620 AC_SUBST(MPI_UINT64_T)
3621 AC_SUBST(MPI_C_BOOL)
3622 AC_SUBST(MPI_C_FLOAT_COMPLEX)
3623 AC_SUBST(MPI_C_DOUBLE_COMPLEX)
3624 AC_SUBST(MPI_C_LONG_DOUBLE_COMPLEX)
3625 export MPI_INT8_T
3626 export MPI_INT16_T
3627 export MPI_INT32_T
3628 export MPI_INT64_T
3629 export MPI_UINT8_T
3630 export MPI_UINT16_T
3631 export MPI_UINT32_T
3632 export MPI_UINT64_T
3633 export MPI_C_BOOL
3634 export MPI_C_FLOAT_COMPLEX
3635 export MPI_C_DOUBLE_COMPLEX
3636 export MPI_C_LONG_DOUBLE_COMPLEX
3637
3638
3639 # ----------------------------------------------------------------------------
3640 # We can now create the Fortran versions of the datatype values, along with
3641 # some of the other datatype-dependent sizes
3642
3643 # There are two parts to handling the datatypes:
3644 #    Convert the C datatype values to their Fortran equivalent.  This
3645 #    involves converting the hex values for the C version into decimal
3646 #    since standard Fortran does not have hex constants
3647 #
3648 #    Determine the existence of the Fortran 'sized' types and set those
3649 #    values.
3650 #
3651 # In addition, we need to look at a few additional constants that depend
3652 # on how the compiler sizes some datatypes.  These are:
3653 #    STATUS_SIZE, INTEGER_KIND, ADDRESS_KIND, and OFFSET_KIND
3654
3655 # ----------------------------------------------------------------------------
3656 if test "$enable_f77" = yes ; then
3657     # Up to size checking code in master configure.ac (where it tries to 
3658     # find the matching C sizes) as part of defining mpi_integer8 etc.
3659     # The results are available in pac_cv_sizeof_f77_<type>
3660     # Size is 0 if unknown or unavailable (or cross-compiling)
3661     # Due to limitations in autoconf, we cannot put these into a loop.
3662     # We also check integer to find the type of MPI_Fint
3663     #
3664     # Cross-compilation results can be included with the --with-cross=file
3665     # option.
3666     CROSS_F77_SIZEOF_INTEGER=${CROSS_F77_SIZEOF_INTEGER:-0}
3667     CROSS_F77_SIZEOF_REAL=${CROSS_F77_SIZEOF_REAL:-0}
3668     CROSS_F77_SIZEOF_DOUBLE_PRECISION=${CROSS_F77_SIZEOF_DOUBLE_PRECISION:-0}
3669     PAC_PROG_F77_CHECK_SIZEOF_EXT(integer,$CROSS_F77_SIZEOF_INTEGER)
3670     PAC_PROG_F77_CHECK_SIZEOF_EXT(real,$CROSS_F77_SIZEOF_REAL)
3671     PAC_PROG_F77_CHECK_SIZEOF_EXT(double precision,$CROSS_F77_SIZEOF_DOUBLE_PRECISION)
3672     AC_LANG_FORTRAN77
3673     # If we have sizes for real and double, we do not need to call 
3674     # mpir_get_fsize at run time.
3675     # For the size-defined types (e.g., integer*2), we assume that if the
3676     # compiler allows it, it has the stated size.
3677     AC_CACHE_CHECK([whether integer*1 is supported],pac_cv_fort_integer1,[
3678     AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,[      integer*1 i])],
3679          pac_cv_fort_integer1=yes,
3680          pac_cv_fort_integer1=no)])
3681     AC_CACHE_CHECK([whether integer*2 is supported],pac_cv_fort_integer2,[
3682     AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,[      integer*2 i])],
3683         pac_cv_fort_integer2=yes,
3684         pac_cv_fort_integer2=no)])
3685     AC_CACHE_CHECK([whether integer*4 is supported],pac_cv_fort_integer4,[
3686     AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,[      integer*4 i])],
3687         pac_cv_fort_integer4=yes,
3688         pac_cv_fort_integer4=no)])
3689     AC_CACHE_CHECK([whether integer*8 is supported],pac_cv_fort_integer8,[
3690     AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,[      integer*8 i])],
3691         pac_cv_fort_integer8=yes,
3692         pac_cv_fort_integer8=no)])
3693     AC_CACHE_CHECK([whether integer*16 is supported],pac_cv_fort_integer16,[
3694     AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,[      integer*16 i])],
3695         pac_cv_fort_integer16=yes,
3696         pac_cv_fort_integer16=no)])
3697     AC_CACHE_CHECK([whether real*4 is supported],pac_cv_fort_real4,[
3698     AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,[      real*4 a])],
3699         pac_cv_fort_real4=yes,
3700         pac_cv_fort_real4=no)])
3701     AC_CACHE_CHECK([whether real*8 is supported],pac_cv_fort_real8,[
3702     AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,[      real*8 a])],
3703         pac_cv_fort_real8=yes,
3704         pac_cv_fort_real8=no)])
3705     AC_CACHE_CHECK([whether real*16 is supported],pac_cv_fort_real16,[
3706     AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,[      real*16 a])],
3707         pac_cv_fort_real16=yes,
3708         pac_cv_fort_real16=no)])
3709
3710     # Create the default datatype names for the standard MPI Fortran types
3711     MPI_CHARACTER=0x4c00011a
3712     AC_SUBST(MPI_CHARACTER)
3713
3714     if test -z "$pac_cv_f77_sizeof_integer" -o \
3715        "X$pac_cv_f77_sizeof_integer" = "X0" ; then
3716         AC_MSG_ERROR([Unable to configure with Fortran support because configure could not determine the size of a Fortran INTEGER.  Consider setting CROSS_F77_SIZEOF_INTEGER to the length in bytes of a Fortran INTEGER])
3717     fi
3718     len_integer=$pac_cv_f77_sizeof_integer
3719     # Convert to two digit hex
3720     len=$len_integer
3721     #
3722     # Take len and turn it into two hex digits (there are 8 bits available
3723     # in the built-in datatype handle for the length; see
3724     # src/mpid/common/datatype/mpidu_datatype.h).  This code is taken
3725     # from the code in mpich/configure.ac 
3726     if test "$len" -gt 255 ; then
3727         AC_MSG_ERROR([Type sizes greater than 255 bytes are not supported (type INTEGER is $len bytes)]) 
3728     fi
3729     tmplen=$len
3730     hexlen=""
3731     while test $tmplen -gt 0 ; do
3732         lowdigit=`expr $tmplen - 16 \* \( $tmplen / 16 \)`
3733         case $lowdigit in 
3734         10) char=a ;;
3735         11) char=b ;;
3736         12) char=c ;;
3737         13) char=d ;;
3738         14) char=e ;;
3739         15) char=f ;;
3740          *) char=$lowdigit ;;
3741         esac
3742         hexlen="$char$hexlen"
3743         tmplen=`expr $tmplen / 16`
3744     done
3745     if test $len -lt 16 ; then
3746         hexlen="0$hexlen"
3747     fi
3748     len_integer=$hexlen
3749     if test "$len_integer" = 0 ; then
3750         # We have a problem
3751         AC_MSG_WARN([Unable to determine size of an INTEGER type; using 4])
3752         # We make the length 4
3753         len_integer="04"
3754     fi
3755     MPI_INTEGER=0x4c00${len_integer}1b
3756     MPI_REAL=0x4c00${len_integer}1c
3757     MPI_LOGICAL=0x4c00${len_integer}1d
3758     AC_SUBST(MPI_INTEGER)
3759     AC_SUBST(MPI_REAL)
3760     AC_SUBST(MPI_LOGICAL)
3761
3762     if test -z "$pac_cv_f77_sizeof_double_precision" ; then
3763         AC_MSG_ERROR([Unable to configure with Fortran support because configure could not determine the size of a Fortran DOUBLE PRECISION.  Consider setting CROSS_F77_SIZEOF_DOUBLE_PRECISION to the length in bytes of a Fortran DOUBLE PRECISION])
3764     fi
3765     len_double=$pac_cv_f77_sizeof_double_precision
3766     # Convert to two digit hex
3767     len=$len_double
3768     #
3769     # Take len and turn it into two hex digits (there are 8 bits available
3770     # in the built-in datatype handle for the length; see
3771     # src/mpid/common/datatype/mpidu_datatype.h).  This code is taken
3772     # from the code in mpich/configure.ac 
3773     if test "$len" -gt 255 ; then
3774         AC_MSG_ERROR([Type sizes greater than 255 bytes are not supported (type DOUBLE is $len bytes)]) 
3775     fi
3776     tmplen=$len
3777     hexlen=""
3778     while test $tmplen -gt 0 ; do
3779         lowdigit=`expr $tmplen - 16 \* \( $tmplen / 16 \)`
3780         case $lowdigit in 
3781         10) char=a ;;
3782         11) char=b ;;
3783         12) char=c ;;
3784         13) char=d ;;
3785         14) char=e ;;
3786         15) char=f ;;
3787          *) char=$lowdigit ;;
3788         esac
3789         hexlen="$char$hexlen"
3790         tmplen=`expr $tmplen / 16`
3791     done
3792     if test $len -lt 16 ; then
3793         hexlen="0$hexlen"
3794     fi 
3795     len_double=$hexlen
3796     if test "$len_double" = 0 ; then
3797        # We have a problem
3798        AC_MSG_WARN([Unable to determine size of a DOUBLE PRECISION type; using 8])
3799        # We make the length 8
3800        len_double="08"
3801     fi
3802
3803     # Provide the corresponding C types for MPI_REAL and MPI_DOUBLE
3804     AC_MSG_CHECKING([for C type matching Fortran real])
3805     noval=yes
3806     for c_type in float double "long_double" ; do
3807         eval ctypelen=\$"ac_cv_sizeof_$c_type"
3808         if test "$pac_cv_f77_sizeof_real" = "$ctypelen" -a \
3809           "$ctypelen" -gt 0 ; then
3810             c_type=`echo $c_type | sed -e 's/_/ /g'`
3811             AC_MSG_RESULT($c_type)
3812             MPIR_FC_REAL_CTYPE=$c_type
3813             noval="no"
3814             break
3815         fi
3816     done
3817     if test "$noval" = "yes" ; then
3818         # Set a default
3819         MPIR_FC_REAL_CTYPE="float"
3820         AC_MSG_RESULT([unavailable])
3821     fi
3822
3823     noval=yes
3824     AC_MSG_CHECKING([for C type matching Fortran double])
3825     for c_type in double "long_double" float ; do
3826         eval ctypelen=\$"ac_cv_sizeof_$c_type"
3827         if test "$pac_cv_f77_sizeof_double_precision" = "$ctypelen" -a \
3828           "$ctypelen" -gt 0 ; then
3829             c_type=`echo $c_type | sed -e 's/_/ /g'`
3830             AC_MSG_RESULT($c_type)
3831             MPIR_FC_DOUBLE_CTYPE=$c_type
3832             noval="no"
3833             break
3834         fi
3835     done
3836     if test "$noval" = "yes" ; then
3837         # Set a default
3838         MPIR_FC_DOUBLE_CTYPE="double"
3839         AC_MSG_RESULT([unavailable])
3840     fi
3841
3842     # These are needed to correctly implement the MPI reduction operations
3843     AC_DEFINE_UNQUOTED([MPIR_FC_REAL_CTYPE],[$MPIR_FC_REAL_CTYPE],
3844      [The C type for FORTRAN REAL])
3845     AC_DEFINE_UNQUOTED([MPIR_FC_DOUBLE_CTYPE],[$MPIR_FC_DOUBLE_CTYPE],
3846      [The C type for FORTRAN DOUBLE PRECISION])
3847
3848     # Use the proper length values for these items in case we are building
3849     # with Fortran integers that are not the same size as C ints and 
3850     # reals and double precision that are the same size (not valid Fortran,
3851     # but used by some applications)
3852
3853     len_2integer=`expr 2 \* $len_integer`
3854     len_2real=`expr 2 \* $len_integer`
3855     len_doublecplx=`expr $pac_cv_f77_sizeof_double_precision \* 2`
3856     if test "$len_doublecplx" = 0 ; then
3857         # We have a problem
3858         AC_MSG_WARN([Unable to determine size of a DOUBLE PRECISION type; using 8])
3859         # We make the length 8*2 (in hex)
3860         len_doublecplx="16"
3861     fi
3862
3863     for lenname in len_2integer len_2real len_doublecplx ; do
3864         eval len=\$$lenname
3865         if test "$len" -gt 255 ; then
3866             AC_MSG_ERROR([Type sizes greater than 255 bytes are not supported (type $lenname is $len bytes)]) 
3867         fi          
3868         tmplen=$len
3869         hexlen=""
3870         while test $tmplen -gt 0 ; do
3871             lowdigit=`expr $tmplen - 16 \* \( $tmplen / 16 \)`
3872             case $lowdigit in 
3873             10) char=a ;;
3874             11) char=b ;;
3875             12) char=c ;;
3876             13) char=d ;;
3877             14) char=e ;;
3878             15) char=f ;;
3879             *) char=$lowdigit ;;
3880             esac
3881             hexlen="$char$hexlen"
3882             tmplen=`expr $tmplen / 16`
3883         done
3884         if test $len -lt 16 ; then
3885             hexlen="0$hexlen"
3886         fi 
3887         eval ${lenname}=$hexlen
3888         if test "$hexlen" = 0 ; then
3889            # We have a problem
3890            AC_MSG_WARN([Unable to determine size of a $lenname type; using 8])
3891            # We make the length 8
3892            eval ${lenname}=$hexlen
3893         fi
3894     done
3895
3896     MPI_DOUBLE_PRECISION=0x4c00${len_double}1f
3897     MPI_2INTEGER=0x4c00${len_2integer}20
3898     MPI_2REAL=0x4c00${len_2real}21
3899     MPI_COMPLEX=0x4c00${len_2real}1e
3900     AC_SUBST(MPI_COMPLEX)
3901     AC_SUBST(MPI_DOUBLE_PRECISION)
3902     AC_SUBST(MPI_2INTEGER)
3903     AC_SUBST(MPI_2REAL)
3904
3905 dnl     len=$len_doublecplx
3906 dnl     #
3907 dnl     # Take len and turn it into two hex digits (there are 8 bits available
3908 dnl     # in the built-in datatype handle for the length; see
3909 dnl     # src/mpid/common/datatype/mpidu_datatype.h).  This code is taken
3910 dnl     # from the code in mpich/configure.ac 
3911 dnl     if test "$len" -gt 255 ; then
3912 dnl         AC_MSG_ERROR([Type sizes greater than 255 bytes are not supported (type DOUBLE COMPLEX is $len bytes)]) 
3913 dnl     fi
3914 dnl     tmplen=$len
3915 dnl     hexlen=""
3916 dnl     while test $tmplen -gt 0 ; do
3917 dnl         lowdigit=`expr $tmplen - 16 \* \( $tmplen / 16 \)`
3918 dnl         case $lowdigit in 
3919 dnl         10) char=a ;;
3920 dnl         11) char=b ;;
3921 dnl         12) char=c ;;
3922 dnl         13) char=d ;;
3923 dnl         14) char=e ;;
3924 dnl         15) char=f ;;
3925 dnl          *) char=$lowdigit ;;
3926 dnl         esac
3927 dnl         hexlen="$char$hexlen"
3928 dnl         tmplen=`expr $tmplen / 16`
3929 dnl     done
3930 dnl     if test $len -lt 16 ; then
3931 dnl         hexlen="0$hexlen"
3932 dnl     fi
3933 dnl     len_doublecplx=$hexlen
3934
3935     MPI_DOUBLE_COMPLEX=0x4c00${len_doublecplx}22
3936     MPI_2DOUBLE_PRECISION=0x4c00${len_doublecplx}23
3937     MPI_2COMPLEX=0x4c00${len_doublecplx}24
3938     AC_SUBST(MPI_DOUBLE_COMPLEX)
3939     AC_SUBST(MPI_2DOUBLE_PRECISION)
3940     AC_SUBST(MPI_2COMPLEX)
3941
3942     #
3943     # Temporary for the vast majority of systems that use 4 byte reals and
3944     # 8 byte doubles
3945     # Lengths at this point are in hex, hence "10" = 10 base 16 = 16 base 10.
3946     if test "$len_double" = "08" ; then
3947         F77_COMPLEX8=$MPI_COMPLEX
3948     fi
3949     if test "$len_doublecplx" = "10" ; then
3950         F77_COMPLEX16=$MPI_DOUBLE_COMPLEX
3951     fi
3952     if test "$len_long_double" = "10" -a "$MPID_NO_LONG_DOUBLE" != "yes" ; then
3953         F77_COMPLEX32="0x4c002025"
3954     else
3955         F77_COMPLEX32="MPI_DATATYPE_NULL"
3956     fi
3957
3958     len_2dc=`expr $pac_cv_f77_sizeof_double_precision \* 4`
3959     firstdigit=0
3960     seconddigit=0
3961     while test $len_2dc -ge 16 ; do
3962         firstdigit=`expr $firstdigit + 1`
3963         len_2dc=`expr $len_2dc - 16`    
3964     done
3965     case $len_2dc in
3966         10) seconddigit=a ;;
3967         11) seconddigit=b ;;
3968         12) seconddigit=c ;;
3969         13) seconddigit=d ;;
3970         14) seconddigit=e ;;
3971         15) seconddigit=f ;;
3972          *) seconddigit=$len_2dc ;;
3973     esac
3974     len_2dc="$firstdigit$seconddigit"
3975     #echo "2double complex = $len_2dc"
3976     MPI_2DOUBLE_COMPLEX=0x4c00${len_2dc}25
3977     AC_SUBST(MPI_2DOUBLE_COMPLEX)
3978     MPI_F77_PACKED=$MPI_PACKED
3979     MPI_F77_UB=$MPI_UB
3980     MPI_F77_LB=$MPI_LB
3981     MPI_F77_BYTE=$MPI_BYTE
3982     AC_SUBST(MPI_F77_PACKED)
3983     AC_SUBST(MPI_F77_UB)
3984     AC_SUBST(MPI_F77_LB)
3985     AC_SUBST(MPI_F77_BYTE)
3986     #
3987     # We must convert all hex values to decimal (!)
3988     # It would be nice to use expr to extract the next character rather than
3989     # the heavier-weight sed, but expr under Tru64 Unix discards leading zeros,
3990     # even when used only with the match (:) command.  Rather than have 
3991     # configure figure out if expr works, we just use sed.  Sigh.
3992     for var in CHARACTER INTEGER REAL LOGICAL DOUBLE_PRECISION COMPLEX \
3993         DOUBLE_COMPLEX 2INTEGER 2REAL 2COMPLEX 2DOUBLE_PRECISION \
3994         2DOUBLE_COMPLEX F77_PACKED F77_UB F77_LB F77_BYTE; do  
3995         fullvar="MPI_$var"
3996         eval fullvarvalue=\$$fullvar
3997         #echo "$fullvar = $fullvarvalue"
3998         value=0
3999         fullvarvalue=`echo $fullvarvalue | sed -e 's/..\(.*\)/\1/'`
4000         for pos in 3 4 5 6 7 8 9 10 ; do
4001             # This works, even for Tru64, because only a single character
4002             # is extracted
4003             char=`expr $fullvarvalue : '\(.\)'`
4004             # FIXME: Tru64 Unix eliminates leading zeros (!)
4005             # How do we fix something that broken?
4006             fullvarvalue=`echo $fullvarvalue | sed -e 's/.\(.*\)/\1/'`
4007             case $char in 
4008                 a) char=10 ;;
4009                 b) char=11 ;;
4010                 c) char=12 ;;
4011                 d) char=13 ;;
4012                 e) char=14 ;;
4013                 f) char=15 ;;
4014             esac
4015             value=`expr $value \* 16 + $char`
4016         done
4017         #echo "$fullvar = $value"
4018         if test "X$value" = "X"; then
4019             eval origvarvalue=\$$fullvar
4020             AC_MSG_ERROR([Internal Error: Failed to convert $fullvar value to hex!  Original value was $origvarvalue])
4021         fi
4022         eval $fullvar=$value
4023     done
4024     AC_LANG_C
4025
4026     # Now, handle the sized types
4027     #
4028     # Preload the C mpi types
4029     # THESE MUST MATCH THE DEFINITIONS IN MPI.H and MPIF.H
4030     # We use these to match the optional Fortran types
4031     char_mpi=${MPI_CHAR:-0}
4032     short_mpi=${MPI_SHORT:-0}
4033     int_mpi=${MPI_INT:-0}
4034     long_mpi=${MPI_LONG:-0}
4035     long_long_mpi=${MPI_LONG_LONG:-0}
4036     float_mpi=${MPI_FLOAT:-0}
4037     double_mpi=${MPI_DOUBLE:-0}
4038     long_double_mpi=${MPI_LONG_DOUBLE:-0}
4039
4040     #
4041     # The following code was correct for MPI-1, which allowed these datatypes
4042     # to be an alias for another MPI type.  MPI-2 requires these to 
4043     # be distinct types, so these are enumerated
4044     if test "$use_alias_types" = yes ; then
4045         for len in 1 2 4 8 16 ; do
4046             eval F77_INTEGER$len=0
4047             #eval testval=\$"pac_cv_f77_sizeof_integer_$len"
4048             eval testval=\$"pac_cv_fort_integer$len"
4049             if test "$testval" = no ; then continue ; fi
4050             testval=$len
4051             noval="yes"
4052             AC_MSG_CHECKING([for C type matching Fortran integer*$len])
4053             for c_type in char short int long "long_long" ; do
4054                 eval ctypelen=\$"ac_cv_sizeof_$c_type"
4055                 if test "$testval" = "$ctypelen" -a "$ctypelen" -gt 0 ; then
4056                     AC_MSG_RESULT($c_type)
4057                     eval F77_INTEGER$len=\$"${c_type}_mpi"
4058                     noval="no"
4059                     break
4060                 fi
4061             done
4062             if test "$noval" = "yes" ; then
4063                 AC_MSG_RESULT([unavailable])
4064             fi
4065         done
4066
4067         # Complex is set separately above
4068         for len in 4 8 16 ; do
4069             len2=`expr $len + $len`
4070             eval F77_REAL$len=0
4071             #eval F77_COMPLEX$len2=0
4072             #eval testval=\$"pac_cv_f77_sizeof_real_$len"
4073             eval testval=\$"pac_cv_fort_real$len"
4074             if test "$testval" = no ; then continue ; fi
4075             testval=$len
4076             noval="yes"
4077             AC_MSG_CHECKING([for C type matching Fortran real*$len])
4078             for c_type in float double "long_double" ; do
4079                 eval ctypelen=\$"ac_cv_sizeof_$c_type"
4080                 if test "$testval" = "$ctypelen" -a "$ctypelen" -gt 0 ; then
4081                     AC_MSG_RESULT($c_type)
4082                     eval F77_REAL$len=\$"${c_type}_mpi"
4083                     #eval F77_COMPLEX$len2=\$"${c_type}_cplx_mpi"
4084                     noval="no"
4085                     break
4086                 fi
4087             done
4088             if test "$noval" = "yes" ; then
4089                 AC_MSG_RESULT([unavailable])
4090             fi
4091         done
4092     else 
4093         # Simply determine which types exist.  These may have been set by the
4094         # toplevel configure
4095         for var in INTEGER1 INTEGER2 INTEGER4 INTEGER8 INTEGER16 \
4096             REAL4 REAL8 REAL16 COMPLEX8 COMPLEX16 COMPLEX32 ; do  
4097             eval varname=MPI_$var
4098             eval varvalue=\$$varname
4099             #echo "$varname = $varvalue"
4100             if test "$varvalue" = MPI_DATATYPE_NULL ; then
4101                 eval F77_$var=0
4102             else
4103                 eval F77_$var=\$$varname
4104             fi
4105        done
4106     fi
4107     # We must convert all hex values to decimal (!)
4108     for var in INTEGER1 INTEGER2 INTEGER4 INTEGER8 INTEGER16 \
4109         REAL4 REAL8 REAL16 COMPLEX8 COMPLEX16 COMPLEX32 ; do  
4110         fullvar="F77_$var"
4111         eval fullvarvalue=\$$fullvar
4112         if test "$fullvarvalue" = 0 -o -z "$fullvarvalue" ; then 
4113             eval $fullvar=MPI_DATATYPE_NULL
4114             continue
4115         fi
4116         #echo "$fullvar = $fullvarvalue"
4117         value=0
4118         # See the comments above on why expr with : cannot be used here
4119         fullvarvalue=`echo $fullvarvalue | sed -e 's/..\(.*\)/\1/'`
4120         for pos in 3 4 5 6 7 8 9 10 ; do
4121             #char=`expr substr $fullvarvalue $pos 1`
4122             char=`expr $fullvarvalue : '\(.\)'`
4123             # We don't test for success of expr here because some expr's are
4124             # buggy and set the status to one on expressions like
4125             #    expr 00ccc : '\(.\)'
4126             # while both
4127             #    expr 00ccc : '\(..\)' 
4128             # and
4129             #    expr 100cc : '\(.\)'
4130             # return a zero status.  So the status is set even on success,
4131             # if the result is a single character that is a zero (!)
4132             #rc=$?
4133             #if test "$rc" != 0 ; then
4134             dnl #    AC_MSG_WARN([Failure (status $rc) in extracting first char from $fullvarvalue])
4135             #    break
4136             #fi
4137             fullvarvalue=`echo $fullvarvalue | sed -e 's/.\(.*\)/\1/'`
4138             case $char in 
4139                 a) char=10 ;;
4140                 b) char=11 ;;
4141                 c) char=12 ;;
4142                 d) char=13 ;;
4143                 e) char=14 ;;
4144                 f) char=15 ;;
4145             esac
4146             value=`expr $value \* 16 + $char`
4147             if test $? != 0 ; then
4148                 AC_MSG_WARN([Failure to evaluate $value \* 16 + $char])
4149             fi
4150         done
4151         #echo "$fullvar = $value"
4152         eval $fullvar=$value
4153     done
4154     AC_SUBST(F77_INTEGER1)
4155     AC_SUBST(F77_INTEGER2)
4156     AC_SUBST(F77_INTEGER4)
4157     AC_SUBST(F77_INTEGER8)
4158     AC_SUBST(F77_INTEGER16)
4159     AC_SUBST(F77_REAL4)
4160     AC_SUBST(F77_REAL8)
4161     AC_SUBST(F77_REAL16)
4162     AC_SUBST(F77_COMPLEX8)
4163     AC_SUBST(F77_COMPLEX16)
4164     AC_SUBST(F77_COMPLEX32)
4165
4166     noval="yes"
4167     AC_MSG_CHECKING([for C type matching Fortran integer])
4168     for c_type in char short int long "long_long" ; do
4169         eval ctypelen=\$"ac_cv_sizeof_$c_type"
4170         if test "$pac_cv_f77_sizeof_integer" = "$ctypelen" -a \
4171           "$ctypelen" -gt 0 ; then
4172             c_type=`echo $c_type | sed -e 's/_/ /g'`
4173             AC_MSG_RESULT($c_type)
4174             MPI_FINT=$c_type
4175             noval="no"
4176             break
4177         fi
4178     done
4179     if test "$noval" = "yes" ; then
4180         # Set a default
4181         MPI_FINT="int"
4182         AC_MSG_RESULT([unavailable])
4183     fi
4184     # We also need to check the size of MPI_Aint vs MPI_Fint, and
4185     # define AINT_LARGER_THAN_FINT if aint is larger (this 
4186     # affects code in MPI_Address)
4187     if test "$ac_cv_sizeof_void_p" != "0" -a \
4188         "$ac_cv_sizeof_void_p" -gt "$pac_cv_f77_sizeof_integer" ; then
4189         AC_DEFINE(HAVE_AINT_LARGER_THAN_FINT,1,[Define if addresses are larger than Fortran integers])
4190     fi
4191     if test "$ac_cv_sizeof_void_p" != 0 -a \
4192         "$ac_cv_sizeof_void_p" != "$pac_cv_f77_sizeof_integer" ; then
4193         AC_DEFINE(HAVE_AINT_DIFFERENT_THAN_FINT,1,[Define if addresses are a different size than Fortran integers])
4194     fi
4195     
4196     # Include a defined value for Fint is int
4197     if test "$MPI_FINT" = "int" ; then
4198         AC_DEFINE(HAVE_FINT_IS_INT,1,[Define if Fortran integer are the same size as C ints])
4199     elif test "$SIZEOF_F77_INTEGER" != "$ac_cv_sizeof_int" ; then
4200         # Make this fatal because we do not want to build a broken fortran
4201         # interface (was error)
4202         # Check to see if the f77 binding has enabled the code to support
4203         # the case of int != fint. 
4204         if grep HAVE_FINT_IS_INT $master_top_srcdir/src/binding/fortran/mpif_h/testf.c 2>&1 1>/dev/null ; then
4205             AC_MSG_WARN([Fortran integers and C ints are not the same size.  Support for this case is experimental; use at your own risk])
4206         else 
4207             AC_MSG_ERROR([Fortran integers and C ints are not the same size.  The current Fortran binding does not support this case.  Either force the Fortran compiler to use integers of $ac_cv_sizeof_int bytes, or use --disable-fortran on the configure line for MPICH.])
4208         fi
4209     fi
4210
4211     # We must convert all hex values to decimal (!).
4212     # This is for the C types so they are also available in Fortran
4213     for var in CHAR SIGNED_CHAR UNSIGNED_CHAR WCHAR SHORT \
4214                   UNSIGNED_SHORT INT UNSIGNED_INT LONG UNSIGNED_LONG \
4215                   FLOAT DOUBLE LONG_DOUBLE LONG_LONG_INT \
4216                   UNSIGNED_LONG_LONG LONG_LONG FLOAT_INT DOUBLE_INT \
4217                   LONG_INT SHORT_INT "2INT" LONG_DOUBLE_INT \
4218                   INT8_T INT16_T INT32_T INT64_T            \
4219                   UINT8_T UINT16_T UINT32_T UINT64_T        \
4220                   C_BOOL C_FLOAT_COMPLEX C_DOUBLE_COMPLEX   \
4221                   C_LONG_DOUBLE_COMPLEX AINT OFFSET ; do
4222         fullvar="MPI_$var"
4223         fullf77var="MPI_F77_$var"
4224         eval fullvarvalue=\$$fullvar
4225         #echo "$fullvar = $fullvarvalue"
4226         if test "x$fullvarvalue" = "x" -o \
4227                 "x$fullvarvalue" = "xMPI_DATATYPE_NULL" ; then
4228              eval $fullf77var="MPI_DATATYPE_NULL"
4229               continue
4230         fi
4231         value=0
4232         fullvarvalue=`echo $fullvarvalue | sed -e 's/..\(.*\)/\1/'`
4233         offset=0
4234         for pos in 3 4 5 6 7 8 9 10 ; do
4235             # This works, even for Tru64, because only a single character
4236             # is extracted
4237             char=`expr $fullvarvalue : '\(.\)'`
4238             # FIXME: Tru64 Unix eliminates leading zeros (!)
4239             # How do we fix something that broken?
4240             fullvarvalue=`echo $fullvarvalue | sed -e 's/.\(.*\)/\1/'`
4241             case $char in 
4242                 a) char=10 ;;
4243                 b) char=11 ;;
4244                 c) char=12 ;;
4245                 d) char=13 ;;
4246                 e) char=14 ;;
4247                 f) char=15 ;;
4248             esac
4249             # For Fortran, if the value is too big for an unsigned int, 
4250             # we need to make it a signed (negative) int. Currently, the
4251             # types in this class are the minloc/maxloc types.
4252             if test $pos = 3 -a $char -ge 8 ; then
4253                 #echo "for $var in position $pos found a value >= 8"
4254                 char=`expr $char - 8`
4255                 offset=-2147483648
4256             fi
4257             value=`expr $value \* 16 + $char`
4258         done
4259         if test "$offset" != 0 ; then 
4260             #echo "$fullf77var: $value, $offset"
4261             value=`expr $value + $offset`
4262         fi
4263         #echo "$fullf77var = $value"
4264         eval $fullf77var=$value
4265     done
4266     AC_SUBST(MPI_F77_CHAR)
4267     AC_SUBST(MPI_F77_SIGNED_CHAR)
4268     AC_SUBST(MPI_F77_UNSIGNED_CHAR)
4269     AC_SUBST(MPI_F77_WCHAR)
4270     AC_SUBST(MPI_F77_SHORT)
4271     AC_SUBST(MPI_F77_UNSIGNED_SHORT)
4272     MPI_F77_UNSIGNED=$MPI_F77_UNSIGNED_INT
4273     AC_SUBST(MPI_F77_UNSIGNED)
4274     AC_SUBST(MPI_F77_INT)
4275     AC_SUBST(MPI_F77_LONG)
4276     AC_SUBST(MPI_F77_UNSIGNED_LONG)
4277     AC_SUBST(MPI_F77_FLOAT)
4278     AC_SUBST(MPI_F77_DOUBLE)
4279     AC_SUBST(MPI_F77_LONG_DOUBLE)
4280     AC_SUBST(MPI_F77_UNSIGNED_LONG_LONG)
4281     MPI_F77_LONG_LONG_INT=$MPI_F77_LONG_LONG
4282     AC_SUBST(MPI_F77_LONG_LONG_INT)
4283     AC_SUBST(MPI_F77_LONG_LONG)
4284     AC_SUBST(MPI_F77_FLOAT_INT)
4285     AC_SUBST(MPI_F77_DOUBLE_INT)
4286     AC_SUBST(MPI_F77_LONG_INT)
4287     AC_SUBST(MPI_F77_SHORT_INT)
4288     AC_SUBST(MPI_F77_2INT)
4289     AC_SUBST(MPI_F77_LONG_DOUBLE_INT)
4290     AC_SUBST(MPI_F77_INT8_T)
4291     AC_SUBST(MPI_F77_INT16_T)
4292     AC_SUBST(MPI_F77_INT32_T)
4293     AC_SUBST(MPI_F77_INT64_T)
4294     AC_SUBST(MPI_F77_UINT8_T)
4295     AC_SUBST(MPI_F77_UINT16_T)
4296     AC_SUBST(MPI_F77_UINT32_T)
4297     AC_SUBST(MPI_F77_UINT64_T)
4298     AC_SUBST(MPI_F77_C_BOOL)
4299     AC_SUBST(MPI_F77_C_FLOAT_COMPLEX)
4300     # C_COMPLEX is an alias for FLOAT_COMPLEX
4301     MPI_F77_C_COMPLEX=$MPI_F77_C_FLOAT_COMPLEX
4302     AC_SUBST(MPI_F77_C_COMPLEX)
4303     AC_SUBST(MPI_F77_C_DOUBLE_COMPLEX)
4304     AC_SUBST(MPI_F77_C_LONG_DOUBLE_COMPLEX)
4305     # these two are not yet defined, but AC_SUBST only cares about them at 
4306     # AC_OUTPUT-time
4307     AC_SUBST(MPI_F77_AINT)
4308     AC_SUBST(MPI_F77_OFFSET)
4309
4310     # Try and compute the values of .true. and .false. in Fortran
4311     # This code has been removed because the Fortran binding code does
4312     # not yet support it.  
4313     PAC_F77_LOGICALS_IN_C([$MPI_FINT])
4314
4315     # Get the INTEGER_KIND, ADDRESS_KIND and OFFSET_KIND if possible
4316     #
4317     # For Fortran 90, we'll also need MPI_ADDRESS_KIND and MPI_OFFSET_KIND
4318     # Since our compiler might BE a Fortran 90 compiler, try and determine the
4319     # values.  
4320     if test "$FC" = "no" ; then
4321         PAC_F77_IS_FC([
4322             FC=$F77
4323             if test -z "$FCFLAGS" ; then
4324                 FCFLAGS="$FFLAGS"
4325             fi
4326         ])
4327     fi
4328     if test "$FC" != "no" ; then
4329         # Offset kind should be for 8 bytes if possible (Romio prefers that)
4330         # address should be sizeof void * (unless --with-aint-size has
4331         # been set)
4332         # FIXME in the current configure implementation OFFSET_KIND and
4333         # MPI_Offset won't always agree, but generally will.  The MPI Standard
4334         # implies that these types must have identical size, so this is a bug
4335         # waiting to happen.
4336         if test "$with_aint_size" -gt 0 -a \
4337                 "$with_aint_size" -gt "$ac_cv_sizeof_void_p" ; then
4338             testsize=$with_aint_size
4339         else
4340             testsize=$ac_cv_sizeof_void_p
4341         fi
4342         if test "$testsize" = 0 ; then
4343             # Set a default
4344             testsize=4
4345         fi  
4346         dnl Using the {} around testsize helps the comments work correctly
4347         PAC_PROG_FC_INT_KIND(ADDRESS_KIND,${testsize},$CROSS_F90_ADDRESS_KIND)
4348         if test "$testsize" = 8 ; then
4349             OFFSET_KIND=$ADDRESS_KIND
4350         else
4351             PAC_PROG_FC_INT_KIND(OFFSET_KIND,8,$CROSS_F90_OFFSET_KIND)
4352         fi
4353         #
4354         PAC_PROG_FC_INT_KIND(INTEGER_KIND,$pac_cv_f77_sizeof_integer,$CROSS_F90_INTEGER_KIND)
4355         if test "$INTEGER_KIND" = "-1" ; then
4356             # In our experience, this usually means that there is some
4357             # problem building and/or running the f90 program.  Fail
4358             # in this case rather than attempt to continue
4359             AC_MSG_ERROR([Unable to determine Fortran 90 KIND values for either address-sized integers or offset-sized integers.])
4360         fi
4361         #
4362         # Some compilers won't allow a -1 kind (e.g., absoft).  In this case, 
4363         # use a fallback (sizeof(int) kind)
4364         if test "$ADDRESS_KIND" = "-1" -o "$OFFSET_KIND" = "-1" ; then
4365             if test "$ADDRESS_KIND" = "-1" ; then
4366                 ADDRESS_KIND=$INTEGER_KIND
4367             fi
4368             if test "$OFFSET_KIND" = "-1" ; then
4369                 OFFSET_KIND=$INTEGER_KIND
4370             fi
4371         fi
4372         AC_LANG_PUSH([Fortran])
4373         AC_CACHE_CHECK([if real*8 is supported in Fortran 90],
4374                        [pac_cv_fort90_real8],[
4375             AC_COMPILE_IFELSE([
4376                 AC_LANG_PROGRAM([],[      real*8 a])
4377             ],[
4378                 pac_cv_fort90_real8=yes
4379             ],[
4380                 pac_cv_fort90_real8=no
4381             ])
4382         ])
4383         AC_LANG_POP([Fortran])
4384         WTIME_DOUBLE_TYPE="DOUBLE PRECISION"
4385         # Save a copy of the original mpi_base.f90 file
4386         if test "$enable_fc" = "yes" -a "$pac_cv_fort90_real8" = "yes" ; then
4387             WTIME_DOUBLE_TYPE="REAL*8"
4388         fi
4389         # WTIME_DOUBLE_TYPE is substituted into mpi_base.f90
4390         AC_SUBST(WTIME_DOUBLE_TYPE)
4391     fi
4392     # Make sure that address kind and offset kind have values.
4393     if test -z "$ADDRESS_KIND" ; then
4394         ADDRESS_KIND=0
4395     fi
4396     if test -z "$OFFSET_KIND" ; then
4397         OFFSET_KIND=0
4398     fi
4399     # Note, however, that zero value are (in all practical case) invalid 
4400     # for Fortran 90, and indicate a failure.  Test and fail if Fortran 90
4401     # enabled.
4402     if test "$enable_fc" = "yes" ; then
4403         if test "$ADDRESS_KIND" -le 0 -o "$OFFSET_KIND" -le 0 ; then
4404             AC_MSG_ERROR([Unable to determine Fortran 90 integer kinds for MPI types.  If you do not need Fortran 90, add --disable-fc to the configure options.])
4405             # If the above is converted to a warning, you need to change 
4406             # enable_fc and remote f90 from the bindings
4407             enable_fc=no
4408         fi
4409     fi
4410     AC_SUBST(ADDRESS_KIND)
4411     AC_SUBST(OFFSET_KIND)
4412     AC_SUBST(INTEGER_KIND)
4413
4414     # Some compilers may require special directives to handle the common 
4415     # block in a library.  In particular, directives are needed for Microsoft 
4416     # Windows to support dynamic library import.  The following six
4417     # directives may be needed:
4418     #  CMS\$ATTRIBUTES DLLIMPORT::/MPIPRIV1/
4419     #  CMS\$ATTRIBUTES DLLIMPORT::/MPIPRIV2/
4420     #  CMS\$ATTRIBUTES DLLIMPORT::/MPIPRIVC/
4421     #  CDEC\$ATTRIBUTES DLLIMPORT::/MPIPRIV1/
4422     #  CDEC\$ATTRIBUTES DLLIMPORT::/MPIPRIV2/
4423     #  CDEC\$ATTRIBUTES DLLIMPORT::/MPIPRIVC/
4424     # CMS is for the Microsoft compiler,
4425     # CDEC is (we believe) for the DEC Fortran compiler.  
4426     # We need to make this a configure-time variable because some compilers
4427     # (in particular, a version of the Intel Fortran compiler for Linux)
4428     # will read directives for other compilers and then flag as fatal
4429     # errors directives that it does not support but does recognize.
4430
4431     DLLIMPORT=""
4432     AC_SUBST(DLLIMPORT)
4433
4434     # FIXME:
4435     # We also need to include
4436     # SIZEOF_FC_MPI_OFFSET
4437     # SIZEOF_FC_MPI_AINT
4438     # 
4439     # If other "kinds" are supported, MPI_SIZEOF needs to identify 
4440     # those as well.  This is very difficult to do in a general way.
4441
4442     # To start with, we use the sizes determined for the Fortran 77 values.
4443     # These must be the same as for the Fortran 90 values.
4444     CROSS_F90_SIZEOF_INTEGER=${CROSS_F90_SIZEOF_INTEGER:-0}
4445     CROSS_F90_SIZEOF_REAL=${CROSS_F90_SIZEOF_REAL:-0}
4446     CROSS_F90_SIZEOF_DOUBLE_PRECISION=${CROSS_F90_SIZEOF_DOUBLE_PRECISION:-0}
4447     SIZEOF_FC_INTEGER=$CROSS_F90_SIZEOF_INTEGER
4448     SIZEOF_FC_REAL=$CROSS_F90_SIZEOF_REAL
4449     SIZEOF_FC_CHARACTER=1
4450     SIZEOF_FC_DOUBLE_PRECISION=$CROSS_F90_SIZEOF_DOUBLE_PRECISION
4451     if test "$pac_cv_f77_sizeof_integer" -gt 0 -a \
4452             "$SIZEOF_FC_INTEGER" = "0" ; then
4453         SIZEOF_FC_INTEGER=$pac_cv_f77_sizeof_integer
4454     fi
4455     if test "$pac_cv_f77_sizeof_real" -gt 0 -a "$SIZEOF_FC_REAL" = "0" ; then
4456         SIZEOF_FC_REAL=$pac_cv_f77_sizeof_real
4457     fi
4458     if test "$pac_cv_f77_sizeof_double_precision" -gt 0 -a \
4459        "$SIZEOF_FC_DOUBLE_PRECISION" = "0" ; then
4460         SIZEOF_FC_DOUBLE_PRECISION=$pac_cv_f77_sizeof_double_precision
4461     fi
4462     AC_SUBST(SIZEOF_FC_INTEGER)
4463     AC_SUBST(SIZEOF_FC_REAL)
4464     AC_SUBST(SIZEOF_FC_DOUBLE_PRECISION)
4465     AC_SUBST(SIZEOF_FC_CHARACTER)
4466
4467     # REQD is short for "real equal double precision" and is set to the
4468     # Fortran 90 comment character if true.  This is necessary to
4469     # allow the mpi_sizeofs module to be built, since if this part of the
4470     # Fortran standard is violated by the compiler (unfortunately common,
4471     # as some applications are written to require this non-standard 
4472     # version), the double precision versions of the MPI_SIZEOF routine
4473     # must be commented out of the module (!).
4474     REQD=
4475     if test "$SIZEOF_FC_REAL" = "$SIZEOF_FC_DOUBLE_PRECISION" ; then
4476         REQD="!"
4477     fi
4478     AC_SUBST(REQD)
4479     # Is integer*1 supported, and is it a different size than integer?
4480     REQI1="!"
4481     if test "$pac_cv_fort_integer1" = yes -a "$SIZEOF_FC_INTEGER" != 1 ; then
4482         REQI1=
4483     fi
4484     AC_SUBST(REQI1)
4485     # Is integer*2 supported, and is it a different size than integer?
4486     REQI2="!"
4487     if test "$pac_cv_fort_integer2" = yes -a "$SIZEOF_FC_INTEGER" != 2 ; then
4488         REQI2=
4489     fi
4490     AC_SUBST(REQI2)
4491     # Is integer*8 supported, and is it a different size than integer?
4492     REQI8="!"
4493     if test "$pac_cv_fort_integer8" = yes -a "$SIZEOF_FC_INTEGER" != 8 ; then
4494         REQI8=
4495     fi
4496     AC_SUBST(REQI8)
4497     # 
4498
4499     AC_LANG_C
4500 fi
4501 # ----------------------------------------------------------------------------
4502 # C++ types
4503
4504 # default to null types
4505 # Set to "0x0c000000" instead of "MPI_DATATYPE_NULL" because these values
4506 # sometimes are used in preprocessor tests where we cannot compare the
4507 # type-casted values.
4508 MPIR_CXX_BOOL=0x0c000000
4509 MPIR_CXX_COMPLEX=0x0c000000
4510 MPIR_CXX_DOUBLE_COMPLEX=0x0c000000
4511 MPIR_CXX_LONG_DOUBLE_COMPLEX=0x0c000000
4512 MPI_F77_CXX_BOOL=MPI_DATATYPE_NULL
4513 MPI_F77_CXX_FLOAT_COMPLEX=MPI_DATATYPE_NULL
4514 MPI_F77_CXX_DOUBLE_COMPLEX=MPI_DATATYPE_NULL
4515 MPI_F77_CXX_LONG_DOUBLE_COMPLEX=MPI_DATATYPE_NULL
4516 if test "$enable_cxx" = "yes" ; then
4517     AC_LANG_CPLUSPLUS
4518     AC_CHECK_SIZEOF(bool)
4519
4520     # Find a C type that matches the size of the C++ boolean type
4521     case "$ac_cv_sizeof_bool" in
4522          $ac_cv_sizeof__Bool)
4523                 bool_type=_Bool
4524                 ;;
4525          $ac_cv_sizeof_unsigned_char)
4526                 bool_type="unsigned char"
4527                 ;;
4528          $ac_cv_sizeof_unsigned_short)
4529                 bool_type="unsigned short"
4530                 ;;
4531          $ac_cv_sizeof_unsigned_int)
4532                 bool_type="unsigned int"
4533                 ;;
4534          $ac_cv_sizeof_unsigned_long)
4535                 bool_type="unsigned long"
4536                 ;;
4537          $ac_cv_sizeof_unsigned_long_long)
4538                 bool_type="unsigned long long"
4539                 ;;
4540          *)
4541                 AC_MSG_ERROR([unable to determine matching C type for C++ bool])
4542                 ;;
4543     esac
4544     AC_DEFINE_UNQUOTED([MPIR_CXX_BOOL_CTYPE],[$bool_type],
4545                         [a C type used to compute C++ bool reductions])
4546
4547     AC_CHECK_HEADER(complex)
4548     if test "$ac_cv_header_complex" = "yes" ; then 
4549         # The C++ complex types are all templated.  We finagle this by 
4550         # defining a standin name
4551         AC_CHECK_SIZEOF(Complex,0,[#include <stdio.h>
4552 #include <complex>
4553 using namespace std;
4554 #define Complex complex<float>
4555 ])
4556         AC_CHECK_SIZEOF(DoubleComplex,0,[#include <stdio.h>
4557 #include <complex>
4558 using namespace std;
4559 #define DoubleComplex complex<double>
4560 ])
4561         if test "$MPID_NO_LONG_DOUBLE" != yes ; then
4562              AC_CHECK_SIZEOF(LongDoubleComplex,0,[#include <stdio.h>
4563 #include <complex>
4564 using namespace std;
4565 #define LongDoubleComplex complex<long double>
4566 ])
4567         fi
4568
4569         # If either complex or double complex have length 0, then mark
4570         # c++ complex as unavailable
4571         if test "$ac_cv_sizeof_Complex" != 0 -a \
4572                 "$ac_cv_sizeof_DoubleComplex" != 0 ; then
4573             AC_DEFINE(HAVE_CXX_COMPLEX,1,[Define is C++ supports complex types])
4574         fi
4575
4576         # Datatypes are given by
4577         # 0x4c00 <length in bytes> (1 byte) <unique num> (1 byte)    
4578         # where the unique nums are
4579         # 33,34,35,36
4580         case "$ac_cv_sizeof_bool" in 
4581            1)    MPIR_CXX_BOOL=0x4c000133 ;;
4582            2)    MPIR_CXX_BOOL=0x4c000233 ;;
4583            4)    MPIR_CXX_BOOL=0x4c000433 ;;
4584            8)    MPIR_CXX_BOOL=0x4c000833 ;;
4585            *) ;;
4586         esac
4587         case "$ac_cv_sizeof_Complex" in 
4588            8)    MPIR_CXX_COMPLEX=0x4c000834 ;;
4589            16)   MPIR_CXX_COMPLEX=0x4c001034 ;;
4590            *) ;;
4591         esac
4592         case "$ac_cv_sizeof_DoubleComplex" in 
4593            8)    MPIR_CXX_DOUBLE_COMPLEX=0x4c000835 ;;
4594            16)   MPIR_CXX_DOUBLE_COMPLEX=0x4c001035 ;;
4595            32)   MPIR_CXX_DOUBLE_COMPLEX=0x4c002035 ;;
4596            *) ;;
4597         esac
4598         # only enable CXX "long double" if we have a C "long double", since we
4599         # currently perform reductions on CXX "long double" types via C.
4600         if test "X$pac_cv_have_long_double" = "Xyes" ; then
4601             case "$ac_cv_sizeof_LongDoubleComplex" in
4602                8)    MPIR_CXX_LONG_DOUBLE_COMPLEX=0x4c000836 ;;
4603                16)   MPIR_CXX_LONG_DOUBLE_COMPLEX=0x4c001036 ;;
4604                24)   MPIR_CXX_LONG_DOUBLE_COMPLEX=0x4c001836 ;;
4605                32)   MPIR_CXX_LONG_DOUBLE_COMPLEX=0x4c002036 ;;
4606                *) ;;
4607             esac
4608         fi
4609     fi
4610     AC_LANG_C
4611
4612     # Make these available to the collective operations and other code
4613     AC_DEFINE_UNQUOTED(MPIR_CXX_BOOL_VALUE,$MPIR_CXX_BOOL,[Define as the MPI Datatype handle for MPI::BOOL])
4614     AC_DEFINE_UNQUOTED(MPIR_CXX_COMPLEX_VALUE,$MPIR_CXX_COMPLEX,[Define as the MPI Datatype handle for MPI::COMPLEX])
4615     AC_DEFINE_UNQUOTED(MPIR_CXX_DOUBLE_COMPLEX_VALUE,$MPIR_CXX_DOUBLE_COMPLEX,[Define as the MPI Datatype handle for MPI::DOUBLE_COMPLEX])
4616     AC_DEFINE_UNQUOTED(MPIR_CXX_LONG_DOUBLE_COMPLEX_VALUE,$MPIR_CXX_LONG_DOUBLE_COMPLEX,[Define as the MPI Datatype handle for MPI::LONG_DOUBLE_COMPLEX])
4617     
4618     # compute F77 decimal constant values for these types
4619     PAC_CONV_HEX_TO_DEC([$MPIR_CXX_BOOL],               [MPI_F77_CXX_BOOL])
4620     PAC_CONV_HEX_TO_DEC([$MPIR_CXX_COMPLEX],            [MPI_F77_CXX_FLOAT_COMPLEX])
4621     PAC_CONV_HEX_TO_DEC([$MPIR_CXX_DOUBLE_COMPLEX],     [MPI_F77_CXX_DOUBLE_COMPLEX])
4622     PAC_CONV_HEX_TO_DEC([$MPIR_CXX_LONG_DOUBLE_COMPLEX],[MPI_F77_CXX_LONG_DOUBLE_COMPLEX])
4623 fi
4624 AC_SUBST([MPIR_CXX_BOOL])
4625 AC_SUBST([MPIR_CXX_COMPLEX])
4626 AC_SUBST([MPIR_CXX_DOUBLE_COMPLEX])
4627 AC_SUBST([MPIR_CXX_LONG_DOUBLE_COMPLEX])
4628 AC_SUBST([MPI_F77_CXX_BOOL])
4629 AC_SUBST([MPI_F77_CXX_FLOAT_COMPLEX])
4630 AC_SUBST([MPI_F77_CXX_DOUBLE_COMPLEX])
4631 AC_SUBST([MPI_F77_CXX_LONG_DOUBLE_COMPLEX])
4632
4633 # ------------------------------------------------------------------------
4634 # Test if  type_tag_for_datatype is agnostic to modifiers such as const, volatile, and restrict
4635 # if not, the type tags are disabled to avoid compiler warings. A new type_tag for const etc. does
4636 # does not help, since only the latest type_tag definition is used. Type tags are defined in mpi.h,
4637 # therefore, they must be also be activated/deavtivated there
4638 PAC_PUSH_FLAG([CFLAGS])
4639 PAC_APPEND_FLAG([-Werror],[CFLAGS])
4640 AC_TRY_COMPILE([
4641 typedef int TEST_Datatype;
4642 #define TEST_INT ((TEST_Datatype)0x44)
4643 static const TEST_Datatype test_int  __attribute__((type_tag_for_datatype(TEST,int)))  = TEST_INT;
4644 void test(const void* buffer, TEST_Datatype datatype)__attribute__((pointer_with_type_tag(TEST,1,2)));],[
4645 const int buf[10];
4646 test(buf, TEST_INT);],ac_attr_support=yes, ac_attr_support=no)
4647 if test "$ac_attr_support" = yes
4648 then
4649     DISABLE_TAG_SUPPORT="#undef NO_TAGS_WITH_MODIFIERS"
4650 else
4651     DISABLE_TAG_SUPPORT="#define NO_TAGS_WITH_MODIFIERS 1"
4652 fi
4653 PAC_POP_FLAG([CFLAGS])
4654 AC_SUBST(DISABLE_TAG_SUPPORT)
4655
4656 # ----------------------------------------------------------------------------
4657 # Check for the alignment rules moves with types int64_t etc.  These
4658 # are used in the datatype code to perform pack and unpack operations.  
4659 # These only determine if different alignments *work*, not whether they
4660 # work efficiently.  The datatype pack code (should) allow the developer
4661 # to include stricter alignment rules than are needed for correctness to
4662 # get better performance.
4663 if test "$ac_cv_c_int64_t" != "no" -o -n "$INT64_T" ; then
4664     default_int64_t_alignment=${CROSS_INT64_T_ALIGNMENT:-"unknown"}
4665     if test -z "$INT64_T" ; then
4666          if test "$ac_cv_c_int64_t" = yes ; then
4667              INT64_T="int64_t"
4668          else
4669              INT64_T="$ac_cv_int64_t"
4670          fi
4671     fi
4672     # We use the type that we're going use for int64.
4673     AC_CACHE_CHECK([for alignment restrictions on $INT64_T],pac_cv_int64_t_alignment,[
4674     AC_TRY_RUN([
4675 #include <sys/types.h>
4676 #include <stdlib.h>
4677 int main(int argc, char **argv )
4678 {
4679     $INT64_T *p1, v;
4680     char    *buf_p = (char *)malloc( 64 ), *bp;
4681     bp = buf_p;
4682     /* Make bp aligned on 4, not 8 bytes */
4683     if (!( (long)bp & 0x7 ) ) bp += 4;
4684     p1 = ($INT64_T *)bp;
4685     v = -1;
4686     *p1 = v;
4687     if (!( (long)bp & 0x3 ) ) bp += 2;
4688     p1 = ($INT64_T *)bp;
4689     *p1 = 1;
4690     if (!( (long)bp & 0x1 ) ) bp += 1;
4691     p1 = ($INT64_T *)bp;
4692     *p1 = 1;
4693     return 0;
4694 }
4695 ],pac_cv_int64_t_alignment=no,pac_cv_int64_t_alignment=yes,pac_cv_int64_t_alignment=$default_int64_t_alignment)
4696 ])
4697     if test "$pac_cv_int64_t_alignment" = "no" ; then
4698          AC_DEFINE(HAVE_ANY_INT64_T_ALIGNMENT,1,[Define if int64_t works with any alignment])
4699     fi
4700 fi
4701
4702 if test "$ac_cv_int32_t" != "no" ; then
4703     default_int32_t_alignment=${CROSS_INT32_T_ALIGNMENT:-"unknown"}
4704     if test -z "$INT32_T" ; then
4705          if test "$ac_cv_c_int32_t" = yes ; then
4706              INT32_T="int32_t"
4707          else
4708              INT32_T="$ac_cv_int32_t"
4709          fi
4710     fi
4711     
4712     AC_CACHE_CHECK([for alignment restrictions on int32_t],pac_cv_int32_t_alignment,[
4713     AC_TRY_RUN([
4714 #include <sys/types.h>
4715 #include <stdlib.h>
4716 int main(int argc, char **argv )
4717 {
4718     $INT32_T *p1, v;
4719     char    *buf_p = (char *)malloc( 64 ), *bp;
4720     bp = buf_p;
4721     /* Make bp aligned on 4, not 8 bytes */
4722     if (!( (long)bp & 0x7 ) ) bp += 4;
4723     p1 = ($INT32_T *)bp;
4724     v = -1;
4725     *p1 = v;
4726     if (!( (long)bp & 0x3 ) ) bp += 2;
4727     p1 = ($INT32_T *)bp;
4728     *p1 = 1;
4729     if (!( (long)bp & 0x1 ) ) bp += 1;
4730     p1 = ($INT32_T *)bp;
4731     *p1 = 1;
4732     return 0;
4733 }
4734 ],pac_cv_int32_t_alignment=no,pac_cv_int32_t_alignment=yes,pac_cv_int32_t_alignment=$default_int32_t_alignment)
4735 ])
4736     if test "$pac_cv_int32_t_alignment" = "no" ; then
4737          AC_DEFINE(HAVE_ANY_INT32_T_ALIGNMENT,1,[Define if int32_t works with any alignment])
4738     fi
4739 fi
4740
4741 # -----------------------------------------------------------------------------
4742 # Check for support of enable-coverage.  Put this near the end of the tests
4743 # because the coverage options may affect the other tests.
4744 PAC_ENABLE_COVERAGE
4745
4746 # -----------------------------------------------------------------------------
4747 # Look for Standard headers
4748 AC_HEADER_STDC
4749 # Check for a specific header
4750 # Grrr.  OS/X fails the test for sys/uio.h because uio *requires* sys/types.h
4751 # to compile.  Thus, we'll make that a separate test
4752 # stddef.h is sometimes needed for types like wchar_t
4753 AC_CHECK_HEADERS(stdlib.h stdarg.h sys/types.h string.h inttypes.h limits.h stddef.h errno.h sys/socket.h sys/time.h unistd.h endian.h assert.h sys/param.h)
4754 AC_CACHE_CHECK([for sys/uio.h],ac_cv_header_sys_uio_h,[
4755 AC_TRY_COMPILE([
4756 #include <sys/types.h>
4757 #include <sys/uio.h>
4758 ],[int a;],ac_cv_header_sys_uio_h=yes,ac_cv_header_sys_uio_h=no)])
4759 if test "$ac_cv_header_sys_uio_h" = yes ; then
4760     AC_DEFINE(HAVE_SYS_UIO_H,1,[Define if you have the <sys/uio.h> header file.])
4761 fi
4762
4763 # Check for special types
4764 AC_TYPE_SIZE_T
4765
4766 # These are used to support timeouts
4767 AC_CHECK_FUNCS(setitimer alarm)
4768 # These are used for error reporting
4769 AC_CHECK_FUNCS(vsnprintf vsprintf)
4770 if test "$ac_cv_func_vsnprintf" = "yes" ; then
4771     # vsnprintf may be declared in stdio.h and may need stdarg.h 
4772     PAC_FUNC_NEEDS_DECL([#include <stdio.h>
4773 #include <stdarg.h>],vsnprintf)
4774 fi
4775 # We would like to use strerror in the file namepublisher; it is also used
4776 # in MPIR_Strerror (whose implementation is broken if strerror is not found)
4777 AC_CHECK_FUNCS(strerror strncasecmp)
4778 AC_FUNC_STRERROR_R
4779 if test "$ac_cv_func_strerror_r" = "yes" ; then
4780     PAC_FUNC_NEEDS_DECL([#include <string.h>],strerror_r)
4781 fi
4782
4783 # Use snprintf if possible when creating messages
4784 AC_CHECK_FUNCS(snprintf)
4785 if test "$ac_cv_func_snprintf" = "yes" ; then
4786     PAC_FUNC_NEEDS_DECL([#include <stdio.h>],snprintf)
4787 fi
4788
4789 # qsort will be used in MPI_Comm_split, if available
4790 AC_CHECK_FUNCS([qsort])
4791
4792 # if we are using stdarg, we may need va_copy .  Test to see if we have it
4793 # Since it may be a built-in instead of a function, we must try to 
4794 # compile and link a program that uses it.
4795 # va_copy is currently used only in src/util/dbg_printf.c, in an obsolete
4796 # debugging routine.  We may want to withdraw this (saving the
4797 # test in confdb/aclocal_cc.m4).
4798 AC_CACHE_CHECK([for va_copy],pac_cv_func_va_copy,[
4799 AC_TRY_LINK([
4800 #include <stdarg.h>
4801 void foo1( char *fmt, ... ) {
4802     va_list ap, list;
4803     va_start(ap,fmt);
4804     va_copy(list,ap);
4805     va_end(list);
4806     va_end(ap);
4807 }
4808 ],[foo1("a test %d", 3);],pac_cv_func_va_copy=yes,pac_cv_func_va_copy=no)])
4809
4810 if test "$pac_cv_func_va_copy" = "yes" ; then
4811     AC_DEFINE(HAVE_VA_COPY,1,[Define if we have va_copy])
4812 else
4813     AC_CACHE_CHECK([for __va_copy],pac_cv_func___va_copy,[
4814     AC_TRY_LINK([
4815 #include <stdarg.h>
4816 void foo1( char *fmt, ... ) {
4817     va_list ap, list;
4818     va_start(ap,fmt);
4819     __va_copy(list,ap);
4820     va_end(list);
4821     va_end(ap);
4822 }
4823 ],[foo1("a test %d", 3);],pac_cv_func___va_copy=yes,pac_cv_func___va_copy=no)])
4824     if test "$pac_cv_func___va_copy" = "yes" ; then
4825         AC_DEFINE(HAVE___VA_COPY,1,[Define if we have __va_copy])
4826     fi
4827 fi
4828
4829 PAC_C_MACRO_VA_ARGS
4830
4831 # Check for alloca function.  May set HAVE_ALLOCA_H and HAVE_ALLOCA
4832 AC_FUNC_ALLOCA
4833 # We don't use alloca unless USE_ALLOCA is also set.
4834 AC_ARG_ENABLE(alloca,
4835         AC_HELP_STRING([--enable-alloca],
4836                 [Use alloca to allocate temporary memory if available]),,enable_alloca=no)
4837 if test "$enable_alloca" = yes ; then
4838     AC_DEFINE(USE_ALLOCA,1,[Define if alloca should be used if available])
4839 fi
4840
4841 if test "$enable_g_mem" != "yes" ; then
4842     # Strdup is needed only if memory tracing is not enabled.
4843     AC_CHECK_FUNCS(strdup)
4844     if test "$ac_cv_func_strdup" = "yes" ; then
4845         # Do we need to declare strdup?
4846         PAC_FUNC_NEEDS_DECL([#include <string.h>],strdup)
4847     fi
4848 fi
4849
4850 # ----------------------------------------------------------------------------
4851 # Look for some non-posix, but commonly provided functions
4852 # ----------------------------------------------------------------------------
4853 # mkstemp() is a better replacement for mktemp()
4854 AC_HAVE_FUNCS(mkstemp)
4855 if test "$ac_cv_func_mkstemp" = "yes" ; then
4856     PAC_FUNC_NEEDS_DECL([#include <stdlib.h>],mkstemp)
4857 fi
4858 # putenv() sets environment variable
4859 AC_HAVE_FUNCS(putenv)
4860 if test "$ac_cv_func_putenv" = "yes" ; then
4861     PAC_FUNC_NEEDS_DECL([#include <stdlib.h>],putenv)
4862 fi
4863
4864
4865 # ----------------------------------------------------------------------------
4866 # Setup other replaceable values
4867 AC_SUBST(MPILIBNAME)
4868 AC_SUBST(PMPILIBNAME)
4869
4870 if test "$NEEDSPLIB" = "yes" ; then
4871    LPMPILIBNAME="-l${PMPILIBNAME}"
4872 fi
4873 AC_SUBST(LPMPILIBNAME)
4874
4875 # Note that aint_size must be used instead of void_p where the desired check
4876 # is on the size of MPI_Aint
4877 aint_size=$ac_cv_sizeof_void_p
4878 if test "$with_aint_size" -gt 0 ; then
4879    aint_size=$with_aint_size
4880    if test "$aint_size" != "$ac_cv_sizeof_void_p" ; then
4881         AC_MSG_RESULT([Overriding MPI_Aint to be $aint_size bytes])
4882    fi
4883 fi
4884 MPI_AINT=int
4885 for type in int long long_long short ; do
4886     eval len=\$ac_cv_sizeof_$type
4887     if test "$len" = "$aint_size" ; then
4888         MPI_AINT=`echo $type | sed -e 's/_/ /'`
4889         # Make the sizeof AINT available to other configures
4890         MPI_SIZEOF_AINT=$len
4891         export MPI_SIZEOF_AINT
4892         case $type in
4893             int)
4894                 MPI_AINT_FMT_DEC_SPEC="%d"
4895                 MPI_AINT_FMT_HEX_SPEC="%x"
4896                 MPIR_AINT_MAX="INT_MAX"
4897                 ;;
4898             long)
4899                 MPI_AINT_FMT_DEC_SPEC="%ld"
4900                 MPI_AINT_FMT_HEX_SPEC="%lx"
4901                 MPIR_AINT_MAX="LONG_MAX"
4902                 ;;
4903             long_long)
4904                 MPI_AINT_FMT_DEC_SPEC="%lld"
4905                 MPI_AINT_FMT_HEX_SPEC="%llx"
4906                 # tt#1776: if LLONG_MAX is missing, we fix it up in C, b/c it's
4907                 # easier there.  See mpiiimpl.h.
4908                 MPIR_AINT_MAX="LLONG_MAX"
4909                 ;;
4910             short