add support for x86_64-solaris2 platform
[ghc.git] / aclocal.m4
1 # Extra autoconf macros for the Glasgow fptools
2 #
3 # To be a good autoconf citizen, names of local macros have prefixed with FP_ to
4 # ensure we don't clash with any pre-supplied autoconf ones.
5
6
7 AC_DEFUN([GHC_SELECT_FILE_EXTENSIONS],
8 [
9     $2=''
10     $3='.so'
11     case $1 in
12     *-unknown-cygwin32)
13         AC_MSG_WARN([GHC does not support the Cygwin target at the moment])
14         AC_MSG_WARN([I'm assuming you wanted to build for i386-unknown-mingw32])
15         exit 1
16         ;;
17     *-unknown-mingw32)
18         windows=YES
19         $2='.exe'
20         $3='.dll'
21         ;;
22     i386-apple-darwin|powerpc-apple-darwin)
23         $3='.dylib'
24         ;;
25     x86_64-apple-darwin)
26         $3='.dylib'
27         ;;
28     arm-apple-darwin10|i386-apple-darwin11)
29         $2='.a'
30         $3='.dylib'
31         ;;
32     esac
33 ])
34
35 # FPTOOLS_SET_PLATFORM_VARS
36 # ----------------------------------
37 # Set the platform variables
38 AC_DEFUN([FPTOOLS_SET_PLATFORM_VARS],
39 [
40     # If no argument was given for a configuration variable, then discard
41     # the guessed canonical system and use the configuration of the
42     # bootstrapping ghc. If an argument was given, map it from gnu format
43     # to ghc format.
44     #
45     # For why we do it this way, see: #3637, #1717, #2951
46     #
47     # In bindists, we haven't called AC_CANONICAL_{BUILD,HOST,TARGET}
48     # so this justs uses $bootstrap_target.
49
50     if test "$build_alias" = ""
51     then
52         if test "$bootstrap_target" != ""
53         then
54             build=$bootstrap_target
55             echo "Build platform inferred as: $build"
56         else
57             echo "Can't work out build platform"
58             exit 1
59         fi
60
61         BuildArch=`echo "$build" | sed 's/-.*//'`
62         BuildVendor=`echo "$build" | sed -e 's/.*-\(.*\)-.*/\1/'`
63         BuildOS=`echo "$build" | sed 's/.*-//'`
64     else
65         GHC_CONVERT_CPU([$build_cpu], [BuildArch])
66         GHC_CONVERT_VENDOR([$build_vendor], [BuildVendor])
67         GHC_CONVERT_OS([$build_os], [$BuildArch], [BuildOS])
68     fi
69
70     if test "$host_alias" = ""
71     then
72         if test "$bootstrap_target" != ""
73         then
74             host=$bootstrap_target
75             echo "Host platform inferred as: $host"
76         else
77             echo "Can't work out host platform"
78             exit 1
79         fi
80
81         HostArch=`echo "$host" | sed 's/-.*//'`
82         HostVendor=`echo "$host" | sed -e 's/.*-\(.*\)-.*/\1/'`
83         HostOS=`echo "$host" | sed 's/.*-//'`
84     else
85         GHC_CONVERT_CPU([$host_cpu], [HostArch])
86         GHC_CONVERT_VENDOR([$host_vendor], [HostVendor])
87         GHC_CONVERT_OS([$host_os], [$HostArch], [HostOS])
88     fi
89
90     if test "$target_alias" = ""
91     then
92         if test "$host_alias" != ""
93         then
94             GHC_CONVERT_CPU([$host_cpu], [TargetArch])
95             GHC_CONVERT_VENDOR([$host_vendor], [TargetVendor])
96             GHC_CONVERT_OS([$host_os], [$TargetArch],[TargetOS])
97         else
98             if test "$bootstrap_target" != ""
99             then
100                 target=$bootstrap_target
101                 echo "Target platform inferred as: $target"
102             else
103                 echo "Can't work out target platform"
104                 exit 1
105             fi
106
107             TargetArch=`echo "$target" | sed 's/-.*//'`
108             TargetVendor=`echo "$target" | sed -e 's/.*-\(.*\)-.*/\1/'`
109             TargetOS=`echo "$target" | sed 's/.*-//'`
110         fi
111     else
112         GHC_CONVERT_CPU([$target_cpu], [TargetArch])
113         GHC_CONVERT_VENDOR([$target_vendor], [TargetVendor])
114         GHC_CONVERT_OS([$target_os], [$TargetArch], [TargetOS])
115     fi
116
117     GHC_SELECT_FILE_EXTENSIONS([$host], [exeext_host], [soext_host])
118     GHC_SELECT_FILE_EXTENSIONS([$target], [exeext_target], [soext_target])
119     windows=NO
120     case $host in
121     *-unknown-mingw32)
122         windows=YES
123         ;;
124     esac
125
126     BuildPlatform="$BuildArch-$BuildVendor-$BuildOS"
127     BuildPlatform_CPP=`echo "$BuildPlatform" | sed -e 's/\./_/g' -e 's/-/_/g'`
128     BuildArch_CPP=`    echo "$BuildArch"     | sed -e 's/\./_/g' -e 's/-/_/g'`
129     BuildVendor_CPP=`  echo "$BuildVendor"   | sed -e 's/\./_/g' -e 's/-/_/g'`
130     BuildOS_CPP=`      echo "$BuildOS"       | sed -e 's/\./_/g' -e 's/-/_/g'`
131
132     HostPlatform="$HostArch-$HostVendor-$HostOS"
133     HostPlatform_CPP=`echo "$HostPlatform" | sed -e 's/\./_/g' -e 's/-/_/g'`
134     HostArch_CPP=`    echo "$HostArch"     | sed -e 's/\./_/g' -e 's/-/_/g'`
135     HostVendor_CPP=`  echo "$HostVendor"   | sed -e 's/\./_/g' -e 's/-/_/g'`
136     HostOS_CPP=`      echo "$HostOS"       | sed -e 's/\./_/g' -e 's/-/_/g'`
137
138     TargetPlatform="$TargetArch-$TargetVendor-$TargetOS"
139     TargetPlatform_CPP=`echo "$TargetPlatform" | sed -e 's/\./_/g' -e 's/-/_/g'`
140     TargetArch_CPP=`    echo "$TargetArch"     | sed -e 's/\./_/g' -e 's/-/_/g'`
141     TargetVendor_CPP=`  echo "$TargetVendor"   | sed -e 's/\./_/g' -e 's/-/_/g'`
142     TargetOS_CPP=`      echo "$TargetOS"       | sed -e 's/\./_/g' -e 's/-/_/g'`
143
144     echo "GHC build  : $BuildPlatform"
145     echo "GHC host   : $HostPlatform"
146     echo "GHC target : $TargetPlatform"
147
148     AC_SUBST(BuildPlatform)
149     AC_SUBST(HostPlatform)
150     AC_SUBST(TargetPlatform)
151     AC_SUBST(HostPlatform_CPP)
152     AC_SUBST(BuildPlatform_CPP)
153     AC_SUBST(TargetPlatform_CPP)
154
155     AC_SUBST(HostArch_CPP)
156     AC_SUBST(BuildArch_CPP)
157     AC_SUBST(TargetArch_CPP)
158
159     AC_SUBST(HostOS_CPP)
160     AC_SUBST(BuildOS_CPP)
161     AC_SUBST(TargetOS_CPP)
162
163     AC_SUBST(HostVendor_CPP)
164     AC_SUBST(BuildVendor_CPP)
165     AC_SUBST(TargetVendor_CPP)
166
167     AC_SUBST(exeext_host)
168     AC_SUBST(exeext_target)
169     AC_SUBST(soext_host)
170     AC_SUBST(soext_target)
171 ])
172
173
174 # FPTOOLS_SET_HASKELL_PLATFORM_VARS
175 # ----------------------------------
176 # Set the Haskell platform variables
177 AC_DEFUN([FPTOOLS_SET_HASKELL_PLATFORM_VARS],
178 [
179     checkArch() {
180         case [$]1 in
181         i386)
182             test -z "[$]2" || eval "[$]2=ArchX86"
183             ;;
184         x86_64|amd64)
185             test -z "[$]2" || eval "[$]2=ArchX86_64"
186             ;;
187         powerpc)
188             test -z "[$]2" || eval "[$]2=ArchPPC"
189             ;;
190         powerpc64)
191             test -z "[$]2" || eval "[$]2=ArchPPC_64"
192             ;;
193         sparc)
194             test -z "[$]2" || eval "[$]2=ArchSPARC"
195             ;;
196         arm)
197             GET_ARM_ISA()
198             test -z "[$]2" || eval "[$]2=\"ArchARM {armISA = \$ARM_ISA, armISAExt = \$ARM_ISA_EXT, armABI = \$ARM_ABI}\""
199             ;;
200         aarch64)
201             test -z "[$]2" || eval "[$]2=ArchARM64"
202             ;;
203         alpha)
204             test -z "[$]2" || eval "[$]2=ArchAlpha"
205             ;;
206         mips|mipseb)
207             test -z "[$]2" || eval "[$]2=ArchMipseb"
208             ;;
209         mipsel)
210             test -z "[$]2" || eval "[$]2=ArchMipsel"
211             ;;
212         hppa|hppa1_1|ia64|m68k|powerpc64le|rs6000|s390|s390x|sparc64|vax)
213             test -z "[$]2" || eval "[$]2=ArchUnknown"
214             ;;
215         *)
216             echo "Unknown arch [$]1"
217             exit 1
218             ;;
219         esac
220     }
221
222     checkVendor() {
223         case [$]1 in
224         dec|unknown|hp|apple|next|sun|sgi|ibm|montavista|portbld)
225             ;;
226         *)
227             echo "Unknown vendor [$]1"
228             exit 1
229             ;;
230         esac
231     }
232
233     checkOS() {
234         case [$]1 in
235         linux)
236             test -z "[$]2" || eval "[$]2=OSLinux"
237             ;;
238         ios)
239             test -z "[$]2" || eval "[$]2=OSiOS"
240             ;;
241         darwin)
242             test -z "[$]2" || eval "[$]2=OSDarwin"
243             ;;
244         solaris2)
245             test -z "[$]2" || eval "[$]2=OSSolaris2"
246             ;;
247         mingw32)
248             test -z "[$]2" || eval "[$]2=OSMinGW32"
249             ;;
250         freebsd)
251             test -z "[$]2" || eval "[$]2=OSFreeBSD"
252             ;;
253         dragonfly)
254             test -z "[$]2" || eval "[$]2=OSDragonFly"
255             ;;
256         kfreebsdgnu)
257             test -z "[$]2" || eval "[$]2=OSKFreeBSD"
258             ;;
259         openbsd)
260             test -z "[$]2" || eval "[$]2=OSOpenBSD"
261             ;;
262         netbsd)
263             test -z "[$]2" || eval "[$]2=OSNetBSD"
264             ;;
265         haiku)
266             test -z "[$]2" || eval "[$]2=OSHaiku"
267             ;;
268         osf3)
269             test -z "[$]2" || eval "[$]2=OSOsf3"
270             ;;
271         nto-qnx)
272             test -z "[$]2" || eval "[$]2=OSQNXNTO"
273             ;;
274         dragonfly|osf1|hpux|linuxaout|freebsd2|cygwin32|gnu|nextstep2|nextstep3|sunos4|ultrix|irix|aix)
275             test -z "[$]2" || eval "[$]2=OSUnknown"
276             ;;
277         linux-android)
278             test -z "[$]2" || eval "[$]2=OSAndroid"
279             ;;
280         *)
281             echo "Unknown OS '[$]1'"
282             exit 1
283             ;;
284         esac
285     }
286
287     dnl ** check for Apple-style dead-stripping support
288     dnl    (.subsections-via-symbols assembler directive)
289
290     AC_MSG_CHECKING(for .subsections_via_symbols)
291     AC_COMPILE_IFELSE(
292         [AC_LANG_PROGRAM([], [__asm__ (".subsections_via_symbols");])],
293         [AC_MSG_RESULT(yes)
294          HaskellHaveSubsectionsViaSymbols=True
295          AC_DEFINE([HAVE_SUBSECTIONS_VIA_SYMBOLS],[1],
296                    [Define to 1 if Apple-style dead-stripping is supported.])
297         ],
298         [HaskellHaveSubsectionsViaSymbols=False
299          AC_MSG_RESULT(no)])
300
301     dnl ** check for .ident assembler directive
302
303     AC_MSG_CHECKING(whether your assembler supports .ident directive)
304     AC_COMPILE_IFELSE(
305         [AC_LANG_SOURCE([__asm__ (".ident \"GHC x.y.z\"");])],
306         [AC_MSG_RESULT(yes)
307          HaskellHaveIdentDirective=True],
308         [AC_MSG_RESULT(no)
309          HaskellHaveIdentDirective=False])
310
311     dnl *** check for GNU non-executable stack note support (ELF only)
312     dnl     (.section .note.GNU-stack,"",@progbits)
313
314     dnl This test doesn't work with "gcc -g" in gcc 4.4 (GHC trac #3889:
315     dnl     Error: can't resolve `.note.GNU-stack' {.note.GNU-stack section} - `.Ltext0' {.text section}
316     dnl so we empty CFLAGS while running this test
317     CFLAGS2="$CFLAGS"
318     CFLAGS=
319     AC_MSG_CHECKING(for GNU non-executable stack support)
320     AC_COMPILE_IFELSE(
321         [AC_LANG_PROGRAM([__asm__ (".section .note.GNU-stack,\"\",@progbits");], [0])],
322         [AC_MSG_RESULT(yes)
323          HaskellHaveGnuNonexecStack=True],
324         [AC_MSG_RESULT(no)
325          HaskellHaveGnuNonexecStack=False])
326     CFLAGS="$CFLAGS2"
327
328     checkArch "$BuildArch" "HaskellBuildArch"
329     checkVendor "$BuildVendor"
330     checkOS "$BuildOS" ""
331
332     checkArch "$HostArch" "HaskellHostArch"
333     checkVendor "$HostVendor"
334     checkOS "$HostOS" ""
335
336     checkArch "$TargetArch" "HaskellTargetArch"
337     checkVendor "$TargetVendor"
338     checkOS "$TargetOS" "HaskellTargetOs"
339
340     AC_SUBST(HaskellTargetArch)
341     AC_SUBST(HaskellTargetOs)
342     AC_SUBST(HaskellHaveSubsectionsViaSymbols)
343     AC_SUBST(HaskellHaveIdentDirective)
344     AC_SUBST(HaskellHaveGnuNonexecStack)
345 ])
346
347
348 # GET_ARM_ISA
349 # ----------------------------------
350 # Get info about the ISA on the ARM arch
351 AC_DEFUN([GET_ARM_ISA],
352 [
353     AC_COMPILE_IFELSE([
354         AC_LANG_PROGRAM(
355             [],
356             [#if defined(__ARM_ARCH_2__)  || \
357                  defined(__ARM_ARCH_3__)  || \
358                  defined(__ARM_ARCH_3M__) || \
359                  defined(__ARM_ARCH_4__)  || \
360                  defined(__ARM_ARCH_4T__) || \
361                  defined(__ARM_ARCH_5__)  || \
362                  defined(__ARM_ARCH_5T__) || \
363                  defined(__ARM_ARCH_5E__) || \
364                  defined(__ARM_ARCH_5TE__)
365                  return 0;
366              #else
367                  not pre arm v6
368              #endif]
369         )],
370         [AC_DEFINE(arm_HOST_ARCH_PRE_ARMv6, 1, [ARM pre v6])
371          AC_DEFINE(arm_HOST_ARCH_PRE_ARMv7, 1, [ARM pre v7])
372          changequote(, )dnl
373          ARM_ISA=ARMv5
374          ARM_ISA_EXT="[]"
375          changequote([, ])dnl
376         ],
377         [
378             AC_COMPILE_IFELSE([
379                 AC_LANG_PROGRAM(
380                     [],
381                     [#if defined(__ARM_ARCH_6__)   || \
382                          defined(__ARM_ARCH_6J__)  || \
383                          defined(__ARM_ARCH_6T2__) || \
384                          defined(__ARM_ARCH_6Z__)  || \
385                          defined(__ARM_ARCH_6ZK__) || \
386                          defined(__ARM_ARCH_6M__)
387                          return 0;
388                      #else
389                          not pre arm v7
390                      #endif]
391                 )],
392                 [AC_DEFINE(arm_HOST_ARCH_PRE_ARMv7, 1, [ARM pre v7])
393                  ARM_ISA=ARMv6
394                  AC_COMPILE_IFELSE([
395                         AC_LANG_PROGRAM(
396                                 [],
397                                 [#if defined(__VFP_FP__)
398                                      return 0;
399                                 #else
400                                      no vfp
401                                 #endif]
402                         )],
403                         [changequote(, )dnl
404                          ARM_ISA_EXT="[VFPv2]"
405                          changequote([, ])dnl
406                         ],
407                         [changequote(, )dnl
408                          ARM_ISA_EXT="[]"
409                          changequote([, ])dnl
410                         ]
411                 )],
412                 [changequote(, )dnl
413                  ARM_ISA=ARMv7
414                  ARM_ISA_EXT="[VFPv3,NEON]"
415                  changequote([, ])dnl
416                 ])
417         ])
418
419         AC_COMPILE_IFELSE(
420                [AC_LANG_PROGRAM(
421                        [],
422                        [#if defined(__SOFTFP__)
423                             return 0;
424                        #else
425                             not softfp
426                        #endif]
427                )],
428                [changequote(, )dnl
429                 ARM_ABI="SOFT"
430                 changequote([, ])dnl
431                ],
432                [AC_COMPILE_IFELSE(
433                     [AC_LANG_PROGRAM(
434                        [],
435                        [#if defined(__ARM_PCS_VFP)
436                             return 0;
437                        #else
438                             no hard float ABI
439                        #endif]
440                     )],
441                     [ARM_ABI="HARD"],
442                     [ARM_ABI="SOFTFP"]
443                )]
444         )
445 ])
446
447
448 # FP_SETTINGS
449 # ----------------------------------
450 # Set the variables used in the settings file
451 AC_DEFUN([FP_SETTINGS],
452 [
453     if test "$windows" = YES
454     then
455         mingw_bin_prefix=mingw/bin/
456         SettingsCCompilerCommand="\$topdir/../${mingw_bin_prefix}gcc.exe"
457         SettingsHaskellCPPCommand="\$topdir/../${mingw_bin_prefix}gcc.exe"
458         SettingsHaskellCPPFlags="$HaskellCPPArgs"
459         SettingsLdCommand="\$topdir/../${mingw_bin_prefix}ld.exe"
460         SettingsArCommand="\$topdir/../${mingw_bin_prefix}ar.exe"
461         SettingsPerlCommand='$topdir/../perl/perl.exe'
462         SettingsDllWrapCommand="\$topdir/../${mingw_bin_prefix}dllwrap.exe"
463         SettingsWindresCommand="\$topdir/../${mingw_bin_prefix}windres.exe"
464         SettingsTouchCommand='$topdir/touchy.exe'
465     else
466         SettingsCCompilerCommand="$WhatGccIsCalled"
467         SettingsHaskellCPPCommand="$HaskellCPPCmd"
468         SettingsHaskellCPPFlags="$HaskellCPPArgs"
469         SettingsLdCommand="$LdCmd"
470         SettingsArCommand="$ArCmd"
471         SettingsPerlCommand="$PerlCmd"
472         SettingsDllWrapCommand="/bin/false"
473         SettingsWindresCommand="/bin/false"
474         SettingsLibtoolCommand="libtool"
475         SettingsTouchCommand='touch'
476         if test -z "$LlcCmd"
477         then
478           SettingsLlcCommand="llc"
479         else
480           SettingsLlcCommand="$LlcCmd"
481         fi
482         if test -z "$OptCmd"
483         then
484           SettingsOptCommand="opt"
485         else
486           SettingsOptCommand="$OptCmd"
487         fi
488     fi
489     SettingsCCompilerFlags="$CONF_CC_OPTS_STAGE2"
490     SettingsCCompilerLinkFlags="$CONF_GCC_LINKER_OPTS_STAGE2"
491     SettingsLdFlags="$CONF_LD_LINKER_OPTS_STAGE2"
492     AC_SUBST(SettingsCCompilerCommand)
493     AC_SUBST(SettingsHaskellCPPCommand)
494     AC_SUBST(SettingsHaskellCPPFlags)
495     AC_SUBST(SettingsCCompilerFlags)
496     AC_SUBST(SettingsCCompilerLinkFlags)
497     AC_SUBST(SettingsLdCommand)
498     AC_SUBST(SettingsLdFlags)
499     AC_SUBST(SettingsArCommand)
500     AC_SUBST(SettingsPerlCommand)
501     AC_SUBST(SettingsDllWrapCommand)
502     AC_SUBST(SettingsWindresCommand)
503     AC_SUBST(SettingsLibtoolCommand)
504     AC_SUBST(SettingsTouchCommand)
505     AC_SUBST(SettingsLlcCommand)
506     AC_SUBST(SettingsOptCommand)
507 ])
508
509
510 # FPTOOLS_SET_C_LD_FLAGS
511 # ----------------------------------
512 # Set the C, LD and CPP flags for a given platform
513 # $1 is the platform
514 # $2 is the name of the CC flags variable
515 # $3 is the name of the linker flags variable when linking with gcc
516 # $4 is the name of the linker flags variable when linking with ld
517 # $5 is the name of the CPP flags variable
518 AC_DEFUN([FPTOOLS_SET_C_LD_FLAGS],
519 [
520     AC_MSG_CHECKING([Setting up $2, $3, $4 and $5])
521     case $$1 in
522     i386-*)
523         # Workaround for #7799
524         $2="$$2 -U__i686"
525         ;;
526     esac
527
528     case $$1 in
529     i386-apple-darwin)
530         $2="$$2 -m32"
531         $3="$$3 -m32"
532         $4="$$4 -arch i386"
533         $5="$$5 -m32"
534         ;;
535     x86_64-apple-darwin)
536         $2="$$2 -m64"
537         $3="$$3 -m64"
538         $4="$$4 -arch x86_64"
539         $5="$$5 -m64"
540         ;;
541     x86_64-unknown-solaris2)
542         $2="$$2 -m64"
543         $3="$$3 -m64"
544         $4="$$4 -m64"
545         $5="$$5 -m64"
546         ;;
547     alpha-*)
548         # For now, to suppress the gcc warning "call-clobbered
549         # register used for global register variable", we simply
550         # disable all warnings altogether using the -w flag. Oh well.
551         $2="$$2 -w -mieee -D_REENTRANT"
552         $3="$$3 -w -mieee -D_REENTRANT"
553         $5="$$5 -w -mieee -D_REENTRANT"
554         ;;
555     hppa*)
556         # ___HPUX_SOURCE, not _HPUX_SOURCE, is #defined if -ansi!
557         # (very nice, but too bad the HP /usr/include files don't agree.)
558         $2="$$2 -D_HPUX_SOURCE"
559         $3="$$3 -D_HPUX_SOURCE"
560         $5="$$5 -D_HPUX_SOURCE"
561         ;;
562     esac
563
564     # If gcc knows about the stack protector, turn it off.
565     # Otherwise the stack-smash handler gets triggered.
566     echo 'int main(void) {return 0;}' > conftest.c
567     if $CC -c conftest.c -fno-stack-protector > /dev/null 2>&1
568     then
569         $2="$$2 -fno-stack-protector"
570     fi
571
572     rm -f conftest.c conftest.o
573     AC_MSG_RESULT([done])
574 ])
575
576
577 AC_DEFUN([FP_PATH_PROG],[
578     AC_PATH_PROG($1,$2,$3,$4,$5,$6)
579     # If we have a cygwin path for something, and we try to run it
580     # from cabal or python, then it'll fail. So we convert to a
581     # native path.
582     if test "$HostOS"     = "mingw32" && \
583        test "${OSTYPE}"  != "msys"    && \
584        test "${$1}" != ""
585     then
586         # Canonicalise to <drive>:/path/to/gcc
587         $1=`cygpath -m "${$1}"`
588     fi
589 ])
590
591
592 # FP_VISIBILITY_HIDDEN
593 # ----------------------------------
594 # Is the visibility hidden attribute supported?
595 AC_DEFUN([FP_VISIBILITY_HIDDEN],
596 [
597     AC_MSG_CHECKING([whether __attribute__((visibility("hidden"))) is supported])
598     echo '__attribute__((visibility("hidden"))) void foo(void) {}' > conftest.c
599     if $CC -Wall -Werror -c conftest.c > /dev/null 2>&1
600     then
601         AC_MSG_RESULT([yes])
602         AC_DEFINE(HAS_VISIBILITY_HIDDEN, 1, [Has visibility hidden])
603     else
604         AC_MSG_RESULT([no])
605     fi
606     rm -f conftest.c conftest.o
607 ])
608
609
610 # FPTOOLS_FLOAT_WORD_ORDER_BIGENDIAN
611 # ----------------------------------
612 # Little endian ARM on Linux with some ABIs has big endian word order
613 # in doubles. Define FLOAT_WORDS_BIGENDIAN if this is the case.
614 AC_DEFUN([FPTOOLS_FLOAT_WORD_ORDER_BIGENDIAN],
615   [AC_CACHE_CHECK([whether float word order is big endian], [fptools_cv_float_word_order_bigendian],
616     [AC_COMPILE_IFELSE(
617       [AC_LANG_PROGRAM(
618         [#include <endian.h>],
619         [#if defined(__FLOAT_WORD_ORDER) && __FLOAT_WORD_ORDER == BIG_ENDIAN
620              return 0;
621          #else
622              not float word order big endian
623          #endif]
624       )],
625       [fptools_cv_float_word_order_bigendian=yes],
626       [fptools_cv_float_word_order_bigendian=no])
627     ])
628   case $fptools_cv_float_word_order_bigendian in
629       yes)
630           AC_DEFINE([FLOAT_WORDS_BIGENDIAN], 1,
631           [Define to 1 if your processor stores words of floats with
632            the most significant byte first]) ;;
633   esac
634 ])
635
636
637 # FP_ARG_WITH_PATH_GNU_PROG
638 # --------------------
639 # Find the specified command on the path or allow a user to set it manually
640 # with a --with-<command> option. An error will be thrown if the command isn't
641 # found.
642 #
643 # This is ignored on the mingw32 platform.
644 #
645 # $1 = the variable to set
646 # $2 = the with option name
647 # $3 = the command to look for
648 #
649 AC_DEFUN([FP_ARG_WITH_PATH_GNU_PROG],
650 [
651 AC_ARG_WITH($2,
652 [AC_HELP_STRING([--with-$2=ARG],
653         [Use ARG as the path to $2 [default=autodetect]])],
654 [
655     if test "$HostOS" = "mingw32"
656     then
657         AC_MSG_WARN([Request to use $withval will be ignored])
658     else
659         $1=$withval
660     fi
661
662     # Remember that we set this manually.  Used to override CC_STAGE0
663     # and friends later, if we are not cross-compiling.
664     With_$2=$withval
665 ],
666 [
667     if test "$HostOS" != "mingw32"
668     then
669         if test "$target_alias" = "" ; then
670             AC_PATH_PROG([$1], [$3])
671         else
672             AC_PATH_PROG([$1], [$target_alias-$3])
673         fi
674         if test -z "$$1"
675         then
676             AC_MSG_ERROR([cannot find $3 in your PATH])
677         fi
678     fi
679 ]
680 )
681 ]) # FP_ARG_WITH_PATH_GNU_PROG
682
683
684 # FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL
685 # --------------------
686 # Same as FP_ARG_WITH_PATH_GNU_PROG but no error will be thrown if the command
687 # isn't found.
688 #
689 # This is ignored on the mingw32 platform.
690 #
691 # $1 = the variable to set
692 # $2 = the with option name
693 # $3 = the command to look for
694 #
695 AC_DEFUN([FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL],
696 [
697 AC_ARG_WITH($2,
698 [AC_HELP_STRING([--with-$2=ARG],
699         [Use ARG as the path to $2 [default=autodetect]])],
700 [
701     if test "$HostOS" = "mingw32"
702     then
703         AC_MSG_WARN([Request to use $withval will be ignored])
704     else
705         $1=$withval
706     fi
707
708     # Remember that we set this manually.  Used to override CC_STAGE0
709     # and friends later, if we are not cross-compiling.
710     With_$2=$withval
711 ],
712 [
713     if test "$HostOS" != "mingw32"
714     then
715         AC_PATH_PROG([$1], [$3])
716     fi
717 ]
718 )
719 ]) # FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL
720
721
722
723 # FP_PROG_CONTEXT_DIFF
724 # --------------------
725 # Figure out how to do context diffs. Sets the output variable ContextDiffCmd.
726 #
727 # Note: NeXTStep thinks diff'ing a file against itself is "trouble".
728 AC_DEFUN([FP_PROG_CONTEXT_DIFF],
729 [AC_CACHE_CHECK([for a working context diff], [fp_cv_context_diff],
730 [echo foo > conftest1
731 echo foo > conftest2
732 fp_cv_context_diff=no
733 for fp_var in '-U 1' '-u1' '-C 1' '-c1'
734 do
735   if diff $fp_var conftest1 conftest2 > /dev/null 2>&1; then
736     fp_cv_context_diff="diff $fp_var"
737     break
738   fi
739 done])
740 if test x"$fp_cv_context_diff" = xno; then
741    AC_MSG_ERROR([cannot figure out how to do context diffs])
742 fi
743 AC_SUBST(ContextDiffCmd, [$fp_cv_context_diff])
744 ])# FP_PROG_CONTEXT_DIFF
745
746
747 # FP_COMPUTE_INT(EXPRESSION, VARIABLE, INCLUDES, IF-FAILS)
748 # --------------------------------------------------------
749 # Assign VARIABLE the value of the compile-time EXPRESSION using INCLUDES for
750 # compilation. Execute IF-FAILS when unable to determine the value. Works for
751 # cross-compilation, too.
752 #
753 # Implementation note: We are lazy and use an internal autoconf macro, but it
754 # is supported in autoconf versions 2.50 up to the actual 2.57, so there is
755 # little risk.
756 AC_DEFUN([FP_COMPUTE_INT],
757 [_AC_COMPUTE_INT([$1], [$2], [$3], [$4])[]dnl
758 ])# FP_COMPUTE_INT
759
760
761 # FP_CHECK_ALIGNMENT(TYPE, [IGNORED], [INCLUDES = DEFAULT-INCLUDES])
762 # ------------------------------------------------------------------
763 # A variation of AC_CHECK_SIZEOF for computing the alignment restrictions of a
764 # given type. Defines ALIGNMENT_TYPE.
765 AC_DEFUN([FP_CHECK_ALIGNMENT],
766 [AS_LITERAL_IF(m4_translit([[$1]], [*], [p]), [],
767                [AC_FATAL([$0: requires literal arguments])])[]dnl
768 AC_CHECK_TYPE([$1], [], [], [$3])[]dnl
769 m4_pushdef([fp_Cache], [AS_TR_SH([fp_cv_alignment_$1])])[]dnl
770 AC_CACHE_CHECK([alignment of $1], [fp_Cache],
771 [if test "$AS_TR_SH([ac_cv_type_$1])" = yes; then
772   FP_COMPUTE_INT([offsetof(struct { char c; $1 ty; },ty)],
773                  [fp_Cache],
774                  [AC_INCLUDES_DEFAULT([$3])],
775                  [AC_MSG_ERROR([cannot compute alignment ($1)
776 See `config.log' for more details.], [77])])
777 else
778   fp_Cache=0
779 fi])[]dnl
780 AC_DEFINE_UNQUOTED(AS_TR_CPP(alignment_$1), $fp_Cache, [The alignment of a `$1'.])[]dnl
781 m4_popdef([fp_Cache])[]dnl
782 ])# FP_CHECK_ALIGNMENT
783
784
785 # FP_LEADING_UNDERSCORE
786 # ---------------------
787 # Test for determining whether symbol names have a leading underscore. We assume
788 # that they _haven't_ if anything goes wrong. Sets the output variable
789 # LeadingUnderscore to YES or NO and defines LEADING_UNDERSCORE correspondingly.
790 #
791 # Some nlist implementations seem to try to be compatible by ignoring a leading
792 # underscore sometimes (eg. FreeBSD). We therefore have to work around this by
793 # checking for *no* leading underscore first. Sigh.  --SDM
794 #
795 # Similarly on OpenBSD, but this test doesn't help. -- dons
796 AC_DEFUN([FP_LEADING_UNDERSCORE],
797 [AC_CHECK_LIB([elf], [nlist], [LIBS="-lelf $LIBS"])
798 AC_CACHE_CHECK([leading underscore in symbol names], [fptools_cv_leading_underscore], [
799 # Hack!: nlist() under Digital UNIX insist on there being an _,
800 # but symbol table listings shows none. What is going on here?!?
801 #
802 # Another hack: cygwin doesn't come with nlist.h , so we hardwire
803 # the underscoredness of that "platform"
804 case $HostPlatform in
805 *openbsd*) # x86 openbsd is ELF from 3.4 >, meaning no leading uscore
806   case $build in
807     i386-*2\.@<:@0-9@:>@ | i386-*3\.@<:@0-3@:>@ ) fptools_cv_leading_underscore=yes ;;
808     *) fptools_cv_leading_underscore=no ;;
809   esac ;;
810 alpha-dec-osf*) fptools_cv_leading_underscore=no;;
811 *cygwin32) fptools_cv_leading_underscore=yes;;
812 i386-unknown-mingw32) fptools_cv_leading_underscore=yes;;
813 x86_64-unknown-mingw32) fptools_cv_leading_underscore=no;;
814
815     # HACK: Apple doesn't seem to provide nlist in the 64-bit-libraries
816 x86_64-apple-darwin*) fptools_cv_leading_underscore=yes;;
817 *-apple-ios) fptools_cv_leading_underscore=yes;;
818
819 *) AC_RUN_IFELSE([AC_LANG_SOURCE([[#ifdef HAVE_NLIST_H
820 #include <nlist.h>
821 struct nlist xYzzY1[] = {{"xYzzY1", 0},{0}};
822 struct nlist xYzzY2[] = {{"_xYzzY2", 0},{0}};
823 #endif
824
825 int main(argc, argv)
826 int argc;
827 char **argv;
828 {
829 #ifdef HAVE_NLIST_H
830     if(nlist(argv[0], xYzzY1) == 0 && xYzzY1[0].n_value != 0)
831         exit(1);
832     if(nlist(argv[0], xYzzY2) == 0 && xYzzY2[0].n_value != 0)
833         exit(0);
834 #endif
835     exit(1);
836 }]])],[fptools_cv_leading_underscore=yes],[fptools_cv_leading_underscore=no],[fptools_cv_leading_underscore=no])
837 ;;
838 esac]);
839 AC_SUBST([LeadingUnderscore], [`echo $fptools_cv_leading_underscore | sed 'y/yesno/YESNO/'`])
840 if test x"$fptools_cv_leading_underscore" = xyes; then
841    AC_DEFINE([LEADING_UNDERSCORE], [1], [Define to 1 if C symbols have a leading underscore added by the compiler.])
842 fi])# FP_LEADING_UNDERSCORE
843
844
845 # FP_COMPARE_VERSIONS(VERSION1, TEST, VERSION2, [ACTION-IF-TRUE], [ACTION-IF-FALSE])
846 # ----------------------------------------------------------------------------------
847 # Compare dotted version numbers VERSION1 and VERSION2 lexicographically according
848 # to TEST (one of -eq, -ne, -lt, -le, -gt, or -ge).
849 AC_DEFUN([FP_COMPARE_VERSIONS],
850 [fp_version1=$1; fp_version2=$3
851 fp_save_IFS=$IFS; IFS='.'
852 while test x"$fp_version1" != x || test x"$fp_version2" != x
853 do
854
855   set dummy $fp_version1; shift
856   fp_num1=""
857   test $[@%:@] = 0 || { fp_num1="[$]1"; shift; }
858   test x"$fp_num1" = x && fp_num1="0"
859   fp_version1="[$]*"
860
861   set dummy $fp_version2; shift
862   fp_num2=""
863   test $[@%:@] = 0 || { fp_num2="[$]1"; shift; }
864   test x"$fp_num2" = x && fp_num2="0"
865   fp_version2="[$]*"
866
867   test "$fp_num1" = "$fp_num2" || break;
868 done
869 IFS=$fp_save_IFS
870 AS_IF([test "$fp_num1" $2 "$fp_num2"], [$4], [$5])[]dnl
871 ])# FP_COMPARE_VERSIONS
872
873
874 dnl
875 dnl Check for Happy and version.  If we're building GHC, then we need
876 dnl at least Happy version 1.19.  If there's no installed Happy, we look
877 dnl for a happy source tree and point the build system at that instead.
878 dnl
879 AC_DEFUN([FPTOOLS_HAPPY],
880 [FP_PATH_PROG(HappyCmd,happy,)
881
882 AC_CACHE_CHECK([for version of happy], fptools_cv_happy_version,
883 changequote(, )dnl
884 [if test x"$HappyCmd" != x; then
885    fptools_cv_happy_version=`"$HappyCmd" -v |
886                           grep 'Happy Version' | sed -e 's/Happy Version \([^ ]*\).*/\1/g'` ;
887 else
888    fptools_cv_happy_version="";
889 fi;
890 changequote([, ])dnl
891 ])
892 if test ! -f compiler/parser/Parser.hs || test ! -f compiler/cmm/CmmParse.hs
893 then
894     FP_COMPARE_VERSIONS([$fptools_cv_happy_version],[-lt],[1.19],
895       [AC_MSG_ERROR([Happy version 1.19 or later is required to compile GHC.])])[]
896 fi
897 HappyVersion=$fptools_cv_happy_version;
898 AC_SUBST(HappyVersion)
899 ])
900
901 dnl
902 dnl Check for Alex and version.  If we're building GHC, then we need
903 dnl at least Alex version 2.1.1.
904 dnl
905 AC_DEFUN([FPTOOLS_ALEX],
906 [
907 FP_PATH_PROG(AlexCmd,alex,)
908
909 AC_CACHE_CHECK([for version of alex], fptools_cv_alex_version,
910 changequote(, )dnl
911 [if test x"$AlexCmd" != x; then
912    fptools_cv_alex_version=`"$AlexCmd" -v |
913                           grep 'Alex [Vv]ersion' | sed -e 's/Alex [Vv]ersion \([0-9\.]*\).*/\1/g'` ;
914 else
915    fptools_cv_alex_version="";
916 fi;
917 changequote([, ])dnl
918 ])
919 FP_COMPARE_VERSIONS([$fptools_cv_alex_version],[-ge],[3.0],
920   [Alex3=YES],[Alex3=NO])
921 if test ! -f compiler/cmm/CmmLex.hs || test ! -f compiler/parser/Lexer.hs
922 then
923     FP_COMPARE_VERSIONS([$fptools_cv_alex_version],[-lt],[3.1.0],
924       [AC_MSG_ERROR([Alex version 3.1.0 or later is required to compile GHC.])])[]
925 fi
926 AlexVersion=$fptools_cv_alex_version;
927 AC_SUBST(AlexVersion)
928 AC_SUBST(Alex3)
929 ])
930
931
932 # FP_PROG_LD_FLAG
933 # ---------------
934 # Sets the output variable $2 to $1 if ld supports the $1 flag.
935 # Otherwise the variable's value is empty.
936 AC_DEFUN([FP_PROG_LD_FLAG],
937 [
938 AC_CACHE_CHECK([whether ld understands $1], [fp_cv_$2],
939 [echo 'int foo() { return 0; }' > conftest.c
940 ${CC-cc} -c conftest.c
941 if ${LdCmd} -r $1 -o conftest2.o conftest.o > /dev/null 2>&1; then
942    fp_cv_$2=$1
943 else
944    fp_cv_$2=
945 fi
946 rm -rf conftest*])
947 $2=$fp_cv_$2
948 ])# FP_PROG_LD_FLAG
949
950
951 # FP_PROG_LD_BUILD_ID
952 # ------------
953
954 # Sets the output variable LdHasBuildId to YES if ld supports
955 # --build-id, or NO otherwise.
956 AC_DEFUN([FP_PROG_LD_BUILD_ID],
957 [
958 AC_CACHE_CHECK([whether ld understands --build-id], [fp_cv_ld_build_id],
959 [echo 'int foo() { return 0; }' > conftest.c
960 ${CC-cc} -c conftest.c
961 if ${LdCmd} -r --build-id=none -o conftest2.o conftest.o > /dev/null 2>&1; then
962    fp_cv_ld_build_id=yes
963 else
964    fp_cv_ld_build_id=no
965 fi
966 rm -rf conftest*])
967 if test "$fp_cv_ld_build_id" = yes; then
968   LdHasBuildId=YES
969 else
970   LdHasBuildId=NO
971 fi
972 AC_SUBST([LdHasBuildId])
973 ])# FP_PROG_LD_BUILD_ID
974
975
976 # FP_PROG_LD_IS_GNU
977 # -----------------
978 # Sets the output variable LdIsGNULd to YES or NO, depending on whether it is
979 # GNU ld or not.
980 AC_DEFUN([FP_PROG_LD_IS_GNU],
981 [
982 AC_CACHE_CHECK([whether ld is GNU ld], [fp_cv_gnu_ld],
983 [if ${LdCmd} --version 2> /dev/null | grep "GNU" > /dev/null 2>&1; then
984   fp_cv_gnu_ld=yes
985 else
986   fp_cv_gnu_ld=no
987 fi])
988 AC_SUBST([LdIsGNULd], [`echo $fp_cv_gnu_ld | sed 'y/yesno/YESNO/'`])
989 ])# FP_PROG_LD_IS_GNU
990
991
992 # FP_PROG_LD_NO_COMPACT_UNWIND
993 # ----------------------------
994
995 # Sets the output variable LdHasNoCompactUnwind to YES if ld supports
996 # -no_compact_unwind, or NO otherwise.
997 AC_DEFUN([FP_PROG_LD_NO_COMPACT_UNWIND],
998 [
999 AC_CACHE_CHECK([whether ld understands -no_compact_unwind], [fp_cv_ld_no_compact_unwind],
1000 [echo 'int foo() { return 0; }' > conftest.c
1001 ${CC-cc} -c conftest.c
1002 if ${LdCmd} -r -no_compact_unwind -o conftest2.o conftest.o > /dev/null 2>&1; then
1003    fp_cv_ld_no_compact_unwind=yes
1004 else
1005    fp_cv_ld_no_compact_unwind=no
1006 fi
1007 rm -rf conftest*])
1008 if test "$fp_cv_ld_no_compact_unwind" = yes; then
1009   LdHasNoCompactUnwind=YES
1010 else
1011   LdHasNoCompactUnwind=NO
1012 fi
1013 AC_SUBST([LdHasNoCompactUnwind])
1014 ])# FP_PROG_LD_NO_COMPACT_UNWIND
1015
1016
1017 # FP_PROG_LD_FILELIST
1018 # -------------------
1019
1020 # Sets the output variable LdHasFilelist to YES if ld supports
1021 # -filelist, or NO otherwise.
1022 AC_DEFUN([FP_PROG_LD_FILELIST],
1023 [
1024 AC_CACHE_CHECK([whether ld understands -filelist], [fp_cv_ld_has_filelist],
1025 [
1026     echo 'int foo() { return 0; }' > conftest1.c
1027     echo 'int bar() { return 0; }' > conftest2.c
1028     ${CC-cc} -c conftest1.c
1029     ${CC-cc} -c conftest2.c
1030     echo conftest1.o  > conftest.o-files
1031     echo conftest2.o >> conftest.o-files
1032     if ${LdCmd} -r -filelist conftest.o-files -o conftest.o > /dev/null 2>&1
1033     then
1034         fp_cv_ld_has_filelist=yes
1035     else
1036         fp_cv_ld_has_filelist=no
1037     fi
1038     rm -rf conftest*
1039 ])
1040 if test "$fp_cv_ld_has_filelist" = yes; then
1041     LdHasFilelist=YES
1042 else
1043     LdHasFilelist=NO
1044 fi
1045 AC_SUBST([LdHasFilelist])
1046 ])# FP_PROG_LD_FILELIST
1047
1048
1049 # FP_PROG_AR
1050 # ----------
1051 # Sets fp_prog_ar to a (non-Cygwin) path to ar. Exits if no ar can be found
1052 AC_DEFUN([FP_PROG_AR],
1053 [FP_PATH_PROG([fp_prog_ar], [ar])
1054 if test -z "$fp_prog_ar"; then
1055   AC_MSG_ERROR([cannot find ar in your PATH, no idea how to make a library])
1056 fi
1057 ])# FP_PROG_AR
1058
1059
1060 # FP_PROG_AR_IS_GNU
1061 # -----------------
1062 # Sets fp_prog_ar_is_gnu to yes or no, depending on whether it is GNU ar or not.
1063 AC_DEFUN([FP_PROG_AR_IS_GNU],
1064 [AC_REQUIRE([FP_PROG_AR])
1065 AC_CACHE_CHECK([whether $fp_prog_ar is GNU ar], [fp_cv_prog_ar_is_gnu],
1066 [if "$fp_prog_ar" --version 2> /dev/null | grep "GNU" > /dev/null 2>&1; then
1067   fp_cv_prog_ar_is_gnu=yes
1068 else
1069   fp_cv_prog_ar_is_gnu=no
1070 fi])
1071 fp_prog_ar_is_gnu=$fp_cv_prog_ar_is_gnu
1072 AC_SUBST([ArIsGNUAr], [`echo $fp_prog_ar_is_gnu | tr 'a-z' 'A-Z'`])
1073 ])# FP_PROG_AR_IS_GNU
1074
1075
1076 # FP_PROG_AR_SUPPORTS_ATFILE
1077 # -----------------
1078 # Sets fp_prog_ar_supports_atfile to yes or no, depending on whether
1079 # or not it supports the @file syntax
1080 AC_DEFUN([FP_PROG_AR_SUPPORTS_ATFILE],
1081 [AC_REQUIRE([FP_PROG_AR])
1082  AC_REQUIRE([FP_PROG_AR_ARGS])
1083 AC_CACHE_CHECK([whether $fp_prog_ar supports @file], [fp_cv_prog_ar_supports_atfile],
1084 [
1085 rm -f conftest*
1086 touch conftest.file
1087 echo conftest.file  > conftest.atfile
1088 echo conftest.file >> conftest.atfile
1089 "$fp_prog_ar" $fp_prog_ar_args conftest.a @conftest.atfile > /dev/null 2>&1
1090 fp_prog_ar_supports_atfile_tmp=`"$fp_prog_ar" t conftest.a 2> /dev/null | grep -c conftest.file`
1091 rm -f conftest*
1092 if test "$fp_prog_ar_supports_atfile_tmp" -eq 2
1093 then
1094   fp_cv_prog_ar_supports_atfile=yes
1095 else
1096   fp_cv_prog_ar_supports_atfile=no
1097 fi])
1098 fp_prog_ar_supports_atfile=$fp_cv_prog_ar_supports_atfile
1099 AC_SUBST([ArSupportsAtFile], [`echo $fp_prog_ar_supports_atfile | tr 'a-z' 'A-Z'`])
1100 ])# FP_PROG_AR_SUPPORTS_ATFILE
1101
1102 # FP_PROG_AR_ARGS
1103 # ---------------
1104 # Sets fp_prog_ar_args to the arguments for ar and the output variable ArCmd
1105 # to a non-Cygwin invocation of ar including these arguments.
1106 AC_DEFUN([FP_PROG_AR_ARGS],
1107 [AC_REQUIRE([FP_PROG_AR_IS_GNU])
1108 AC_CACHE_CHECK([for ar arguments], [fp_cv_prog_ar_args],
1109 [
1110 # GNU ar needs special treatment: it appears to have problems with
1111 # object files with the same name if you use the 's' modifier, but
1112 # simple 'ar q' works fine, and doesn't need a separate ranlib.
1113 if test $fp_prog_ar_is_gnu = yes; then
1114   fp_cv_prog_ar_args="q"
1115 else
1116   touch conftest.dummy
1117   for fp_var in clqsZ clqs cqs clq cq ; do
1118      rm -f conftest.a
1119      if "$fp_prog_ar" $fp_var conftest.a conftest.dummy > /dev/null 2> /dev/null; then
1120         fp_cv_prog_ar_args=$fp_var
1121         break
1122      fi
1123   done
1124   rm -f conftest*
1125   if test -z "$fp_cv_prog_ar_args"; then
1126     AC_MSG_ERROR([cannot figure out how to use your $fp_prog_ar])
1127   fi
1128 fi])
1129 fp_prog_ar_args=$fp_cv_prog_ar_args
1130 AC_SUBST([ArCmd], ["$fp_prog_ar"])
1131 AC_SUBST([ArArgs], ["$fp_prog_ar_args"])
1132
1133 ])# FP_PROG_AR_ARGS
1134
1135
1136 # FP_PROG_AR_NEEDS_RANLIB
1137 # -----------------------
1138 # Sets the output variable RANLIB_CMD to "ranlib" if it is needed and
1139 # found, to "true" otherwise. Sets REAL_RANLIB_CMD to the ranlib program,
1140 # even if we don't need ranlib (libffi might still need it).
1141 AC_DEFUN([FP_PROG_AR_NEEDS_RANLIB],[
1142     AC_REQUIRE([FP_PROG_AR_IS_GNU])
1143     AC_REQUIRE([FP_PROG_AR_ARGS])
1144     AC_REQUIRE([AC_PROG_CC])
1145
1146     AC_PROG_RANLIB
1147
1148     if test $fp_prog_ar_is_gnu = yes
1149     then
1150         fp_cv_prog_ar_needs_ranlib=no
1151     elif test "$TargetOS_CPP" = "darwin"
1152     then
1153         # It's quite tedious to check for Apple's crazy timestamps in
1154         # .a files, so we hardcode it.
1155         fp_cv_prog_ar_needs_ranlib=yes
1156     else
1157         case $fp_prog_ar_args in
1158         *s*)
1159             fp_cv_prog_ar_needs_ranlib=no;;
1160         *)
1161             fp_cv_prog_ar_needs_ranlib=yes;;
1162         esac
1163     fi
1164
1165     # workaround for AC_PROG_RANLIB which sets RANLIB to `:' when
1166     # ranlib is missing on the target OS. The problem is that
1167     # ghc-cabal cannot execute `:' which is a shell built-in but can
1168     # execute `true' which is usually simple program supported by the
1169     # OS.
1170     # Fixes #8795
1171     if test "$RANLIB" = ":"
1172     then
1173         RANLIB="true"
1174     fi
1175     REAL_RANLIB_CMD="$RANLIB"
1176     if test $fp_cv_prog_ar_needs_ranlib = yes
1177     then
1178         RANLIB_CMD="$RANLIB"
1179     else
1180         RANLIB_CMD="true"
1181     fi
1182     AC_SUBST([REAL_RANLIB_CMD])
1183     AC_SUBST([RANLIB_CMD])
1184 ])# FP_PROG_AR_NEEDS_RANLIB
1185
1186
1187 # FP_GCC_VERSION
1188 # -----------
1189 # Extra testing of the result AC_PROG_CC, testing the gcc version no. Sets the
1190 # output variable GccVersion.
1191 AC_DEFUN([FP_GCC_VERSION],
1192 [AC_REQUIRE([AC_PROG_CC])
1193 if test -z "$CC"
1194 then
1195   AC_MSG_ERROR([gcc is required])
1196 fi
1197 GccLT34=NO
1198 GccLT46=NO
1199 AC_CACHE_CHECK([version of gcc], [fp_cv_gcc_version],
1200 [
1201     fp_cv_gcc_version="`$CC -v 2>&1 | grep 'version ' | sed -e 's/.*version [[^0-9]]*\([[0-9.]]*\).*/\1/g'`"
1202     FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-lt], [3.0],
1203                         [AC_MSG_ERROR([Need at least gcc version 3.0 (3.4+ recommended)])])
1204     # See #2770: gcc 2.95 doesn't work any more, apparently.  There probably
1205     # isn't a very good reason for that, but for now just make configure
1206     # fail.
1207     FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-lt], [3.4], GccLT34=YES)
1208     FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-lt], [4.6], GccLT46=YES)
1209 ])
1210 AC_SUBST([GccVersion], [$fp_cv_gcc_version])
1211 AC_SUBST(GccLT34)
1212 AC_SUBST(GccLT46)
1213 ])# FP_GCC_VERSION
1214
1215 dnl Check to see if the C compiler is clang or llvm-gcc
1216 dnl
1217 GccIsClang=NO
1218 AC_DEFUN([FP_CC_LLVM_BACKEND],
1219 [AC_REQUIRE([AC_PROG_CC])
1220 AC_MSG_CHECKING([whether C compiler is clang])
1221 $CC -x c /dev/null -dM -E > conftest.txt 2>&1
1222 if grep "__clang__" conftest.txt >/dev/null 2>&1; then
1223   AC_SUBST([CC_CLANG_BACKEND], [1])
1224   AC_SUBST([CC_LLVM_BACKEND], [1])
1225   GccIsClang=YES
1226   AC_MSG_RESULT([yes])
1227 else
1228   AC_MSG_RESULT([no])
1229   AC_MSG_CHECKING([whether C compiler has an LLVM back end])
1230   if grep "__llvm__" conftest.txt >/dev/null 2>&1; then
1231     AC_SUBST([CC_CLANG_BACKEND], [0])
1232     AC_SUBST([CC_LLVM_BACKEND], [1])
1233     AC_MSG_RESULT([yes])
1234   else
1235     AC_SUBST([CC_CLANG_BACKEND], [0])
1236     AC_SUBST([CC_LLVM_BACKEND], [0])
1237     AC_MSG_RESULT([no])
1238   fi
1239 fi
1240 AC_SUBST(GccIsClang)
1241
1242 rm -f conftest.txt
1243 ])
1244
1245 dnl Small feature test for perl version. Assumes PerlCmd
1246 dnl contains path to perl binary.
1247 dnl
1248 dnl (Perl versions prior to v5.6 does not contain the string "v5";
1249 dnl instead they display version strings such as "version 5.005".)
1250 dnl
1251 AC_DEFUN([FPTOOLS_CHECK_PERL_VERSION],
1252 [$PerlCmd -v >conftest.out 2>&1
1253    if grep "v5" conftest.out >/dev/null 2>&1; then
1254       :
1255    else
1256       AC_MSG_ERROR([your version of perl probably won't work, try upgrading it.])
1257    fi
1258 rm -fr conftest*
1259 ])
1260
1261
1262 # FP_CHECK_PROG(VARIABLE, PROG-TO-CHECK-FOR,
1263 #               [VALUE-IF-NOT-FOUND], [PATH], [REJECT])
1264 # -----------------------------------------------------
1265 # HACK: A small wrapper around AC_CHECK_PROG, setting VARIABLE to the full path
1266 # of PROG-TO-CHECK-FOR when found.
1267 AC_DEFUN([FP_CHECK_PROG],
1268 [AC_CHECK_PROG([$1], [$2], [$as_dir/$ac_word$ac_exec_ext], [$3], [$4], [$5])][]dnl
1269 )# FP_CHECK_PROC
1270
1271
1272 # FP_PROG_FIND
1273 # ------------
1274 # Find a non-WinDoze version of the "find" utility.
1275 AC_DEFUN([FP_PROG_FIND],
1276 [AC_PATH_PROGS([fp_prog_find], [gfind find], find)
1277 echo foo > conftest.txt
1278 $fp_prog_find conftest.txt -print > conftest.out 2>&1
1279 if grep '^conftest.txt$' conftest.out > /dev/null 2>&1 ; then
1280   # OK, looks like a real "find".
1281   case $HostPlatform in
1282     *mingw32)
1283       if test x${OSTYPE} != xmsys
1284       then
1285             fp_prog_find="`cygpath --mixed ${fp_prog_find}`"
1286         AC_MSG_NOTICE([normalized find command to $fp_prog_find])
1287       fi ;;
1288     *) ;;
1289   esac
1290   FindCmd="$fp_prog_find"
1291 else
1292   # Found a poor WinDoze version of "find", ignore it.
1293   AC_MSG_WARN([$fp_prog_find looks like a non-*nix find, ignoring it])
1294   FP_CHECK_PROG([FindCmd], [find], [], [], [$fp_prog_find])
1295 fi
1296 rm -f conftest.txt conftest.out
1297 AC_SUBST([FindCmd])[]dnl
1298 ])# FP_PROG_FIND
1299
1300
1301 # FP_PROG_SORT
1302 # ------------
1303 # Find a Unix-like sort
1304 AC_DEFUN([FP_PROG_SORT],
1305 [AC_PATH_PROG([fp_prog_sort], [sort])
1306 echo conwip > conftest.txt
1307 $fp_prog_sort -f conftest.txt > conftest.out 2>&1
1308 if grep 'conwip' conftest.out > /dev/null 2>&1 ; then
1309   # The goods
1310   SortCmd="$fp_prog_sort"
1311 else
1312   # Summink else..pick next one.
1313   AC_MSG_WARN([$fp_prog_sort looks like a non-*nix sort, ignoring it])
1314   FP_CHECK_PROG([SortCmd], [sort], [], [], [$fp_prog_sort])
1315 fi
1316 rm -f conftest.txt conftest.out
1317 AC_SUBST([SortCmd])[]dnl
1318 ])# FP_PROG_SORT
1319
1320
1321 dnl
1322 dnl FPTOOLS_NOCACHE_CHECK prints a message, then sets the
1323 dnl values of the second argument to the result of running
1324 dnl the commands given by the third. It does not cache its
1325 dnl result, so it is suitable for checks which should be
1326 dnl run every time.
1327 dnl
1328 AC_DEFUN([FPTOOLS_NOCACHE_CHECK],
1329 [AC_MSG_CHECKING([$1])
1330  $3
1331  AC_MSG_RESULT([$][$2])
1332 ])
1333
1334 dnl
1335 dnl FPTOOLS_GHC_VERSION(version)
1336 dnl FPTOOLS_GHC_VERSION(major, minor [, patchlevel])
1337 dnl FPTOOLS_GHC_VERSION(version, major, minor, patchlevel)
1338 dnl
1339 dnl Test for version of installed ghc.  Uses $GHC.
1340 dnl [original version pinched from c2hs]
1341 dnl
1342 AC_DEFUN([FPTOOLS_GHC_VERSION],
1343 [FPTOOLS_NOCACHE_CHECK([version of ghc], [fptools_version_of_ghc],
1344 ["${WithGhc-ghc}" --version > conftestghc 2>&1
1345   cat conftestghc >&AS_MESSAGE_LOG_FD
1346 #Useless Use Of cat award...
1347   fptools_version_of_ghc=`cat conftestghc | sed -n -e 's/, patchlevel *\([[0-9]]\)/.\1/;s/.* version \([[0-9]][[0-9.]]*\).*/\1/p'`
1348   rm -fr conftest*
1349   if test "[$]fptools_version_of_ghc" = ""
1350   then
1351     fptools_version_of_ghc='unknown'
1352   fi
1353 fptools_version_of_ghc[_major]=`echo [$]fptools_version_of_ghc | sed -e 's/^\([[0-9]]\).*/\1/'`
1354 fptools_version_of_ghc[_minor]=`echo [$]fptools_version_of_ghc | sed -e 's/^[[0-9]]\.\([[0-9]]*\).*/\1/'`
1355 fptools_version_of_ghc[_pl]=`echo [$]fptools_version_of_ghc | sed -n -e 's/^[[0-9]]\.[[0-9]]*\.\([[0-9]]*\)/\1/p'`
1356 #
1357 if test "[$]fptools_version_of_ghc[_pl]" = ""
1358 then
1359   fptools_version_of_ghc[_all]="[$]fptools_version_of_ghc[_major].[$]fptools_version_of_ghc[_minor]"
1360   fptools_version_of_ghc[_pl]="0"
1361 else
1362   fptools_version_of_ghc[_all]="[$]fptools_version_of_ghc[_major].[$]fptools_version_of_ghc[_minor].[$]fptools_version_of_ghc[_pl]"
1363 fi
1364 #
1365 ifelse($#, [1], [dnl
1366 [$1]="[$]fptools_version_of_ghc[_all]"
1367 ], $#, [2], [dnl
1368 [$1]="[$]fptools_version_of_ghc[_major]"
1369 [$2]="[$]fptools_version_of_ghc[_minor]"
1370 ], $#, [3], [dnl
1371 [$1]="[$]fptools_version_of_ghc[_major]"
1372 [$2]="[$]fptools_version_of_ghc[_minor]"
1373 [$3]="[$]fptools_version_of_ghc[_pl]"
1374 ], $#, [4], [dnl
1375 [$1]="[$]fptools_version_of_ghc[_all]"
1376 [$2]="[$]fptools_version_of_ghc[_major]"
1377 [$3]="[$]fptools_version_of_ghc[_minor]"
1378 [$4]="[$]fptools_version_of_ghc[_pl]"
1379 ])
1380 ])
1381 ])dnl
1382
1383
1384 # FP_CHECK_FUNC(FUNCTION, PROLOGUE, BODY, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1385 # ---------------------------------------------------------------------------------
1386 # A variant of AC_CHECK_FUNCS, limited to a single FUNCTION, but with the
1387 # additional flexibility of specifying the PROLOGUE and BODY.
1388 AC_DEFUN([FP_CHECK_FUNC],
1389 [AS_VAR_PUSHDEF([fp_func], [fp_cv_func_$1])dnl
1390 AC_CACHE_CHECK([for $1], fp_func,
1391 [AC_LINK_IFELSE([AC_LANG_PROGRAM([$2], [$3])],
1392                 [AS_VAR_SET(fp_func, yes)],
1393                 [AS_VAR_SET(fp_func, no)])])
1394 AS_IF([test AS_VAR_GET(fp_func) = yes],
1395       [AC_DEFINE(AS_TR_CPP(HAVE_$1), [1],
1396                 [Define to 1 if you have the `]$1[' function.]) $4],
1397       [$5])dnl
1398 AS_VAR_POPDEF([fp_func])dnl
1399 ])# FP_CHECK_FUNC
1400
1401
1402 # FP_GEN_DOCBOOK_XML
1403 # ------------------
1404 # Generates a DocBook XML V4.5 document in conftest.xml.
1405 #
1406 # It took a lot of experimentation to find a document that will cause
1407 # xsltproc to fail with an error code when the relevant
1408 # stylesheets/DTDs are not found.  I couldn't make xsltproc fail with
1409 # a single-file document, it seems a multi-file document is needed.
1410 # -- SDM 2009-06-03
1411 #
1412 AC_DEFUN([FP_GEN_DOCBOOK_XML],
1413 [rm -f conftest.xml conftest-book.xml
1414 cat > conftest.xml << EOF
1415 <?xml version="1.0" encoding="iso-8859-1"?>
1416 <!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
1417    "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd" [[
1418 <!ENTITY conftest-book SYSTEM "conftest-book.xml">
1419 ]]>
1420 <book id="test">
1421 &conftest-book;
1422 </book>
1423 EOF
1424 cat >conftest-book.xml << EOF
1425 <?xml version="1.0" encoding="iso-8859-1"?>
1426   <title>A DocBook &ldquo;Test Document&rdquo;</title>
1427   <chapter id="id-one">
1428     <title>A Chapter Title</title>
1429     <para>This is a paragraph, referencing <xref linkend="id-two"/>.</para>
1430   </chapter>
1431   <chapter id="id-two">
1432     <title>Another Chapter Title</title>
1433     <para>This is another paragraph, referencing <xref linkend="id-one"/>.</para>
1434   </chapter>
1435 EOF
1436 ]) # FP_GEN_DOCBOOK_XML
1437
1438
1439 # FP_PROG_DBLATEX
1440 # ----------------
1441 # Sets the output variable DblatexCmd to the full path of dblatex,
1442 # which we use for building PDF and PS docs.
1443 # DblatexCmd is empty if dblatex could not be found.
1444 AC_DEFUN([FP_PROG_DBLATEX],
1445 [FP_PATH_PROG([DblatexCmd], [dblatex])
1446 if test -z "$DblatexCmd"; then
1447   AC_MSG_WARN([cannot find dblatex in your PATH, you will not be able to build the PDF and PS documentation])
1448 fi
1449 ])# FP_PROG_DBLATEX
1450
1451
1452 # FP_PROG_XSLTPROC
1453 # ----------------
1454 # Sets the output variable XsltprocCmd to the full path of the XSLT processor
1455 # xsltproc. XsltprocCmd is empty if xsltproc could not be found.
1456 AC_DEFUN([FP_PROG_XSLTPROC],
1457 [FP_PATH_PROG([XsltprocCmd], [xsltproc])
1458 if test -z "$XsltprocCmd"; then
1459   AC_MSG_WARN([cannot find xsltproc in your PATH, you will not be able to build the HTML documentation])
1460 fi
1461 ])# FP_PROG_XSLTPROC
1462
1463
1464 # FP_DOCBOOK_XSL
1465 # ----------------------------
1466 # Check that we can process a DocBook XML document to HTML using xsltproc.
1467 AC_DEFUN([FP_DOCBOOK_XSL],
1468 [AC_REQUIRE([FP_PROG_XSLTPROC])dnl
1469 if test -n "$XsltprocCmd"; then
1470   AC_CACHE_CHECK([for DocBook XSL stylesheet], fp_cv_dir_docbook_xsl,
1471   [FP_GEN_DOCBOOK_XML
1472   fp_cv_dir_docbook_xsl=no
1473   if $XsltprocCmd --nonet http://docbook.sourceforge.net/release/xsl/current/html/chunk.xsl conftest.xml > /dev/null 2>&1; then
1474      fp_cv_dir_docbook_xsl=yes
1475   fi
1476   rm -rf conftest*])
1477 fi
1478 if test x"$fp_cv_dir_docbook_xsl" = xno; then
1479   AC_MSG_WARN([cannot find DocBook XSL stylesheets, you will not be able to build the documentation])
1480   HAVE_DOCBOOK_XSL=NO
1481 else
1482   HAVE_DOCBOOK_XSL=YES
1483 fi
1484 AC_SUBST([HAVE_DOCBOOK_XSL])
1485 ])# FP_DOCBOOK_XSL
1486
1487
1488 # FP_PROG_XMLLINT
1489 # ----------------
1490 # Sets the output variable XmllintCmd to the full path of the XSLT processor
1491 # xmllint. XmllintCmd is empty if xmllint could not be found.
1492 AC_DEFUN([FP_PROG_XMLLINT],
1493 [FP_PATH_PROG([XmllintCmd], [xmllint])
1494 if test -z "$XmllintCmd"; then
1495   AC_MSG_WARN([cannot find xmllint in your PATH, you will not be able to validate your documentation])
1496 fi
1497 ])# FP_PROG_XMLLINT
1498
1499
1500 # FP_CHECK_DOCBOOK_DTD
1501 # --------------------
1502 AC_DEFUN([FP_CHECK_DOCBOOK_DTD],
1503 [AC_REQUIRE([FP_PROG_XMLLINT])dnl
1504 if test -n "$XmllintCmd"; then
1505   AC_MSG_CHECKING([for DocBook DTD])
1506   FP_GEN_DOCBOOK_XML
1507   if $XmllintCmd --nonet --valid --noout conftest.xml ; then
1508     AC_MSG_RESULT([ok])
1509   else
1510     AC_MSG_RESULT([failed])
1511     AC_MSG_WARN([cannot find a DTD for DocBook XML V4.5, you will not be able to validate your documentation])
1512     AC_MSG_WARN([check your XML_CATALOG_FILES environment variable and/or /etc/xml/catalog])
1513   fi
1514   rm -rf conftest*
1515 fi
1516 ])# FP_CHECK_DOCBOOK_DTD
1517
1518
1519 # FP_PROG_GHC_PKG
1520 # ----------------
1521 # Try to find a ghc-pkg matching the ghc mentioned in the environment variable
1522 # WithGhc. Sets the output variable GhcPkgCmd.
1523 AC_DEFUN([FP_PROG_GHC_PKG],
1524 [AC_CACHE_CHECK([for ghc-pkg matching $WithGhc], fp_cv_matching_ghc_pkg,
1525 [
1526 # If we are told to use ghc-stage2, then we're using an in-tree
1527 # compiler. In this case, we just want ghc-pkg, not ghc-pkg-stage2,
1528 # so we sed off -stage[0-9]$. However, if we are told to use
1529 # ghc-6.12.1 then we want to use ghc-pkg-6.12.1, so we keep any
1530 # other suffix.
1531 fp_ghc_pkg_guess=`echo $WithGhc | sed -e 's/-stage@<:@0-9@:>@$//' -e 's,ghc\(@<:@^/\\@:>@*\)$,ghc-pkg\1,'`
1532 if "$fp_ghc_pkg_guess" list > /dev/null 2>&1; then
1533   fp_cv_matching_ghc_pkg=$fp_ghc_pkg_guess
1534 else
1535   AC_MSG_ERROR([Cannot find matching ghc-pkg])
1536 fi])
1537 GhcPkgCmd=$fp_cv_matching_ghc_pkg
1538 AC_SUBST([GhcPkgCmd])
1539 ])# FP_PROG_GHC_PKG
1540
1541
1542 # FP_GCC_EXTRA_FLAGS
1543 # ------------------
1544 # Determine which extra flags we need to pass gcc when we invoke it
1545 # to compile .hc code.
1546 #
1547 # -fwrapv is needed for gcc to emit well-behaved code in the presence of
1548 # integer wrap around. (Trac #952)
1549 #
1550 AC_DEFUN([FP_GCC_EXTRA_FLAGS],
1551 [AC_REQUIRE([FP_GCC_VERSION])
1552 AC_CACHE_CHECK([for extra options to pass gcc when compiling via C], [fp_cv_gcc_extra_opts],
1553 [fp_cv_gcc_extra_opts=
1554  FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-ge], [3.4],
1555   [fp_cv_gcc_extra_opts="$fp_cv_gcc_extra_opts -fwrapv"],
1556   [])
1557 ])
1558 AC_SUBST([GccExtraViaCOpts],$fp_cv_gcc_extra_opts)
1559 ])
1560
1561
1562 # FP_SETUP_PROJECT_VERSION
1563 # ---------------------
1564 AC_DEFUN([FP_SETUP_PROJECT_VERSION],
1565 [
1566 if test "$RELEASE" = "NO"; then
1567     AC_MSG_CHECKING([for GHC version date])
1568     if test -f VERSION_DATE; then
1569         PACKAGE_VERSION=${PACKAGE_VERSION}.`cat VERSION_DATE`
1570         AC_MSG_RESULT(given $PACKAGE_VERSION)
1571     elif test -d .git; then
1572         changequote(, )dnl
1573         ver_date=`git log -n 1 --date=short --pretty=format:%ci | cut -d ' ' -f 1 | tr -d -`
1574         if echo $ver_date | grep '^[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]$' 2>&1 >/dev/null; then true; else
1575         changequote([, ])dnl
1576                 AC_MSG_ERROR([failed to detect version date: check that git is in your path])
1577         fi
1578         PACKAGE_VERSION=${PACKAGE_VERSION}.$ver_date
1579         AC_MSG_RESULT(inferred $PACKAGE_VERSION)
1580     elif test -f VERSION; then
1581         PACKAGE_VERSION=`cat VERSION`
1582         AC_MSG_RESULT(given $PACKAGE_VERSION)
1583     else
1584         AC_MSG_WARN([cannot determine snapshot version: no .git directory and no VERSION file])
1585         dnl We'd really rather this case didn't happen, but it might
1586         dnl do (in particular, people using lndir trees may find that
1587         dnl the build system can't find any other date). If it does
1588         dnl happen, then we use the current date.
1589         dnl This way we get some idea about how recent a build is.
1590         dnl It also means that packages built for 2 different builds
1591         dnl will probably use different version numbers, so things are
1592         dnl less likely to go wrong.
1593         PACKAGE_VERSION=${PACKAGE_VERSION}.`date +%Y%m%d`
1594     fi
1595 fi
1596
1597 # Some renamings
1598 AC_SUBST([ProjectName], [$PACKAGE_NAME])
1599 AC_SUBST([ProjectVersion], [$PACKAGE_VERSION])
1600
1601 # Split PACKAGE_VERSION into (possibly empty) parts
1602 VERSION_MAJOR=`echo $PACKAGE_VERSION | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\1'/`
1603 VERSION_TMP=`echo $PACKAGE_VERSION | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\3'/`
1604 VERSION_MINOR=`echo $VERSION_TMP | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\1'/`
1605 ProjectPatchLevel=`echo $VERSION_TMP | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\3'/`
1606
1607 # Calculate project version as an integer, using 2 digits for minor version
1608 case $VERSION_MINOR in
1609   ?) ProjectVersionInt=${VERSION_MAJOR}0${VERSION_MINOR} ;;
1610   ??) ProjectVersionInt=${VERSION_MAJOR}${VERSION_MINOR} ;;
1611   *) AC_MSG_ERROR([bad minor version in $PACKAGE_VERSION]) ;;
1612 esac
1613 AC_SUBST([ProjectVersionInt])
1614
1615 # The project patchlevel is zero unless stated otherwise
1616 test -z "$ProjectPatchLevel" && ProjectPatchLevel=0
1617
1618 # Remove dots from the patch level; this allows us to have versions like 6.4.1.20050508
1619 ProjectPatchLevel=`echo $ProjectPatchLevel | sed 's/\.//'`
1620
1621 AC_SUBST([ProjectPatchLevel])
1622 ])# FP_SETUP_PROJECT_VERSION
1623
1624
1625 # Check for a working timer_create().  We need a pretty detailed check
1626 # here, because there exist partially-working implementations of
1627 # timer_create() in certain versions of Linux (see bug #1933).
1628 #
1629 AC_DEFUN([FP_CHECK_TIMER_CREATE],[
1630 AC_CHECK_FUNC([timer_create],[HAVE_timer_create=yes],[HAVE_timer_create=no])
1631
1632 if test "$HAVE_timer_create" = "yes"
1633 then
1634   if test "$cross_compiling" = "yes"
1635   then
1636     # We can't test timer_create when we're cross-compiling, so we
1637     # optimistiaclly assume that it actually works properly.
1638     AC_DEFINE([USE_TIMER_CREATE], 1,  [Define to 1 if we can use timer_create(CLOCK_PROCESS_CPUTIME_ID,...)])
1639   else
1640   AC_CACHE_CHECK([for a working timer_create(CLOCK_REALTIME)],
1641     [fptools_cv_timer_create_works],
1642     [AC_TRY_RUN([
1643 #include <stdio.h>
1644 #ifdef HAVE_STDLIB_H
1645 #include <stdlib.h>
1646 #endif
1647 #ifdef HAVE_TIME_H
1648 #include <time.h>
1649 #endif
1650 #ifdef HAVE_SIGNAL_H
1651 #include <signal.h>
1652 #endif
1653 #ifdef HAVE_UNISTD_H
1654 #include <unistd.h>
1655 #endif
1656
1657 static volatile int tock = 0;
1658 static void handler(int i)
1659 {
1660    tock = 1;
1661 }
1662
1663 static void timeout(int i)
1664 {
1665   // timer_settime() has been known to hang, so just in case
1666   // we install a 1-second timeout (see #2257)
1667   exit(99);
1668 }
1669
1670 int main(int argc, char *argv[])
1671 {
1672
1673     struct sigevent ev;
1674     timer_t timer;
1675     struct itimerspec it;
1676     struct sigaction action;
1677     int m,n,count = 0;
1678
1679     ev.sigev_notify = SIGEV_SIGNAL;
1680     ev.sigev_signo  = SIGVTALRM;
1681
1682     action.sa_handler = handler;
1683     action.sa_flags = 0;
1684     sigemptyset(&action.sa_mask);
1685     if (sigaction(SIGVTALRM, &action, NULL) == -1) {
1686         fprintf(stderr,"SIGVTALRM problem\n");
1687         exit(3);
1688     }
1689
1690     action.sa_handler = timeout;
1691     action.sa_flags = 0;
1692     sigemptyset(&action.sa_mask);
1693     if (sigaction(SIGALRM, &action, NULL) == -1) {
1694       fprintf(stderr,"SIGALRM problem\n");
1695       exit(3);
1696     }
1697     alarm(1);
1698
1699     if (timer_create(CLOCK_PROCESS_CPUTIME_ID, &ev, &timer) != 0) {
1700         fprintf(stderr,"No CLOCK_PROCESS_CPUTIME_ID timer\n");
1701        exit(1);
1702     }
1703
1704     it.it_value.tv_sec = 0;
1705     it.it_value.tv_nsec = 1;
1706     it.it_interval = it.it_value;
1707     if (timer_settime(timer, 0, &it, NULL) != 0) {
1708         fprintf(stderr,"settime problem\n");
1709         exit(4);
1710     }
1711
1712     tock = 0;
1713
1714     for(n = 3; n < 20000; n++){
1715         for(m = 2; m <= n/2; m++){
1716             if (!(n%m)) count++;
1717             if (tock) goto out;
1718         }
1719     }
1720 out:
1721
1722     if (!tock) {
1723         fprintf(stderr,"no CLOCK_PROCESS_CPUTIME_ID signal\n");
1724         exit(5);
1725     }
1726
1727     timer_delete(timer);
1728
1729     if (timer_create(CLOCK_REALTIME, &ev, &timer) != 0) {
1730         fprintf(stderr,"No CLOCK_REALTIME timer\n");
1731         exit(2);
1732     }
1733
1734     it.it_value.tv_sec = 0;
1735     it.it_value.tv_nsec = 1000000;
1736     it.it_interval = it.it_value;
1737     if (timer_settime(timer, 0, &it, NULL) != 0) {
1738         fprintf(stderr,"settime problem\n");
1739         exit(4);
1740     }
1741
1742     tock = 0;
1743
1744     usleep(3000);
1745
1746     if (!tock) {
1747         fprintf(stderr,"no CLOCK_REALTIME signal\n");
1748         exit(5);
1749     }
1750
1751     timer_delete(timer);
1752
1753     exit(0);
1754 }
1755      ],
1756      [fptools_cv_timer_create_works=yes],
1757      [fptools_cv_timer_create_works=no])
1758   ])
1759 case $fptools_cv_timer_create_works in
1760     yes) AC_DEFINE([USE_TIMER_CREATE], 1,
1761                    [Define to 1 if we can use timer_create(CLOCK_PROCESS_CPUTIME_ID,...)]);;
1762 esac
1763   fi
1764 fi
1765 ])
1766
1767 # FP_ICONV
1768 # -------------
1769 AC_DEFUN([FP_ICONV],
1770 [
1771   dnl--------------------------------------------------------------------
1772   dnl * Deal with arguments telling us iconv is somewhere odd
1773   dnl--------------------------------------------------------------------
1774
1775   dnl Note: ICONV_LIB_DIRS and ICONV_INCLUDE_DIRS are not predefined
1776   dnl to the empty string to allow them to be overridden from the
1777   dnl environment.
1778
1779   AC_ARG_WITH([iconv-includes],
1780     [AC_HELP_STRING([--with-iconv-includes],
1781       [directory containing iconv.h])],
1782       [ICONV_INCLUDE_DIRS=$withval])
1783
1784   AC_ARG_WITH([iconv-libraries],
1785     [AC_HELP_STRING([--with-iconv-libraries],
1786       [directory containing iconv library])],
1787       [ICONV_LIB_DIRS=$withval])
1788
1789   AC_SUBST(ICONV_INCLUDE_DIRS)
1790   AC_SUBST(ICONV_LIB_DIRS)
1791 ])# FP_ICONV
1792
1793 # FP_GMP
1794 # -------------
1795 AC_DEFUN([FP_GMP],
1796 [
1797   dnl--------------------------------------------------------------------
1798   dnl * Deal with arguments telling us gmp is somewhere odd
1799   dnl--------------------------------------------------------------------
1800
1801   AC_ARG_WITH([gmp-includes],
1802     [AC_HELP_STRING([--with-gmp-includes],
1803       [directory containing gmp.h])],
1804       [GMP_INCLUDE_DIRS=$withval])
1805
1806   AC_ARG_WITH([gmp-libraries],
1807     [AC_HELP_STRING([--with-gmp-libraries],
1808       [directory containing gmp library])],
1809       [GMP_LIB_DIRS=$withval])
1810
1811   AC_SUBST(GMP_INCLUDE_DIRS)
1812   AC_SUBST(GMP_LIB_DIRS)
1813 ])# FP_GMP
1814
1815 # --------------------------------------------------------------
1816 # Calculate absolute path to build tree
1817 # --------------------------------------------------------------
1818
1819 AC_DEFUN([FP_INTREE_GHC_PWD],[
1820 AC_MSG_NOTICE(Building in-tree ghc-pwd)
1821     dnl This would be
1822     dnl     make -C utils/ghc-pwd clean && make -C utils/ghc-pwd
1823     dnl except we don't want to have to know what make is called. Sigh.
1824     rm -rf utils/ghc-pwd/dist-boot
1825     mkdir  utils/ghc-pwd/dist-boot
1826     dnl If special linker flags are needed to build things, then allow
1827     dnl the user to pass them in via LDFLAGS.
1828     changequote(, )dnl
1829     GHC_LDFLAGS=`echo $LDFLAGS | sed 's/\(^\| \)\([^ ]\)/\1-optl\2/g'`
1830     changequote([, ])dnl
1831     if ! "$WithGhc" $GHC_LDFLAGS -v0 -no-user-$GHC_PACKAGE_DB_FLAG -hidir utils/ghc-pwd/dist-boot -odir utils/ghc-pwd/dist-boot -stubdir utils/ghc-pwd/dist-boot --make utils/ghc-pwd/Main.hs -o utils/ghc-pwd/dist-boot/ghc-pwd
1832     then
1833         AC_MSG_ERROR([Building ghc-pwd failed])
1834     fi
1835
1836     GHC_PWD=utils/ghc-pwd/dist-boot/ghc-pwd
1837 ])
1838
1839 AC_DEFUN([FP_BINDIST_GHC_PWD],[
1840     GHC_PWD=utils/ghc-pwd/dist-install/build/tmp/ghc-pwd-bindist
1841 ])
1842
1843 AC_DEFUN([FP_FIND_ROOT],[
1844 AC_MSG_CHECKING(for path to top of build tree)
1845     hardtop=`$GHC_PWD`
1846
1847     dnl Remove common automounter nonsense
1848     hardtop=`echo $hardtop | sed 's|^/tmp_mnt.*\(/local/.*\)$|\1|' | sed 's|^/tmp_mnt/|/|'`
1849
1850     if ! test -d "$hardtop"; then
1851         AC_MSG_ERROR([cannot determine current directory])
1852     fi
1853
1854     dnl We don't support building in directories with spaces.
1855     case "$hardtop" in
1856     *' '*)
1857         AC_MSG_ERROR([
1858         The build system does not support building in a directory
1859         containing space characters.
1860         Suggestion: move the build tree somewhere else.])
1861         ;;
1862     esac
1863
1864     AC_SUBST(hardtop)
1865
1866     AC_MSG_RESULT($hardtop)
1867 ])
1868
1869 # GHC_CONVERT_CPU(cpu, target_var)
1870 # --------------------------------
1871 # converts cpu from gnu to ghc naming, and assigns the result to $target_var
1872 AC_DEFUN([GHC_CONVERT_CPU],[
1873 case "$1" in
1874   aarch64*)
1875     $2="aarch64"
1876     ;;
1877   alpha*)
1878     $2="alpha"
1879     ;;
1880   arm*)
1881     $2="arm"
1882     ;;
1883   hppa1.1*)
1884     $2="hppa1_1"
1885     ;;
1886   hppa*)
1887     $2="hppa"
1888     ;;
1889   i386|i486|i586|i686)
1890     $2="i386"
1891     ;;
1892   ia64)
1893     $2="ia64"
1894     ;;
1895   m68k*)
1896     $2="m68k"
1897     ;;
1898   mipseb*)
1899     $2="mipseb"
1900     ;;
1901   mipsel*)
1902     $2="mipsel"
1903     ;;
1904   mips*)
1905     $2="mips"
1906     ;;
1907   powerpc64le*)
1908     $2="powerpc64le"
1909     ;;
1910   powerpc64*)
1911     $2="powerpc64"
1912     ;;
1913   powerpc*)
1914     $2="powerpc"
1915     ;;
1916   rs6000)
1917     $2="rs6000"
1918     ;;
1919   s390x*)
1920     $2="s390x"
1921     ;;
1922   s390*)
1923     $2="s390"
1924     ;;
1925   sparc64*)
1926     $2="sparc64"
1927     ;;
1928   sparc*)
1929     $2="sparc"
1930     ;;
1931   vax)
1932     $2="vax"
1933     ;;
1934   x86_64|amd64)
1935     $2="x86_64"
1936     ;;
1937   *)
1938     echo "Unknown CPU $1"
1939     exit 1
1940     ;;
1941   esac
1942 ])
1943
1944 # GHC_CONVERT_VENDOR(vendor, target_var)
1945 # --------------------------------
1946 # converts vendor from gnu to ghc naming, and assigns the result to $target_var
1947 AC_DEFUN([GHC_CONVERT_VENDOR],[
1948   case "$1" in
1949   pc|gentoo|w64) # like i686-pc-linux-gnu, i686-gentoo-freebsd8, x86_64-w64-mingw32
1950     $2="unknown"
1951     ;;
1952   softfloat) # like armv5tel-softfloat-linux-gnueabi
1953     $2="unknown"
1954     ;;
1955   *)
1956     #pass thru by default
1957     $2="$1"
1958     ;;
1959   esac
1960 ])
1961
1962 # GHC_CONVERT_OS(os, converted_cpu, target_var)
1963 # --------------------------------
1964 # converts os from gnu to ghc naming, and assigns the result to $target_var
1965 AC_DEFUN([GHC_CONVERT_OS],[
1966 case "$1-$2" in
1967   darwin10-arm|darwin11-i386)
1968     $3="ios"
1969     ;;
1970   *)
1971     case "$1" in
1972       linux-android*)
1973         $3="linux-android"
1974         ;;
1975       linux-*|linux)
1976         $3="linux"
1977         ;;
1978       # As far as I'm aware, none of these have relevant variants
1979       freebsd|netbsd|openbsd|dragonfly|osf1|osf3|hpux|linuxaout|kfreebsdgnu|freebsd2|solaris2|cygwin32|mingw32|darwin|gnu|nextstep2|nextstep3|sunos4|ultrix|irix|aix|haiku)
1980         $3="$1"
1981         ;;
1982       freebsd*) # like i686-gentoo-freebsd7
1983                 #      i686-gentoo-freebsd8
1984                 #      i686-gentoo-freebsd8.2
1985         $3="freebsd"
1986         ;;
1987       nto-qnx*)
1988         $3="nto-qnx"
1989         ;;
1990       *)
1991         echo "Unknown OS $1"
1992         exit 1
1993         ;;
1994       esac
1995       ;;
1996   esac
1997 ])
1998
1999 # BOOTSTRAPPING_GHC_INFO_FIELD
2000 # --------------------------------
2001 # Set the variable $1 to the value of the ghc --info field $2.
2002 AC_DEFUN([BOOTSTRAPPING_GHC_INFO_FIELD],[
2003 $1=`"$WithGhc" --info | grep "^ ,(\"$2\"," | sed -e 's/.*","//' -e 's/")$//'`
2004 tmp=${$1#\$topdir/}
2005 if test "${$1}" != "$tmp"
2006 then
2007     topdir=`"$WithGhc" --print-libdir | sed 's#\\\\#/#g'`
2008     $1="$topdir/$tmp"
2009 fi
2010 AC_SUBST($1)
2011 ])
2012
2013 # LIBRARY_VERSION(lib, [dir])
2014 # --------------------------------
2015 # Gets the version number of a library.
2016 # If $1 is ghc-prim, then we define LIBRARY_ghc_prim_VERSION as 1.2.3
2017 # $2 points to the directory under libraries/
2018 AC_DEFUN([LIBRARY_VERSION],[
2019 dir=m4_default([$2],[$1])
2020 LIBRARY_[]translit([$1], [-], [_])[]_VERSION=`grep -i "^version:" libraries/${dir}/$1.cabal | sed "s/.* //"`
2021 AC_SUBST(LIBRARY_[]translit([$1], [-], [_])[]_VERSION)
2022 ])
2023
2024 # XCODE_VERSION()
2025 # --------------------------------
2026 # Gets the version number of XCode, if on a Mac
2027 AC_DEFUN([XCODE_VERSION],[
2028     if test "$TargetOS_CPP" = "darwin"
2029     then
2030         AC_MSG_CHECKING(XCode version)
2031         XCodeVersion=`xcodebuild -version | grep Xcode | sed "s/Xcode //"`
2032         # Old XCode versions don't actually give the XCode version
2033         if test "$XCodeVersion" = ""
2034         then
2035             AC_MSG_RESULT(not found (too old?))
2036             XCodeVersion1=0
2037             XCodeVersion2=0
2038         else
2039             AC_MSG_RESULT($XCodeVersion)
2040             XCodeVersion1=`echo "$XCodeVersion" | sed 's/\..*//'`
2041             changequote(, )dnl
2042             XCodeVersion2=`echo "$XCodeVersion" | sed 's/[^.]*\.\([^.]*\).*/\1/'`
2043             changequote([, ])dnl
2044             AC_MSG_NOTICE(XCode version component 1: $XCodeVersion1)
2045             AC_MSG_NOTICE(XCode version component 2: $XCodeVersion2)
2046         fi
2047     fi
2048 ])
2049
2050 # FIND_LLVM_PROG()
2051 # --------------------------------
2052 # Find where the llvm tools are. We have a special function to handle when they
2053 # are installed with a version suffix (e.g., llc-3.1).
2054 #
2055 # $1 = the variable to set
2056 # $2 = the with option name
2057 # $3 = the command to look for
2058 #
2059 AC_DEFUN([FIND_LLVM_PROG],[
2060     FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL([$1], [$2], [$3])
2061     if test "$$1" == ""; then
2062         save_IFS=$IFS
2063         IFS=":;"
2064         for p in ${PATH}; do
2065             if test -d "${p}"; then
2066                 $1=`${FindCmd} "${p}" -type f -perm +111 -maxdepth 1 -regex '.*/$3-[[0-9]]\.[[0-9]]' -or -type l -perm +111 -maxdepth 1 -regex '.*/$3-[[0-9]]\.[[0-9]]' | ${SortCmd} -n | tail -1`
2067                 if test -n "$$1"; then
2068                     break
2069                 fi
2070             fi
2071         done
2072         IFS=$save_IFS
2073     fi
2074 ])
2075
2076 # FIND_GCC()
2077 # --------------------------------
2078 # Finds where gcc is
2079 #
2080 # $1 = the variable to set
2081 # $2 = the with option name
2082 # $3 = the command to look for
2083 AC_DEFUN([FIND_GCC],[
2084     if test "$TargetOS_CPP" = "darwin" &&
2085        test "$XCodeVersion1" -eq 4 &&
2086        test "$XCodeVersion2" -lt 2
2087     then
2088         # In Xcode 4.1, 'gcc-4.2' is the gcc legacy backend (rather
2089         # than the LLVM backend). We prefer the legacy gcc, but in
2090         # Xcode 4.2 'gcc-4.2' was removed.
2091         FP_ARG_WITH_PATH_GNU_PROG([$1], [gcc-4.2], [gcc-4.2])
2092     elif test "$windows" = YES
2093     then
2094         $1="$CC"
2095     else
2096         FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL([$1], [$2], [$3])
2097         # From Xcode 5 on, OS X command line tools do not include gcc
2098         # anymore. Use clang.
2099         if test -z "$$1"
2100         then
2101             FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL([$1], [clang], [clang])
2102         fi
2103         if test -z "$$1"
2104         then
2105             AC_MSG_ERROR([cannot find $3 nor clang in your PATH])
2106         fi
2107     fi
2108     AC_SUBST($1)
2109 ])
2110
2111 AC_DEFUN([MAYBE_OVERRIDE_STAGE0],[
2112   if test ! -z "$With_$1" -a "$CrossCompiling" != "YES"; then
2113       AC_MSG_NOTICE([Not cross-compiling, so --with-$1 also sets $2])
2114       $2=$With_$1
2115   fi
2116 ])
2117
2118
2119
2120 # LocalWords:  fi