SCM Repository
Annotation of /trunk/configure.ac
Parent Directory
|
Revision Log
Revision 3349 - (view) (download)
1 : | jhr | 3 | dnl Process this file with autoconf to produce a configure script. |
2 : | dnl | ||
3 : | jhr | 3349 | dnl This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu) |
4 : | dnl | ||
5 : | dnl COPYRIGHT (c) 2015 The University of Chicago | ||
6 : | jhr | 3 | dnl All rights reserved. |
7 : | dnl | ||
8 : | |||
9 : | AC_INIT(diderot,0.1,) | ||
10 : | |||
11 : | AC_PREREQ(2.60) | ||
12 : | jhr | 3349 | AC_COPYRIGHT([[COPYRIGHT (c) 2015 The University of Chicago]]) |
13 : | jhr | 2470 | AC_CONFIG_SRCDIR(src/compiler/driver/main.sml) |
14 : | jhr | 3 | AC_CONFIG_AUX_DIR(config) |
15 : | AC_CONFIG_MACRO_DIR(config) | ||
16 : | jhr | 123 | |
17 : | jhr | 3 | dnl |
18 : | dnl include additional macros | ||
19 : | dnl | ||
20 : | sinclude(config/acx_pthread.m4) | ||
21 : | jhr | 123 | sinclude(config/check_smlnj.m4) |
22 : | sinclude(config/check_smlnj_heap_suffix.m4) | ||
23 : | jhr | 1232 | sinclude(config/ax_check_framework.m4) |
24 : | jhr | 3 | |
25 : | dnl | ||
26 : | jhr | 123 | dnl get host information |
27 : | jhr | 3 | dnl |
28 : | AC_CANONICAL_HOST | ||
29 : | |||
30 : | dnl check for standard programs | ||
31 : | dnl | ||
32 : | jhr | 1232 | AC_PROG_CC([clang gcc cc]) |
33 : | jhr | 3 | AC_PROG_CPP |
34 : | AC_PROG_INSTALL | ||
35 : | AC_PROG_MAKE_SET | ||
36 : | |||
37 : | jhr | 1842 | dnl FIXME: this works for now, but we should probably switch to libtool |
38 : | dnl | ||
39 : | AC_PATH_PROG(LD, [ld], [none]) | ||
40 : | if test x$LD = xnone ; then | ||
41 : | AC_MSG_ERROR([cannot find ld command]) | ||
42 : | fi | ||
43 : | AC_SUBST(LD) | ||
44 : | |||
45 : | jhr | 1116 | dnl check for c99 support |
46 : | jhr | 123 | dnl |
47 : | jhr | 1116 | AC_PROG_CC_C99 |
48 : | if test x"$ac_cv_prog_cc_c99" = xno ; then | ||
49 : | AC_MSG_ERROR([Diderot requires c99 support]) | ||
50 : | fi | ||
51 : | |||
52 : | jhr | 1990 | AC_ARG_ENABLE([32-bit], |
53 : | AC_HELP_STRING([--enable-32-bit], [configure Diderot to produce 32-bit executables]), | ||
54 : | [CFLAG_MXX="-m32"], | ||
55 : | [CFLAG_MXX="-m64"]) | ||
56 : | |||
57 : | jhr | 1116 | dnl extra C compiler options |
58 : | jhr | 123 | dnl |
59 : | jhr | 1367 | CFLAGS="" |
60 : | jhr | 1232 | CFLAGS_BASE="-Wformat -Wreturn-type -Wuninitialized" |
61 : | jhr | 1990 | AC_SUBST(CFLAG_MXX) |
62 : | jhr | 1232 | AC_SUBST(CFLAGS_BASE) |
63 : | jhr | 1116 | |
64 : | dnl | ||
65 : | jhr | 2356 | dnl standard headers |
66 : | dnl | ||
67 : | AC_HEADER_STDBOOL | ||
68 : | |||
69 : | dnl | ||
70 : | jhr | 1232 | dnl check for pthreads support |
71 : | dnl | ||
72 : | jhr | 2356 | ACX_PTHREAD |
73 : | jhr | 1232 | |
74 : | dnl | ||
75 : | jhr | 1116 | dnl Look for NVIDIA's nvcc compiler |
76 : | dnl | ||
77 : | jhr | 1232 | AC_MSG_NOTICE([checking for CUDA and nvcc]) |
78 : | AC_PATH_PROG(NVCC, nvcc, no, $PATH) | ||
79 : | if test x"$NVCC" = xno ; then | ||
80 : | jhr | 1116 | AC_MSG_WARN([nvcc not found]) |
81 : | jhr | 1232 | CUDA_ENABLED=false |
82 : | NVCC=":" | ||
83 : | jhr | 1116 | else |
84 : | AC_MSG_RESULT([$NVCC]) | ||
85 : | jhr | 1232 | CUDA_ENABLED=true |
86 : | jhr | 1116 | fi |
87 : | AC_SUBST(NVCC) | ||
88 : | jhr | 1232 | AC_SUBST(CUDA_ENABLED) |
89 : | jhr | 1116 | |
90 : | dnl | ||
91 : | jhr | 1232 | dnl check for OpenCL support |
92 : | jhr | 1116 | dnl |
93 : | jhr | 2487 | CL_LIBS="none" |
94 : | jhr | 1232 | case "$host_os" in |
95 : | darwin*) # On Mac OS X we check for installed frameworks | ||
96 : | jhr | 2487 | AX_CHECK_FRAMEWORK([OpenCL], [CL_LIBS="-framework OpenCL"], []) |
97 : | jhr | 1232 | ;; |
98 : | *) | ||
99 : | jhr | 2487 | AC_CHECK_LIB([OpenCL],[clGetPlatformIDs],[CL_LIBS="-lOpenCL"]) |
100 : | jhr | 1232 | ;; |
101 : | esac | ||
102 : | jhr | 2487 | if test x"$CL_LIBS" = xnone ; then |
103 : | jhr | 1232 | AC_MSG_WARN([no OpenCL library found]) |
104 : | CL_ENABLED=false | ||
105 : | CL_VERSION=0 | ||
106 : | else | ||
107 : | CL_ENABLED=true | ||
108 : | jhr | 1838 | CPPFLAGS_CL="" |
109 : | jhr | 2356 | CL_HEADER="" |
110 : | AC_CHECK_HEADERS([CL/cl.h OpenCL/cl.h], [HAVE_CL_H="yes"; CL_HEADER="$ac_header"; break], [HAVE_CL_H="no"]) | ||
111 : | jhr | 1838 | if test x"$HAVE_CL_H" = xno ; then |
112 : | # check for AMD's SDK | ||
113 : | jhr | 2356 | AC_MSG_CHECKING([for cl.h in AMD's SDK]) |
114 : | jhr | 1838 | if test -d /opt/AMDAPP/include/CL ; then |
115 : | HAVE_CL_H="yes" | ||
116 : | jhr | 2356 | CL_HEADER="/opt/AMDAPP/include/CL/cl.h" |
117 : | jhr | 1838 | AC_DEFINE([HAVE_CL_CL_H]) |
118 : | CPPFLAGS_CL="-I/opt/AMDAPP/include" | ||
119 : | fi | ||
120 : | jhr | 1839 | AC_MSG_RESULT([$HAVE_CL_H]) |
121 : | jhr | 1838 | fi |
122 : | if test x"$HAVE_CL_H" = xno ; then | ||
123 : | jhr | 1987 | # check for NVIDIA's SDK |
124 : | AC_MSG_CHECKING([for NVIDIA's SDK cl.h]) | ||
125 : | if test -d /usr/local/cuda/include/CL ; then | ||
126 : | HAVE_CL_H="yes" | ||
127 : | jhr | 2768 | CL_HEADER="/usr/local/cuda/include/CL/cl.h" |
128 : | jhr | 1987 | AC_DEFINE([HAVE_CL_CL_H]) |
129 : | CPPFLAGS_CL="-I/usr/local/cuda/include" | ||
130 : | fi | ||
131 : | AC_MSG_RESULT([$HAVE_CL_H]) | ||
132 : | fi | ||
133 : | if test x"$HAVE_CL_H" = xno ; then | ||
134 : | jhr | 1838 | AC_MSG_WARN([no cl.h found]) |
135 : | CL_ENABLED=false | ||
136 : | CL_VERSION=0 | ||
137 : | jhr | 2356 | SIZEOF_CL_INT=0 |
138 : | SIZEOF_CL_LONG=0 | ||
139 : | SIZEOF_CL_FLOAT=0 | ||
140 : | SIZEOF_CL_DOUBLE=0 | ||
141 : | jhr | 1838 | else |
142 : | # check the cl.h header for which version of OpenCL is supported | ||
143 : | AC_LANG([C]) | ||
144 : | save_CPPFLAGS=$CPPFLAGS | ||
145 : | CPPFLAGS="$CPPFLAGS_CL $CPPFLAGS" | ||
146 : | AC_LINK_IFELSE([AC_LANG_PROGRAM([[ | ||
147 : | jhr | 1232 | #include <stdio.h> |
148 : | # ifdef HAVE_CL_CL_H | ||
149 : | # include <CL/cl.h> | ||
150 : | # elif defined(HAVE_OPENCL_CL_H) | ||
151 : | # include <OpenCL/cl.h> | ||
152 : | # else | ||
153 : | # error no cl.h | ||
154 : | # endif]], | ||
155 : | [[#if defined(CL_VERSION_1_1) | ||
156 : | printf("11000\n"); | ||
157 : | #elif defined(CL_VERSION_1_0) | ||
158 : | printf("10000\n"); | ||
159 : | #else | ||
160 : | printf("0\n"); | ||
161 : | #endif | ||
162 : | jhr | 1838 | ]])], |
163 : | [CL_VERSION=`./conftest$EXEEXT`], [CL_VERSION=0]) | ||
164 : | jhr | 1640 | dnl |
165 : | dnl check to see how we access the host-side vector types. For OpenCL 1.1, | ||
166 : | dnl the specification specifies the behavior, but it was unspecified in 1.0. | ||
167 : | dnl | ||
168 : | jhr | 1838 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ |
169 : | jhr | 2356 | #include "$CL_HEADER" |
170 : | ]], | ||
171 : | jhr | 1838 | [[cl_float4 x; x[0] = 0.0;]])], |
172 : | [AC_DEFINE([CL_HOST_VECTORS_ARE_ARRAYS],[1],[host vector types are arrays])], | ||
173 : | jhr | 1640 | dnl |
174 : | dnl not arrays, so try the OpenCL 1.1 structure representation | ||
175 : | dnl | ||
176 : | jhr | 1838 | [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ |
177 : | jhr | 2356 | #include "$CL_HEADER" |
178 : | ]], | ||
179 : | jhr | 1838 | [[cl_float4 x; x.s[0] = 0.0;]])], |
180 : | [AC_DEFINE([CL_HOST_VECTORS_ARE_STRUCTS],[1],[host vector types are structs])], | ||
181 : | [AC_MSG_ERROR([unable to figure out host types for OpenCL vectors])])]) | ||
182 : | # restore saved CPPFLAGS | ||
183 : | CPPFLAGS=$save_CPPFLAGS | ||
184 : | jhr | 1232 | # substitutions |
185 : | jhr | 2487 | AC_SUBST(CL_LIBS) |
186 : | jhr | 1838 | AC_SUBST(CPPFLAGS_CL) |
187 : | jhr | 2356 | # |
188 : | # determine the sizes of the host-side OpenCL types | ||
189 : | AC_CHECK_SIZEOF([cl_int], [], [#include "$CL_HEADER"]) | ||
190 : | SIZEOF_CL_INT=$ac_cv_sizeof_cl_int | ||
191 : | AC_CHECK_SIZEOF([cl_long], [], [#include "$CL_HEADER"]) | ||
192 : | SIZEOF_CL_LONG=$ac_cv_sizeof_cl_long | ||
193 : | AC_CHECK_SIZEOF([cl_float], [], [#include "$CL_HEADER"]) | ||
194 : | SIZEOF_CL_FLOAT=$ac_cv_sizeof_cl_float | ||
195 : | AC_CHECK_SIZEOF([cl_double], [], [#include "$CL_HEADER"]) | ||
196 : | SIZEOF_CL_DOUBLE=$ac_cv_sizeof_cl_double | ||
197 : | jhr | 1838 | fi |
198 : | jhr | 1232 | fi |
199 : | AC_SUBST(CL_ENABLED) | ||
200 : | AC_SUBST(CL_VERSION) | ||
201 : | jhr | 1116 | |
202 : | jhr | 2356 | AC_SUBST(SIZEOF_CL_INT) |
203 : | AC_SUBST(SIZEOF_CL_LONG) | ||
204 : | AC_SUBST(SIZEOF_CL_FLOAT) | ||
205 : | AC_SUBST(SIZEOF_CL_DOUBLE) | ||
206 : | |||
207 : | jhr | 1116 | dnl |
208 : | jhr | 1232 | dnl check for various library routines etc. |
209 : | dnl | ||
210 : | AC_CHECK_FUNCS(posix_memalign) | ||
211 : | if test x"$ac_cv_func_posix_memalign" != xyes ; then | ||
212 : | AC_CHECK_FUNCS(memalign) | ||
213 : | if test x"$ac_cv_func_posix_memalign" != xyes ; then | ||
214 : | AC_CHECK_FUNCS(valloc) | ||
215 : | fi | ||
216 : | fi | ||
217 : | |||
218 : | AC_CHECK_FUNCS(mach_absolute_time) | ||
219 : | AC_CHECK_TYPES([struct timespec]) | ||
220 : | jhr | 1301 | AC_CHECK_FUNCS(pthread_barrier_init) |
221 : | jhr | 1232 | |
222 : | dnl | ||
223 : | dnl check for clock_gettime. On Linux, this requires librt. | ||
224 : | dnl | ||
225 : | save_LIBS=$LIBS | ||
226 : | LIBS="-lrt $LIBS" | ||
227 : | AC_MSG_CHECKING([for clock_gettime]) | ||
228 : | AC_LINK_IFELSE( | ||
229 : | [AC_LANG_PROGRAM( | ||
230 : | [[#include <time.h>]], | ||
231 : | [[struct timespec t; clock_gettime(CLOCK_REALTIME, &t); ]])], | ||
232 : | [ ac_cv_func_clock_gettime=yes; | ||
233 : | AC_DEFINE(HAVE_CLOCK_GETTIME, [1], [is clock_gettime available?])], | ||
234 : | [ac_cv_func_clock_gettime=no]) | ||
235 : | AC_MSG_RESULT($ac_cv_func_clock_gettime) | ||
236 : | if test "$ac_cv_func_clock_gettime" = "no" ; then | ||
237 : | LIBS=$save_LIBS | ||
238 : | fi | ||
239 : | |||
240 : | AC_CHECK_FUNCS(pthread_getcpuclockid) | ||
241 : | AC_CHECK_FUNCS(sigtimedwait nanosleep) | ||
242 : | |||
243 : | dnl | ||
244 : | dnl check for sched_setaffinity | ||
245 : | dnl | ||
246 : | AC_CHECK_FUNCS(sched_setaffinity) | ||
247 : | |||
248 : | dnl | ||
249 : | dnl check for pthread_setaffinity_np | ||
250 : | dnl | ||
251 : | save_LIBS=$LIBS | ||
252 : | save_CFLAGS=$CFLAGS | ||
253 : | LIBS="$PTHREAD_LIBS $LIBS" | ||
254 : | CFLAGS="$PTHREAD_CFLAGS $CFLAGS" | ||
255 : | AC_MSG_CHECKING([for pthread_setaffinity_np]) | ||
256 : | AC_LINK_IFELSE( | ||
257 : | [AC_LANG_PROGRAM( | ||
258 : | [[#include <pthread.h>]], | ||
259 : | [[cpu_set_t s; pthread_setaffinity_np(pthread_self(), sizeof(s), &s); ]])], | ||
260 : | [ ac_cv_func_pthread_setaffinity_np=yes; | ||
261 : | AC_DEFINE(HAVE_PTHREAD_SETAFFINITY_NP, [1], [is pthread_setaffinity_np available?])], | ||
262 : | [ac_cv_func_pthread_setaffinity_np=no]) | ||
263 : | AC_MSG_RESULT($ac_cv_func_pthread_setaffinity_np) | ||
264 : | LIBS=$save_LIBS | ||
265 : | CFLAGS=$save_CFLAGS | ||
266 : | |||
267 : | dnl | ||
268 : | dnl check for Linux NUMA support (libnuma) | ||
269 : | dnl | ||
270 : | AC_CHECK_LIB(numa,numa_available) | ||
271 : | if test "$ac_cv_lib_numa_numa_available" = "yes" ; then | ||
272 : | PTHREAD_LIBS="$PTHREAD_LIBS -lnuma" | ||
273 : | fi | ||
274 : | |||
275 : | dnl check for /proc/cpuinfo | ||
276 : | dnl | ||
277 : | AC_CHECK_FILES(/proc/cpuinfo) | ||
278 : | |||
279 : | dnl | ||
280 : | jhr | 1116 | dnl OS-specific linking issues |
281 : | dnl | ||
282 : | LD_NEEDS_RPATH=false; | ||
283 : | LIBM="" | ||
284 : | jhr | 123 | case "$host_os" in |
285 : | jhr | 1116 | darwin*) # On Mac OS X we check for the presence of macports and/or fink |
286 : | jhr | 123 | if test -x /opt/local/bin/port ; then |
287 : | HAS_MACPORTS=yes | ||
288 : | else | ||
289 : | HAS_MACPORTS=no | ||
290 : | fi | ||
291 : | if test -x /sw/bin/fink ; then | ||
292 : | HAS_FINK=yes | ||
293 : | else | ||
294 : | HAS_FINK=no | ||
295 : | fi | ||
296 : | ;; | ||
297 : | jhr | 1116 | linux*) # On Linux we include the -rpath option to pick up dynamically-loaded libraries |
298 : | LD_NEEDS_RPATH=true | ||
299 : | LIBM="-lm" | ||
300 : | ;; | ||
301 : | jhr | 123 | esac |
302 : | jhr | 3 | |
303 : | jhr | 123 | if test x"$HAS_MACPORTS" = xyes ; then |
304 : | LDPATHS="-L/opt/local/lib" | ||
305 : | elif test x"$HAS_FINK" = xyes ; then | ||
306 : | LDPATHS="-L/sw/lib" | ||
307 : | else | ||
308 : | LDPATHS="" | ||
309 : | fi | ||
310 : | AC_SUBST(LDPATHS) | ||
311 : | jhr | 1116 | AC_SUBST(LD_NEEDS_RPATH) |
312 : | AC_SUBST(LIBM) | ||
313 : | jhr | 123 | |
314 : | dnl | ||
315 : | jhr | 2470 | dnl get the path to the TEEM installation. We need this to build the Diderot |
316 : | dnl runtime code and we use the path when searching for teem in the Diderot | ||
317 : | dnl compiler. | ||
318 : | jhr | 123 | dnl |
319 : | AC_ARG_WITH(teem, | ||
320 : | AC_HELP_STRING([--with-teem=<path>], [specify path to teem installation]), | ||
321 : | [ac_cv_use_teem=$withval], [ac_cv_use_teem=no]) | ||
322 : | if test x"$ac_cv_use_teem" = xno ; then | ||
323 : | TEEM_DIR=none | ||
324 : | else | ||
325 : | AC_MSG_CHECKING([path to teem ($ac_cv_use_teem)]) | ||
326 : | case $ac_cv_use_teem in | ||
327 : | /*) ;; | ||
328 : | *) AC_MSG_ERROR([path to teem must be absolute]) ;; | ||
329 : | esac | ||
330 : | if test -x $ac_cv_use_teem ; then | ||
331 : | TEEM_DIR=$ac_cv_use_teem | ||
332 : | jhr | 1367 | # check that TEEM_DIR actually points to something that looks like teem |
333 : | if test -f $TEEM_DIR/include/teem/nrrd.h ; then | ||
334 : | jhr | 2660 | AC_MSG_RESULT([yes]) |
335 : | jhr | 1367 | else |
336 : | TEEM_DIR=none | ||
337 : | jhr | 2660 | AC_MSG_RESULT([no]) |
338 : | jhr | 1367 | fi |
339 : | jhr | 123 | else |
340 : | TEEM_DIR=none | ||
341 : | jhr | 2660 | AC_MSG_RESULT([no]) |
342 : | jhr | 123 | fi |
343 : | fi | ||
344 : | if test x"$TEEM_DIR" = xnone ; then | ||
345 : | jhr | 2356 | AC_MSG_ERROR([unable to find teem; use --with-teem option to specify location]) |
346 : | jhr | 123 | fi |
347 : | jhr | 2660 | dnl |
348 : | dnl check that unu supports the dnorm command | ||
349 : | dnl | ||
350 : | if test x"$TEEM_DIR" != xnone ; then | ||
351 : | AC_MSG_CHECKING([that \"unu dnorm\" works]) | ||
352 : | if test -x $TEEM_DIR/bin/unu ; then | ||
353 : | $TEEM_DIR/bin/unu dnorm > /dev/null 2> /dev/null | ||
354 : | if test $? -eq 0 ; then | ||
355 : | AC_MSG_RESULT([yes]) | ||
356 : | else | ||
357 : | AC_MSG_ERROR([\"unu dnorm\" is not supported; please update your teem installation]) | ||
358 : | fi | ||
359 : | else | ||
360 : | AC_MSG_ERROR([unable to find unu executable in $TEEM_DIR/bin"]) | ||
361 : | fi | ||
362 : | fi | ||
363 : | jhr | 123 | AC_SUBST(TEEM_DIR) |
364 : | |||
365 : | dnl ******************** SML/NJ configuration ******************** | ||
366 : | dnl | ||
367 : | |||
368 : | dnl check that we have a compatible version of SML/NJ | ||
369 : | dnl | ||
370 : | CHECK_SMLNJ([AC_MSG_ERROR([unable to find SML/NJ installation; check your PATH or set SMLNJ_CMD])]) | ||
371 : | if test $SMLNJ_MAJOR_VERSION -lt 110 \ | ||
372 : | jhr | 2660 | -o $SMLNJ_MINOR_VERSION -lt 75 |
373 : | jhr | 123 | then |
374 : | jhr | 2660 | AC_MSG_ERROR([installation requires SML/NJ version 110.75+]) |
375 : | jhr | 123 | fi |
376 : | AC_SUBST(SMLNJ_VERSION) | ||
377 : | |||
378 : | dnl determine the heap-image suffix | ||
379 : | dnl | ||
380 : | CHECK_SMLNJ_HEAP_SUFFIX([ | ||
381 : | AC_MSG_ERROR([unsupported configuration ${host_cpu}-${host_os}])]) | ||
382 : | |||
383 : | dnl look for ml-makedepend | ||
384 : | dnl | ||
385 : | AC_MSG_CHECKING([for ml-makedepend]) | ||
386 : | tmpPATH="$SMLNJ_PATH:$PATH" | ||
387 : | AC_PATH_PROG(ML_MAKEDEPEND, ml-makedepend, ":", $tmpPATH) | ||
388 : | if test $ML_MAKEDEPEND = none ; then | ||
389 : | AC_MSG_ERROR([ml-makedepend not found]) | ||
390 : | else | ||
391 : | AC_MSG_RESULT([$ML_MAKEDEPEND]) | ||
392 : | fi | ||
393 : | AC_SUBST(ML_MAKEDEPEND) | ||
394 : | |||
395 : | dnl | ||
396 : | dnl look for ml-build | ||
397 : | dnl | ||
398 : | tmpPATH="$SMLNJ_PATH:$PATH" | ||
399 : | AC_PATH_PROG(ML_BUILD, ml-build, none, $tmpPATH) | ||
400 : | if test $ML_BUILD = none ; then | ||
401 : | AC_MSG_ERROR([ml-build not found]) | ||
402 : | fi | ||
403 : | AC_SUBST(ML_BUILD) | ||
404 : | |||
405 : | jhr | 2470 | dnl ******************** Documentation tools ******************** |
406 : | |||
407 : | dnl check for doxygen | ||
408 : | dnl | ||
409 : | AC_ARG_WITH([doxygen], | ||
410 : | [AS_HELP_STRING([--with-doxygen=PATH], [specify location of doxygen executable])], | ||
411 : | [DOXYGEN=$with_doxygen], | ||
412 : | [DOXYGEN=none]) | ||
413 : | if test x$DOXYGEN = xnone ; then | ||
414 : | # see if we can find doxygen in the user's path | ||
415 : | AC_PATH_PROG(DOXYGEN, [doxygen], [none]) | ||
416 : | fi | ||
417 : | if test x$with_doxygen = xyes -o x$with_doxygen = xno ; then | ||
418 : | AC_MSG_ERROR([--with-doxygen option must specify directory argument]) | ||
419 : | elif test x$DOXYGEN != xnone -a ! -x $DOXYGEN ; then | ||
420 : | AC_MSG_ERROR([doxygen not found at $DOXYGEN]) | ||
421 : | elif test x$DOXYGEN != xnone ; then | ||
422 : | dnl | ||
423 : | dnl verify that $DOXYGEN is an absolute path | ||
424 : | dnl | ||
425 : | case $DOXYGEN in | ||
426 : | /*) ;; | ||
427 : | *) AC_MSG_ERROR([--with-doxygen path must be absolute]) ;; | ||
428 : | esac | ||
429 : | fi | ||
430 : | if test $DOXYGEN = xnone ; then | ||
431 : | DOXYGEN=: | ||
432 : | fi | ||
433 : | AC_SUBST(DOXYGEN) | ||
434 : | |||
435 : | dnl check for asciidoc and related tools | ||
436 : | dnl | ||
437 : | AC_PATH_PROGS([ASCIIDOC], [asciidoc], [none]) | ||
438 : | AC_PATH_PROGS([A2X], [a2x], [none]) | ||
439 : | AC_PATH_PROGS([HIGHLIGHTER], [pygmentize], [none]) | ||
440 : | AC_PATH_PROGS([DBLATEX], [dblatex], [none]) | ||
441 : | |||
442 : | dnl | ||
443 : | dnl get the path to the asciidoc cofiguration files | ||
444 : | dnl | ||
445 : | if test x"$ASCIIDOC" != xnone ; then | ||
446 : | AC_MSG_CHECKING([path to asciidoc configuration files]) | ||
447 : | ASCIIDOC_CONF_DIR=`$ASCIIDOC -v /dev/null 2>&1 | head -n 1 | sed 's|.*reading: \(.*\)/asciidoc.conf|\1|'` | ||
448 : | AC_MSG_RESULT([$ASCIIDOC_CONF_DIR]) | ||
449 : | fi | ||
450 : | AC_SUBST(ASCIIDOC) | ||
451 : | AC_SUBST(A2X) | ||
452 : | AC_SUBST(ASCIIDOC_CONF_DIR) | ||
453 : | AC_SUBST(HIGHLIGHTER) | ||
454 : | AC_SUBST(DBLATEX) | ||
455 : | |||
456 : | |||
457 : | jhr | 123 | dnl ******************** Paths ******************** |
458 : | |||
459 : | DIDEROT_ROOT=`pwd` | ||
460 : | DIDEROT_DOCDIR=$DIDEROT_ROOT/doc | ||
461 : | DIDEROT_SRCDIR=$DIDEROT_ROOT/src | ||
462 : | DIDEROT_LIBDIR=$DIDEROT_ROOT/lib | ||
463 : | DIDEROT_BINDIR=$DIDEROT_ROOT/bin | ||
464 : | DIDEROT_MKDIR=$DIDEROT_ROOT/mk | ||
465 : | |||
466 : | HEAP_IMAGE_DIR=$DIDEROT_BINDIR/.heap | ||
467 : | INSTALL_SMLNJ_WRAPPER=$DIDEROT_BINDIR/install-sml-wrapper.sh | ||
468 : | |||
469 : | AC_SUBST(DIDEROT_ROOT) | ||
470 : | AC_SUBST(DIDEROT_DOCDIR) | ||
471 : | AC_SUBST(DIDEROT_SRCDIR) | ||
472 : | AC_SUBST(DIDEROT_LIBDIR) | ||
473 : | AC_SUBST(DIDEROT_BINDIR) | ||
474 : | AC_SUBST(DIDEROT_MKDIR) | ||
475 : | AC_SUBST(HEAP_IMAGE_DIR) | ||
476 : | AC_SUBST(INSTALL_SMLNJ_WRAPPER) | ||
477 : | |||
478 : | dnl | ||
479 : | jhr | 1232 | dnl ******************** C compiler properties ******************** |
480 : | dnl | ||
481 : | |||
482 : | dnl | ||
483 : | dnl run the compiler tests in 64-bit mode | ||
484 : | dnl | ||
485 : | save_CFLAGS=$CFLAGS | ||
486 : | jhr | 1990 | CFLAGS="$CFLAGS $CFLAG_MXX" |
487 : | jhr | 1232 | |
488 : | dnl | ||
489 : | dnl check for gcc builtin atomic operations | ||
490 : | dnl | ||
491 : | AC_MSG_CHECKING([for builtin atomic operations]) | ||
492 : | AC_LINK_IFELSE( | ||
493 : | [AC_LANG_PROGRAM([], [int foo1; int foo2 = __sync_fetch_and_add(&foo1, 1);])], | ||
494 : | AC_MSG_RESULT(yes) | ||
495 : | AC_DEFINE( | ||
496 : | [HAVE_BUILTIN_ATOMIC_OPS], 1, | ||
497 : | [Define to 1 if gcc compiler provides atomic operations.]), | ||
498 : | AC_MSG_RESULT(no)) | ||
499 : | |||
500 : | AC_C_BIGENDIAN | ||
501 : | |||
502 : | jhr | 2356 | # |
503 : | # determine the sizes of the standard C types | ||
504 : | AC_CHECK_SIZEOF([int]) | ||
505 : | SIZEOF_C_INT=$ac_cv_sizeof_int | ||
506 : | AC_CHECK_SIZEOF([long]) | ||
507 : | SIZEOF_C_LONG=$ac_cv_sizeof_long | ||
508 : | AC_CHECK_SIZEOF([float]) | ||
509 : | SIZEOF_C_FLOAT=$ac_cv_sizeof_float | ||
510 : | AC_CHECK_SIZEOF([double]) | ||
511 : | SIZEOF_C_DOUBLE=$ac_cv_sizeof_double | ||
512 : | |||
513 : | AC_SUBST(SIZEOF_C_INT) | ||
514 : | AC_SUBST(SIZEOF_C_LONG) | ||
515 : | AC_SUBST(SIZEOF_C_FLOAT) | ||
516 : | AC_SUBST(SIZEOF_C_DOUBLE) | ||
517 : | |||
518 : | jhr | 1232 | dnl |
519 : | dnl restore CFLAGS | ||
520 : | dnl | ||
521 : | CFLAGS=$save_CFLAGS | ||
522 : | |||
523 : | dnl | ||
524 : | dnl ******************** config.h stuff ******************** | ||
525 : | dnl | ||
526 : | jhr | 1301 | |
527 : | AC_DEFINE_UNQUOTED(DIDEROT_INCLUDE_PATH,["$DIDEROT_SRCDIR/include"], [path for Diderot header files]) | ||
528 : | |||
529 : | jhr | 1232 | AH_TOP([ |
530 : | /* | ||
531 : | jhr | 3349 | * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu) |
532 : | * | ||
533 : | * COPYRIGHT (c) 2015 The University of Chicago * All rights reserved. | ||
534 : | jhr | 1232 | */ |
535 : | |||
536 : | #ifndef _DIDEROT_CONFIG_H_ | ||
537 : | #define _DIDEROT_CONFIG_H_ | ||
538 : | |||
539 : | ]) | ||
540 : | AH_BOTTOM([ | ||
541 : | |||
542 : | jhr | 2356 | #ifdef NDEBUG |
543 : | #define STATIC_INLINE static inline | ||
544 : | #else | ||
545 : | #define STATIC_INLINE static | ||
546 : | #endif | ||
547 : | |||
548 : | jhr | 1232 | #endif /* !_DIDEROT_CONFIG_H_ */ |
549 : | ]) | ||
550 : | |||
551 : | dnl | ||
552 : | jhr | 123 | dnl ******************** write output ******************** |
553 : | dnl | ||
554 : | |||
555 : | jhr | 127 | AC_CONFIG_FILES( |
556 : | dnl | ||
557 : | jhr | 123 | dnl ***** Makefiles ***** |
558 : | jhr | 321 | Makefile |
559 : | jhr | 1640 | doc/Makefile |
560 : | jhr | 2470 | doc/man/Makefile |
561 : | jhr | 1640 | src/clinfo/Makefile |
562 : | jhr | 123 | src/compiler/Makefile |
563 : | jhr | 1116 | src/lib/build/Makefile |
564 : | src/lib/build/mk/build.gmk:src/lib/build/mk/build_gmk.in | ||
565 : | jhr | 204 | test/MIP/Makefile |
566 : | jhr | 260 | test/probe/Makefile |
567 : | jhr | 127 | dnl |
568 : | dnl ***** SML source files ***** | ||
569 : | jhr | 2474 | src/compiler/nrrd/run-dnorm.sml:src/compiler/nrrd/run-dnorm_sml.in |
570 : | jhr | 1116 | src/compiler/common/paths.sml:src/compiler/common/paths_sml.in |
571 : | jhr | 2356 | src/compiler/common/size-of.sml:src/compiler/common/size-of_sml.in |
572 : | jhr | 123 | ) |
573 : | |||
574 : | jhr | 1232 | AC_CONFIG_HEADERS(src/include/Diderot/config.h:config/config_h.in) |
575 : | |||
576 : | jhr | 123 | dnl |
577 : | dnl shell scripts | ||
578 : | dnl | ||
579 : | AC_CONFIG_FILES([ | ||
580 : | bin/install-sml-wrapper.sh:config/install-sml-wrapper_sh.in | ||
581 : | ], [chmod +x bin/install-sml-wrapper.sh]) | ||
582 : | jhr | 1310 | AC_CONFIG_FILES([ |
583 : | jhr | 1640 | src/compiler/gen/file2str/file2str.sh:src/compiler/gen/file2str/file2str_sh.in |
584 : | ], [chmod +x src/compiler/gen/file2str/file2str.sh]) | ||
585 : | jhr | 1810 | AC_CONFIG_FILES([ |
586 : | rtest/scripts/run.sh:rtest/scripts/run_sh.in | ||
587 : | ], [chmod +x rtest/scripts/run.sh]) | ||
588 : | AC_CONFIG_FILES([ | ||
589 : | rtest/scripts/run-one.sh:rtest/scripts/run-one_sh.in | ||
590 : | ], [chmod +x rtest/scripts/run-one.sh]) | ||
591 : | jhr | 123 | |
592 : | jhr | 1116 | dnl |
593 : | dnl generate makefiles for runtime library builds | ||
594 : | dnl | ||
595 : | dnl usage: MK_BUILD_DIR(<build-dir>, <target-platform>, <options>) | ||
596 : | dnl | ||
597 : | AC_DEFUN([MK_BUILD_DIR], [ | ||
598 : | if test ! -d src/lib/build/$1 ; then | ||
599 : | mkdir src/lib/build/$1 | ||
600 : | fi | ||
601 : | [sed -e 's,@BUILD_TARGET@,$1,g' \ | ||
602 : | -e 's,@TARGET_PLATFORM@,$2,g' \ | ||
603 : | -e 's,@BUILD_OPTIONS@,$3,g' \ | ||
604 : | src/lib/build/mk/Makefile.in \ | ||
605 : | > src/lib/build/$1/Makefile.in] | ||
606 : | AC_CONFIG_FILES(src/lib/build/$1/Makefile) | ||
607 : | ]) | ||
608 : | |||
609 : | jhr | 1301 | MK_BUILD_DIR(rt-c-f, c, [float]) |
610 : | jhr | 1640 | MK_BUILD_DIR(rt-c-d, c, [double]) |
611 : | jhr | 1301 | MK_BUILD_DIR(rt-c-f-debug, c, [float debug]) |
612 : | jhr | 1640 | MK_BUILD_DIR(rt-c-d-debug, c, [double debug]) |
613 : | jhr | 1301 | MK_BUILD_DIR(rt-c-f-par, parallel, [parallel float]) |
614 : | jhr | 1640 | MK_BUILD_DIR(rt-c-d-par, parallel, [parallel double]) |
615 : | jhr | 1301 | MK_BUILD_DIR(rt-c-f-par-debug, parallel, [parallel float debug]) |
616 : | jhr | 1640 | MK_BUILD_DIR(rt-c-d-par-debug, parallel, [parallel double debug]) |
617 : | jhr | 1116 | |
618 : | jhr | 1671 | if test x"$CL_ENABLED" = xtrue ; then |
619 : | MK_BUILD_DIR(rt-cl-f, cl, [float]) | ||
620 : | MK_BUILD_DIR(rt-cl-d, cl, [double]) | ||
621 : | MK_BUILD_DIR(rt-cl-f-debug, cl, [float debug]) | ||
622 : | MK_BUILD_DIR(rt-cl-d-debug, cl, [double debug]) | ||
623 : | fi | ||
624 : | |||
625 : | jhr | 3 | AC_OUTPUT |
root@smlnj-gforge.cs.uchicago.edu | ViewVC Help |
Powered by ViewVC 1.0.0 |