LLVM generate llvm.expect for conditional branches
[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|aarch64-apple-darwin14|x86_64-apple-darwin14)
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 {ppc_64ABI = ELF_V1}\""
192             ;;
193         powerpc64le)
194             test -z "[$]2" || eval "[$]2=\"ArchPPC_64 {ppc_64ABI = ELF_V2}\""
195             ;;
196         sparc)
197             test -z "[$]2" || eval "[$]2=ArchSPARC"
198             ;;
199         sparc64)
200             test -z "[$]2" || eval "[$]2=ArchSPARC64"
201             ;;
202         arm)
203             GET_ARM_ISA()
204             test -z "[$]2" || eval "[$]2=\"ArchARM {armISA = \$ARM_ISA, armISAExt = \$ARM_ISA_EXT, armABI = \$ARM_ABI}\""
205             ;;
206         aarch64)
207             test -z "[$]2" || eval "[$]2=ArchARM64"
208             ;;
209         alpha)
210             test -z "[$]2" || eval "[$]2=ArchAlpha"
211             ;;
212         mips|mipseb)
213             test -z "[$]2" || eval "[$]2=ArchMipseb"
214             ;;
215         mipsel)
216             test -z "[$]2" || eval "[$]2=ArchMipsel"
217             ;;
218         hppa|hppa1_1|ia64|m68k|rs6000|s390|s390x|sh4|vax)
219             test -z "[$]2" || eval "[$]2=ArchUnknown"
220             ;;
221         *)
222             echo "Unknown arch [$]1"
223             exit 1
224             ;;
225         esac
226     }
227
228     checkVendor() {
229         case [$]1 in
230         dec|unknown|hp|apple|next|sun|sgi|ibm|montavista|portbld)
231             ;;
232         *)
233             echo "Unknown vendor [$]1"
234             exit 1
235             ;;
236         esac
237     }
238
239     checkOS() {
240         case [$]1 in
241         linux)
242             test -z "[$]2" || eval "[$]2=OSLinux"
243             ;;
244         ios)
245             test -z "[$]2" || eval "[$]2=OSiOS"
246             ;;
247         darwin)
248             test -z "[$]2" || eval "[$]2=OSDarwin"
249             ;;
250         solaris2)
251             test -z "[$]2" || eval "[$]2=OSSolaris2"
252             ;;
253         mingw32)
254             test -z "[$]2" || eval "[$]2=OSMinGW32"
255             ;;
256         freebsd)
257             test -z "[$]2" || eval "[$]2=OSFreeBSD"
258             ;;
259         dragonfly)
260             test -z "[$]2" || eval "[$]2=OSDragonFly"
261             ;;
262         kfreebsdgnu)
263             test -z "[$]2" || eval "[$]2=OSKFreeBSD"
264             ;;
265         openbsd)
266             test -z "[$]2" || eval "[$]2=OSOpenBSD"
267             ;;
268         netbsd)
269             test -z "[$]2" || eval "[$]2=OSNetBSD"
270             ;;
271         haiku)
272             test -z "[$]2" || eval "[$]2=OSHaiku"
273             ;;
274         nto-qnx)
275             test -z "[$]2" || eval "[$]2=OSQNXNTO"
276             ;;
277         dragonfly|hpux|linuxaout|freebsd2|gnu|nextstep2|nextstep3|sunos4|ultrix)
278             test -z "[$]2" || eval "[$]2=OSUnknown"
279             ;;
280         aix)
281             test -z "[$]2" || eval "[$]2=OSAIX"
282             ;;
283         linux-android)
284             test -z "[$]2" || eval "[$]2=OSAndroid"
285             ;;
286         *)
287             echo "Unknown OS '[$]1'"
288             exit 1
289             ;;
290         esac
291     }
292
293     dnl ** check for Apple-style dead-stripping support
294     dnl    (.subsections-via-symbols assembler directive)
295
296     AC_MSG_CHECKING(for .subsections_via_symbols)
297     AC_COMPILE_IFELSE(
298         [AC_LANG_PROGRAM([], [__asm__ (".subsections_via_symbols");])],
299         [AC_MSG_RESULT(yes)
300          HaskellHaveSubsectionsViaSymbols=True
301          AC_DEFINE([HAVE_SUBSECTIONS_VIA_SYMBOLS],[1],
302                    [Define to 1 if Apple-style dead-stripping is supported.])
303         ],
304         [HaskellHaveSubsectionsViaSymbols=False
305          AC_MSG_RESULT(no)])
306
307     dnl ** check for .ident assembler directive
308
309     AC_MSG_CHECKING(whether your assembler supports .ident directive)
310     AC_COMPILE_IFELSE(
311         [AC_LANG_SOURCE([__asm__ (".ident \"GHC x.y.z\"");])],
312         [AC_MSG_RESULT(yes)
313          HaskellHaveIdentDirective=True],
314         [AC_MSG_RESULT(no)
315          HaskellHaveIdentDirective=False])
316
317     dnl *** check for GNU non-executable stack note support (ELF only)
318     dnl     (.section .note.GNU-stack,"",@progbits)
319
320     dnl This test doesn't work with "gcc -g" in gcc 4.4 (GHC trac #3889:
321     dnl     Error: can't resolve `.note.GNU-stack' {.note.GNU-stack section} - `.Ltext0' {.text section}
322     dnl so we empty CFLAGS while running this test
323     CFLAGS2="$CFLAGS"
324     CFLAGS=
325     AC_MSG_CHECKING(for GNU non-executable stack support)
326     AC_COMPILE_IFELSE(
327         [AC_LANG_PROGRAM([__asm__ (".section .note.GNU-stack,\"\",@progbits");], [0])],
328         [AC_MSG_RESULT(yes)
329          HaskellHaveGnuNonexecStack=True],
330         [AC_MSG_RESULT(no)
331          HaskellHaveGnuNonexecStack=False])
332     CFLAGS="$CFLAGS2"
333
334     checkArch "$BuildArch" "HaskellBuildArch"
335     checkVendor "$BuildVendor"
336     checkOS "$BuildOS" ""
337
338     checkArch "$HostArch" "HaskellHostArch"
339     checkVendor "$HostVendor"
340     checkOS "$HostOS" ""
341
342     checkArch "$TargetArch" "HaskellTargetArch"
343     checkVendor "$TargetVendor"
344     checkOS "$TargetOS" "HaskellTargetOs"
345
346     AC_SUBST(HaskellTargetArch)
347     AC_SUBST(HaskellTargetOs)
348     AC_SUBST(HaskellHaveSubsectionsViaSymbols)
349     AC_SUBST(HaskellHaveIdentDirective)
350     AC_SUBST(HaskellHaveGnuNonexecStack)
351 ])
352
353
354 # GET_ARM_ISA
355 # ----------------------------------
356 # Get info about the ISA on the ARM arch
357 AC_DEFUN([GET_ARM_ISA],
358 [
359     AC_COMPILE_IFELSE([
360         AC_LANG_PROGRAM(
361             [],
362             [#if defined(__ARM_ARCH_2__)  || \
363                  defined(__ARM_ARCH_3__)  || \
364                  defined(__ARM_ARCH_3M__) || \
365                  defined(__ARM_ARCH_4__)  || \
366                  defined(__ARM_ARCH_4T__) || \
367                  defined(__ARM_ARCH_5__)  || \
368                  defined(__ARM_ARCH_5T__) || \
369                  defined(__ARM_ARCH_5E__) || \
370                  defined(__ARM_ARCH_5TE__)
371                  return 0;
372              #else
373                  not pre arm v6
374              #endif]
375         )],
376         [AC_DEFINE(arm_HOST_ARCH_PRE_ARMv6, 1, [ARM pre v6])
377          AC_DEFINE(arm_HOST_ARCH_PRE_ARMv7, 1, [ARM pre v7])
378          changequote(, )dnl
379          ARM_ISA=ARMv5
380          ARM_ISA_EXT="[]"
381          changequote([, ])dnl
382         ],
383         [
384             AC_COMPILE_IFELSE([
385                 AC_LANG_PROGRAM(
386                     [],
387                     [#if defined(__ARM_ARCH_6__)   || \
388                          defined(__ARM_ARCH_6J__)  || \
389                          defined(__ARM_ARCH_6T2__) || \
390                          defined(__ARM_ARCH_6Z__)  || \
391                          defined(__ARM_ARCH_6ZK__) || \
392                          defined(__ARM_ARCH_6M__)
393                          return 0;
394                      #else
395                          not pre arm v7
396                      #endif]
397                 )],
398                 [AC_DEFINE(arm_HOST_ARCH_PRE_ARMv7, 1, [ARM pre v7])
399                  ARM_ISA=ARMv6
400                  AC_COMPILE_IFELSE([
401                         AC_LANG_PROGRAM(
402                                 [],
403                                 [#if defined(__VFP_FP__)
404                                      return 0;
405                                 #else
406                                      no vfp
407                                 #endif]
408                         )],
409                         [changequote(, )dnl
410                          ARM_ISA_EXT="[VFPv2]"
411                          changequote([, ])dnl
412                         ],
413                         [changequote(, )dnl
414                          ARM_ISA_EXT="[]"
415                          changequote([, ])dnl
416                         ]
417                 )],
418                 [changequote(, )dnl
419                  ARM_ISA=ARMv7
420                  ARM_ISA_EXT="[VFPv3,NEON]"
421                  changequote([, ])dnl
422                 ])
423         ])
424
425         AC_COMPILE_IFELSE(
426                [AC_LANG_PROGRAM(
427                        [],
428                        [#if defined(__SOFTFP__)
429                             return 0;
430                        #else
431                             not softfp
432                        #endif]
433                )],
434                [changequote(, )dnl
435                 ARM_ABI="SOFT"
436                 changequote([, ])dnl
437                ],
438                [AC_COMPILE_IFELSE(
439                     [AC_LANG_PROGRAM(
440                        [],
441                        [#if defined(__ARM_PCS_VFP)
442                             return 0;
443                        #else
444                             no hard float ABI
445                        #endif]
446                     )],
447                     [ARM_ABI="HARD"],
448                     [ARM_ABI="SOFTFP"]
449                )]
450         )
451
452         AC_SUBST(ARM_ISA)
453 ])
454
455
456 # FP_SETTINGS
457 # ----------------------------------
458 # Set the variables used in the settings file
459 AC_DEFUN([FP_SETTINGS],
460 [
461     SettingsCCompilerCommand="$CC"
462     SettingsHaskellCPPCommand="$HaskellCPPCmd"
463     SettingsHaskellCPPFlags="$HaskellCPPArgs"
464     SettingsLdCommand="$LdCmd"
465     SettingsArCommand="$ArCmd"
466     SettingsPerlCommand="$PerlCmd"
467
468     if test -z "$DllWrap"
469     then
470         SettingsDllWrapCommand="/bin/false"
471     else
472         SettingsDllWrapCommand="$DllWrap"
473     fi
474
475     if test -z "$Windres"
476     then
477         SettingsWindresCommand="/bin/false"
478     else
479         SettingsWindresCommand="$Windres"
480     fi
481
482     if test -z "$Libtool"
483     then
484         SettingsLibtoolCommand="libtool"
485     else
486         SettingsLibtoolCommand="$Libtool"
487     fi
488
489     if test -z "$Touch"
490     then
491         SettingsTouchCommand='touch'
492     else
493         SettingsTouchCommand='$Touch'
494     fi
495
496     if test -z "$LlcCmd"
497     then
498       SettingsLlcCommand="llc"
499     else
500       SettingsLlcCommand="$LlcCmd"
501     fi
502
503     if test -z "$OptCmd"
504     then
505       SettingsOptCommand="opt"
506     else
507       SettingsOptCommand="$OptCmd"
508     fi
509
510     SettingsCCompilerFlags="$CONF_CC_OPTS_STAGE2"
511     SettingsCCompilerLinkFlags="$CONF_GCC_LINKER_OPTS_STAGE2"
512     SettingsCCompilerSupportsNoPie="$CONF_GCC_SUPPORTS_NO_PIE"
513     SettingsLdFlags="$CONF_LD_LINKER_OPTS_STAGE2"
514     AC_SUBST(SettingsCCompilerCommand)
515     AC_SUBST(SettingsHaskellCPPCommand)
516     AC_SUBST(SettingsHaskellCPPFlags)
517     AC_SUBST(SettingsCCompilerFlags)
518     AC_SUBST(SettingsCCompilerLinkFlags)
519     AC_SUBST(SettingsCCompilerSupportsNoPie)
520     AC_SUBST(SettingsLdCommand)
521     AC_SUBST(SettingsLdFlags)
522     AC_SUBST(SettingsArCommand)
523     AC_SUBST(SettingsPerlCommand)
524     AC_SUBST(SettingsDllWrapCommand)
525     AC_SUBST(SettingsWindresCommand)
526     AC_SUBST(SettingsLibtoolCommand)
527     AC_SUBST(SettingsTouchCommand)
528     AC_SUBST(SettingsLlcCommand)
529     AC_SUBST(SettingsOptCommand)
530 ])
531
532 # Helper for cloning a shell variable's state
533 AC_DEFUN([FP_COPY_SHELLVAR],
534 [if test -n "${$1+set}"; then $2="$$1"; else unset $2; fi ])
535
536 # FP_SET_CFLAGS_C99
537 # ----------------------------------
538 # figure out which CFLAGS are needed to place the compiler into C99 mode
539 # $1 is name of CC variable (unmodified)
540 # $2 is name of CC flags variable (augmented if needed)
541 # $3 is name of CPP flags variable (augmented if needed)
542 AC_DEFUN([FP_SET_CFLAGS_C99],
543 [
544     dnl save current state of AC_PROG_CC_C99
545     FP_COPY_SHELLVAR([CC],[fp_save_CC])
546     FP_COPY_SHELLVAR([CFLAGS],[fp_save_CFLAGS])
547     FP_COPY_SHELLVAR([CPPFLAGS],[fp_save_CPPFLAGS])
548     FP_COPY_SHELLVAR([ac_cv_prog_cc_c99],[fp_save_cc_c99])
549     dnl set local state
550     CC="$$1"
551     CFLAGS="$$2"
552     CPPFLAGS="$$3"
553     unset ac_cv_prog_cc_c99
554     dnl perform detection
555     _AC_PROG_CC_C99
556     fp_cc_c99="$ac_cv_prog_cc_c99"
557     case "x$ac_cv_prog_cc_c99" in
558       x)   ;; # noop
559       xno) AC_MSG_ERROR([C99-compatible compiler needed]) ;;
560       *)   $2="$$2 $ac_cv_prog_cc_c99"
561            $3="$$3 $ac_cv_prog_cc_c99"
562            ;;
563     esac
564     dnl restore saved state
565     FP_COPY_SHELLVAR([fp_save_CC],[CC])
566     FP_COPY_SHELLVAR([fp_save_CFLAGS],[CFLAGS])
567     FP_COPY_SHELLVAR([fp_save_CPPFLAGS],[CPPFLAGS])
568     FP_COPY_SHELLVAR([fp_save_cc_c99],[ac_cv_prog_cc_c99])
569     dnl cleanup
570     unset fp_save_CC
571     unset fp_save_CFLAGS
572     unset fp_save_cc_c99
573 ])
574
575 # FPTOOLS_SET_C_LD_FLAGS
576 # ----------------------------------
577 # Set the C, LD and CPP flags for a given platform
578 # $1 is the platform
579 # $2 is the name of the CC flags variable
580 # $3 is the name of the linker flags variable when linking with gcc
581 # $4 is the name of the linker flags variable when linking with ld
582 # $5 is the name of the CPP flags variable
583 AC_DEFUN([FPTOOLS_SET_C_LD_FLAGS],
584 [
585     AC_MSG_CHECKING([Setting up $2, $3, $4 and $5])
586     case $$1 in
587     i386-*)
588         # Workaround for #7799
589         $2="$$2 -U__i686"
590         ;;
591     esac
592
593     case $$1 in
594     i386-unknown-mingw32)
595         $2="$$2 -march=i686"
596         ;;
597     i386-portbld-freebsd*)
598         $2="$$2 -march=i686"
599         ;;
600     i386-apple-darwin)
601         $2="$$2 -m32"
602         $3="$$3 -m32"
603         $4="$$4 -arch i386"
604         $5="$$5 -m32"
605         ;;
606     x86_64-apple-darwin)
607         $2="$$2 -m64"
608         $3="$$3 -m64"
609         $4="$$4 -arch x86_64"
610         $5="$$5 -m64"
611         ;;
612     x86_64-unknown-solaris2)
613         $2="$$2 -m64"
614         $3="$$3 -m64"
615         $4="$$4 -m64"
616         $5="$$5 -m64"
617         ;;
618     alpha-*)
619         # For now, to suppress the gcc warning "call-clobbered
620         # register used for global register variable", we simply
621         # disable all warnings altogether using the -w flag. Oh well.
622         $2="$$2 -w -mieee -D_REENTRANT"
623         $3="$$3 -w -mieee -D_REENTRANT"
624         $5="$$5 -w -mieee -D_REENTRANT"
625         ;;
626     hppa*)
627         # ___HPUX_SOURCE, not _HPUX_SOURCE, is #defined if -ansi!
628         # (very nice, but too bad the HP /usr/include files don't agree.)
629         $2="$$2 -D_HPUX_SOURCE"
630         $3="$$3 -D_HPUX_SOURCE"
631         $5="$$5 -D_HPUX_SOURCE"
632         ;;
633     arm*linux*)
634         # On arm/linux and arm/android, tell gcc to generate Arm
635         # instructions (ie not Thumb) and to link using the gold linker.
636         # Forcing LD to be ld.gold is done in FIND_LD m4 macro.
637         $2="$$2 -marm"
638         $3="$$3 -fuse-ld=gold -Wl,-z,noexecstack"
639         $4="$$4 -z noexecstack"
640         ;;
641
642     aarch64*linux*)
643         # On aarch64/linux and aarch64/android, tell gcc to link using the
644         # gold linker.
645         # Forcing LD to be ld.gold is done in FIND_LD m4 macro.
646         $3="$$3 -fuse-ld=gold -Wl,-z,noexecstack"
647         $4="$$4 -z noexecstack"
648         ;;
649
650     powerpc-ibm-aix*)
651         # We need `-D_THREAD_SAFE` to unlock the thread-local `errno`.
652         $2="$$2 -D_THREAD_SAFE"
653         $3="$$3 -D_THREAD_SAFE -Wl,-bnotextro"
654         $4="$$4 -bnotextro"
655         $5="$$5 -D_THREAD_SAFE"
656         ;;
657
658     x86_64-*-openbsd*)
659         # We need -z wxneeded at least to link ghc-stage2 to workaround
660         # W^X issue in GHCi on OpenBSD current (as of Aug 2016)
661         $3="$$3 -Wl,-zwxneeded"
662         $4="$$4 -z wxneeded"
663         ;;
664
665     esac
666
667     # If gcc knows about the stack protector, turn it off.
668     # Otherwise the stack-smash handler gets triggered.
669     echo 'int main(void) {return 0;}' > conftest.c
670     if $CC -c conftest.c -fno-stack-protector > /dev/null 2>&1
671     then
672         $2="$$2 -fno-stack-protector"
673     fi
674
675     rm -f conftest.c conftest.o
676     AC_MSG_RESULT([done])
677 ])
678
679
680 # FP_VISIBILITY_HIDDEN
681 # ----------------------------------
682 # Is the visibility hidden attribute supported?
683 AC_DEFUN([FP_VISIBILITY_HIDDEN],
684 [
685     AC_MSG_CHECKING([whether __attribute__((visibility("hidden"))) is supported])
686     echo '__attribute__((visibility("hidden"))) void foo(void) {}' > conftest.c
687     if $CC -Wall -Werror -c conftest.c > /dev/null 2>&1
688     then
689         AC_MSG_RESULT([yes])
690         AC_DEFINE(HAS_VISIBILITY_HIDDEN, 1, [Has visibility hidden])
691     else
692         AC_MSG_RESULT([no])
693     fi
694     rm -f conftest.c conftest.o
695 ])
696
697
698 # FPTOOLS_FLOAT_WORD_ORDER_BIGENDIAN
699 # ----------------------------------
700 # Little endian ARM on Linux with some ABIs has big endian word order
701 # in doubles. Define FLOAT_WORDS_BIGENDIAN if this is the case.
702 AC_DEFUN([FPTOOLS_FLOAT_WORD_ORDER_BIGENDIAN],
703   [AC_CACHE_CHECK([whether float word order is big endian], [fptools_cv_float_word_order_bigendian],
704     [AC_COMPILE_IFELSE(
705       [AC_LANG_PROGRAM(
706         [#include <endian.h>],
707         [#if defined(__FLOAT_WORD_ORDER) && __FLOAT_WORD_ORDER == BIG_ENDIAN
708              return 0;
709          #else
710              not float word order big endian
711          #endif]
712       )],
713       [fptools_cv_float_word_order_bigendian=yes],
714       [fptools_cv_float_word_order_bigendian=no])
715     ])
716   case $fptools_cv_float_word_order_bigendian in
717       yes)
718           AC_DEFINE([FLOAT_WORDS_BIGENDIAN], 1,
719           [Define to 1 if your processor stores words of floats with
720            the most significant byte first]) ;;
721   esac
722 ])
723
724
725 # FP_ARG_WITH_PATH_GNU_PROG_GENERAL
726 # --------------------
727 # Find the specified command on the path or allow a user to set it manually
728 # with a --with-<command> option.
729 #
730 # This is ignored on the mingw32 platform.
731 #
732 # $1 = the variable to set
733 # $2 = the with option name
734 # $3 = the command to look for
735 # $4 = prepend target to program name? if 'no', use the name unchanged
736 # $5 = optional? if 'no', then raise an error if the command isn't found
737 #
738 AC_DEFUN([FP_ARG_WITH_PATH_GNU_PROG_GENERAL],
739 [
740 AC_ARG_WITH($2,
741 [AC_HELP_STRING([--with-$2=ARG],
742         [Use ARG as the path to $2 [default=autodetect]])],
743 [
744     if test "$HostOS" = "mingw32"
745     then
746         AC_MSG_WARN([Request to use $withval will be ignored])
747     else
748         $1=$withval
749     fi
750
751     # Remember that we set this manually.  Used to override CC_STAGE0
752     # and friends later, if we are not cross-compiling.
753     With_$2=$withval
754 ],
755 [
756     if test "$HostOS" != "mingw32"
757     then
758         if test "$4" = "no" -o "$target_alias" = "" ; then
759             AC_PATH_PROG([$1], [$3])
760         else
761             AC_PATH_PROG([$1], [$target_alias-$3])
762         fi
763         if test "$5" = "no" -a -z "$$1"
764         then
765             AC_MSG_ERROR([cannot find $3 in your PATH])
766         fi
767     fi
768 ]
769 )
770 ]) # FP_ARG_WITH_PATH_GNU_PROG_GENERAL
771
772
773 # FP_ARG_WITH_PATH_GNU_PROG
774 # --------------------
775 # The usual case: prepend the target, and the program is not optional.
776 AC_DEFUN([FP_ARG_WITH_PATH_GNU_PROG],
777 [FP_ARG_WITH_PATH_GNU_PROG_GENERAL([$1], [$2], [$3], [yes], [no])])
778
779 # FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL
780 # --------------------
781 # Same as FP_ARG_WITH_PATH_GNU_PROG but no error will be thrown if the command
782 # isn't found.
783 AC_DEFUN([FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL],
784 [FP_ARG_WITH_PATH_GNU_PROG_GENERAL([$1], [$2], [$3], [yes], [yes])])
785
786 # FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL_NOTARGET
787 # --------------------
788 # Same as FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL but don't prepend the target name
789 # (used for LLVM).
790 AC_DEFUN([FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL_NOTARGET],
791 [FP_ARG_WITH_PATH_GNU_PROG_GENERAL([$1], [$2], [$3], [no], [yes])])
792
793
794 # FP_PROG_CONTEXT_DIFF
795 # --------------------
796 # Figure out how to do context diffs. Sets the output variable ContextDiffCmd.
797 #
798 # Note: NeXTStep thinks diff'ing a file against itself is "trouble".
799 AC_DEFUN([FP_PROG_CONTEXT_DIFF],
800 [AC_CACHE_CHECK([for a working context diff], [fp_cv_context_diff],
801 [echo foo > conftest1
802 echo foo > conftest2
803 fp_cv_context_diff=no
804 for fp_var in '-U 1' '-u1' '-C 1' '-c1'
805 do
806   if diff $fp_var conftest1 conftest2 > /dev/null 2>&1; then
807     fp_cv_context_diff="diff $fp_var"
808     break
809   fi
810 done])
811 if test x"$fp_cv_context_diff" = xno; then
812    AC_MSG_ERROR([cannot figure out how to do context diffs])
813 fi
814 AC_SUBST(ContextDiffCmd, [$fp_cv_context_diff])
815 ])# FP_PROG_CONTEXT_DIFF
816
817
818 # FP_COMPUTE_INT(EXPRESSION, VARIABLE, INCLUDES, IF-FAILS)
819 # --------------------------------------------------------
820 # Assign VARIABLE the value of the compile-time EXPRESSION using INCLUDES for
821 # compilation. Execute IF-FAILS when unable to determine the value. Works for
822 # cross-compilation, too.
823 #
824 # Implementation note: We are lazy and use an internal autoconf macro, but it
825 # is supported in autoconf versions 2.50 up to the actual 2.57, so there is
826 # little risk.
827 AC_DEFUN([FP_COMPUTE_INT],
828 [_AC_COMPUTE_INT([$1], [$2], [$3], [$4])[]dnl
829 ])# FP_COMPUTE_INT
830
831
832 # FP_CHECK_ALIGNMENT(TYPE, [IGNORED], [INCLUDES = DEFAULT-INCLUDES])
833 # ------------------------------------------------------------------
834 # A variation of AC_CHECK_SIZEOF for computing the alignment restrictions of a
835 # given type. Defines ALIGNMENT_TYPE.
836 AC_DEFUN([FP_CHECK_ALIGNMENT],
837 [AS_LITERAL_IF(m4_translit([[$1]], [*], [p]), [],
838                [AC_FATAL([$0: requires literal arguments])])[]dnl
839 AC_CHECK_TYPE([$1], [], [], [$3])[]dnl
840 m4_pushdef([fp_Cache], [AS_TR_SH([fp_cv_alignment_$1])])[]dnl
841 AC_CACHE_CHECK([alignment of $1], [fp_Cache],
842 [if test "$AS_TR_SH([ac_cv_type_$1])" = yes; then
843   FP_COMPUTE_INT([offsetof(struct { char c; $1 ty; },ty)],
844                  [fp_Cache],
845                  [AC_INCLUDES_DEFAULT([$3])],
846                  [AC_MSG_ERROR([cannot compute alignment ($1)
847 See `config.log' for more details.], [77])])
848 else
849   fp_Cache=0
850 fi])[]dnl
851 AC_DEFINE_UNQUOTED(AS_TR_CPP(alignment_$1), $fp_Cache, [The alignment of a `$1'.])[]dnl
852 m4_popdef([fp_Cache])[]dnl
853 ])# FP_CHECK_ALIGNMENT
854
855
856
857 # FP_CHECK_SIZEOF_AND_ALIGNMENT(TYPE)
858 # ------------------------------------------------------------------
859 # Combines AC_CHECK_SIZEOF and FP_CHECK_ALIGNMENT.
860 AC_DEFUN([FP_CHECK_SIZEOF_AND_ALIGNMENT],
861 [AC_CHECK_SIZEOF([$1])
862 FP_CHECK_ALIGNMENT([$1])
863 ])# FP_CHECK_SIZEOF_AND_ALIGNMENT
864
865
866 # FP_LEADING_UNDERSCORE
867 # ---------------------
868 # Test for determining whether symbol names have a leading underscore. We assume
869 # that they _haven't_ if anything goes wrong. Sets the output variable
870 # LeadingUnderscore to YES or NO and defines LEADING_UNDERSCORE correspondingly.
871 #
872 # Some nlist implementations seem to try to be compatible by ignoring a leading
873 # underscore sometimes (eg. FreeBSD). We therefore have to work around this by
874 # checking for *no* leading underscore first. Sigh.  --SDM
875 #
876 # Similarly on OpenBSD, but this test doesn't help. -- dons
877 AC_DEFUN([FP_LEADING_UNDERSCORE],
878 [AC_CHECK_LIB([elf], [nlist], [LIBS="-lelf $LIBS"])
879 AC_CACHE_CHECK([leading underscore in symbol names], [fptools_cv_leading_underscore], [
880 # Hack!: nlist() under Digital UNIX insist on there being an _,
881 # but symbol table listings shows none. What is going on here?!?
882 case $HostPlatform in
883 *openbsd*) # x86 openbsd is ELF from 3.4 >, meaning no leading uscore
884   case $build in
885     i386-*2\.@<:@0-9@:>@ | i386-*3\.@<:@0-3@:>@ ) fptools_cv_leading_underscore=yes ;;
886     *) fptools_cv_leading_underscore=no ;;
887   esac ;;
888 i386-unknown-mingw32) fptools_cv_leading_underscore=yes;;
889 x86_64-unknown-mingw32) fptools_cv_leading_underscore=no;;
890
891     # HACK: Apple doesn't seem to provide nlist in the 64-bit-libraries
892 x86_64-apple-darwin*) fptools_cv_leading_underscore=yes;;
893 *-apple-ios) fptools_cv_leading_underscore=yes;;
894
895 *) AC_RUN_IFELSE([AC_LANG_SOURCE([[#ifdef HAVE_NLIST_H
896 #include <nlist.h>
897 struct nlist xYzzY1[] = {{"xYzzY1", 0},{0}};
898 struct nlist xYzzY2[] = {{"_xYzzY2", 0},{0}};
899 #endif
900
901 int main(argc, argv)
902 int argc;
903 char **argv;
904 {
905 #ifdef HAVE_NLIST_H
906     if(nlist(argv[0], xYzzY1) == 0 && xYzzY1[0].n_value != 0)
907         exit(1);
908     if(nlist(argv[0], xYzzY2) == 0 && xYzzY2[0].n_value != 0)
909         exit(0);
910 #endif
911     exit(1);
912 }]])],[fptools_cv_leading_underscore=yes],[fptools_cv_leading_underscore=no],[fptools_cv_leading_underscore=no])
913 ;;
914 esac]);
915 AC_SUBST([LeadingUnderscore], [`echo $fptools_cv_leading_underscore | sed 'y/yesno/YESNO/'`])
916 if test x"$fptools_cv_leading_underscore" = xyes; then
917    AC_DEFINE([LEADING_UNDERSCORE], [1], [Define to 1 if C symbols have a leading underscore added by the compiler.])
918 fi])# FP_LEADING_UNDERSCORE
919
920
921 # FP_COMPARE_VERSIONS(VERSION1, TEST, VERSION2, [ACTION-IF-TRUE], [ACTION-IF-FALSE])
922 # ----------------------------------------------------------------------------------
923 # Compare dotted version numbers VERSION1 and VERSION2 lexicographically according
924 # to TEST (one of -eq, -ne, -lt, -le, -gt, or -ge).
925 AC_DEFUN([FP_COMPARE_VERSIONS],
926 [fp_version1=$1; fp_version2=$3
927 fp_save_IFS=$IFS; IFS='.'
928 while test x"$fp_version1" != x || test x"$fp_version2" != x
929 do
930
931   set dummy $fp_version1; shift
932   fp_num1=""
933   test $[@%:@] = 0 || { fp_num1="[$]1"; shift; }
934   test x"$fp_num1" = x && fp_num1="0"
935   fp_version1="[$]*"
936
937   set dummy $fp_version2; shift
938   fp_num2=""
939   test $[@%:@] = 0 || { fp_num2="[$]1"; shift; }
940   test x"$fp_num2" = x && fp_num2="0"
941   fp_version2="[$]*"
942
943   test "$fp_num1" = "$fp_num2" || break;
944 done
945 IFS=$fp_save_IFS
946 AS_IF([test "$fp_num1" $2 "$fp_num2"], [$4], [$5])[]dnl
947 ])# FP_COMPARE_VERSIONS
948
949
950 dnl
951 dnl Check for Happy and version.
952 dnl If there's no installed Happy, we look
953 dnl for a happy source tree and point the build system at that instead.
954 dnl If you increase the minimum version requirement, please also update:
955 dnl https://ghc.haskell.org/trac/ghc/wiki/Building/Preparation/Tools
956 dnl
957 AC_DEFUN([FPTOOLS_HAPPY],
958 [AC_PATH_PROG(HappyCmd,happy,)
959
960 AC_CACHE_CHECK([for version of happy], fptools_cv_happy_version,
961 changequote(, )dnl
962 [if test x"$HappyCmd" != x; then
963    fptools_cv_happy_version=`"$HappyCmd" -v |
964               grep 'Happy Version' | sed -e 's/Happy Version \([^ ]*\).*/\1/g'` ;
965 else
966    fptools_cv_happy_version="";
967 fi;
968 changequote([, ])dnl
969 ])
970 if test ! -f compiler/parser/Parser.hs || test ! -f compiler/cmm/CmmParse.hs
971 then
972     FP_COMPARE_VERSIONS([$fptools_cv_happy_version],[-lt],[1.19.4],
973       [AC_MSG_ERROR([Happy version 1.19.4 or later is required to compile GHC.])])[]
974 fi
975 HappyVersion=$fptools_cv_happy_version;
976 AC_SUBST(HappyVersion)
977 ])
978
979 dnl
980 dnl Check for Alex and version.
981 dnl If you increase the minimum version requirement, please also update:
982 dnl https://ghc.haskell.org/trac/ghc/wiki/Building/Preparation/Tools
983 dnl
984 AC_DEFUN([FPTOOLS_ALEX],
985 [
986 AC_PATH_PROG(AlexCmd,alex,)
987
988 AC_CACHE_CHECK([for version of alex], fptools_cv_alex_version,
989 changequote(, )dnl
990 [if test x"$AlexCmd" != x; then
991    fptools_cv_alex_version=`"$AlexCmd" -v |
992               grep 'Alex [Vv]ersion' | sed -e 's/Alex [Vv]ersion \([0-9\.]*\).*/\1/g'` ;
993 else
994    fptools_cv_alex_version="";
995 fi;
996 changequote([, ])dnl
997 ])
998 FP_COMPARE_VERSIONS([$fptools_cv_alex_version],[-ge],[3.0],
999   [Alex3=YES],[Alex3=NO])
1000 if test ! -f compiler/cmm/CmmLex.hs || test ! -f compiler/parser/Lexer.hs
1001 then
1002     FP_COMPARE_VERSIONS([$fptools_cv_alex_version],[-lt],[3.1.0],
1003       [AC_MSG_ERROR([Alex version 3.1.0 or later is required to compile GHC.])])[]
1004 fi
1005 AlexVersion=$fptools_cv_alex_version;
1006 AC_SUBST(AlexVersion)
1007 AC_SUBST(Alex3)
1008 ])
1009
1010
1011 # FP_PROG_LD_FLAG
1012 # ---------------
1013 # Sets the output variable $2 to $1 if ld supports the $1 flag.
1014 # Otherwise the variable's value is empty.
1015 AC_DEFUN([FP_PROG_LD_FLAG],
1016 [
1017 AC_CACHE_CHECK([whether ld understands $1], [fp_cv_$2],
1018 [echo 'int foo() { return 0; }' > conftest.c
1019 ${CC-cc} -c conftest.c
1020 if ${LdCmd} -r $1 -o conftest2.o conftest.o > /dev/null 2>&1; then
1021    fp_cv_$2=$1
1022 else
1023    fp_cv_$2=
1024 fi
1025 rm -rf conftest*])
1026 $2=$fp_cv_$2
1027 ])# FP_PROG_LD_FLAG
1028
1029
1030 # FP_PROG_LD_BUILD_ID
1031 # ------------
1032
1033 # Sets the output variable LdHasBuildId to YES if ld supports
1034 # --build-id, or NO otherwise.
1035 AC_DEFUN([FP_PROG_LD_BUILD_ID],
1036 [
1037 AC_CACHE_CHECK([whether ld understands --build-id], [fp_cv_ld_build_id],
1038 [echo 'int foo() { return 0; }' > conftest.c
1039 ${CC-cc} -c conftest.c
1040 if ${LdCmd} -r --build-id=none -o conftest2.o conftest.o > /dev/null 2>&1; then
1041    fp_cv_ld_build_id=yes
1042 else
1043    fp_cv_ld_build_id=no
1044 fi
1045 rm -rf conftest*])
1046 if test "$fp_cv_ld_build_id" = yes; then
1047   LdHasBuildId=YES
1048 else
1049   LdHasBuildId=NO
1050 fi
1051 AC_SUBST([LdHasBuildId])
1052 ])# FP_PROG_LD_BUILD_ID
1053
1054
1055 # FP_PROG_LD_IS_GNU
1056 # -----------------
1057 # Sets the output variable LdIsGNULd to YES or NO, depending on whether it is
1058 # GNU ld or not.
1059 AC_DEFUN([FP_PROG_LD_IS_GNU],
1060 [
1061 AC_CACHE_CHECK([whether ld is GNU ld], [fp_cv_gnu_ld],
1062 [if ${LdCmd} --version 2> /dev/null | grep "GNU" > /dev/null 2>&1; then
1063   fp_cv_gnu_ld=yes
1064 else
1065   fp_cv_gnu_ld=no
1066 fi])
1067 AC_SUBST([LdIsGNULd], [`echo $fp_cv_gnu_ld | sed 'y/yesno/YESNO/'`])
1068 ])# FP_PROG_LD_IS_GNU
1069
1070
1071 # FP_PROG_LD_NO_COMPACT_UNWIND
1072 # ----------------------------
1073
1074 # Sets the output variable LdHasNoCompactUnwind to YES if ld supports
1075 # -no_compact_unwind, or NO otherwise.
1076 AC_DEFUN([FP_PROG_LD_NO_COMPACT_UNWIND],
1077 [
1078 AC_CACHE_CHECK([whether ld understands -no_compact_unwind], [fp_cv_ld_no_compact_unwind],
1079 [echo 'int foo() { return 0; }' > conftest.c
1080 ${CC-cc} -c conftest.c
1081 if ${LdCmd} -r -no_compact_unwind -o conftest2.o conftest.o > /dev/null 2>&1; then
1082    fp_cv_ld_no_compact_unwind=yes
1083 else
1084    fp_cv_ld_no_compact_unwind=no
1085 fi
1086 rm -rf conftest*])
1087 if test "$fp_cv_ld_no_compact_unwind" = yes; then
1088   LdHasNoCompactUnwind=YES
1089 else
1090   LdHasNoCompactUnwind=NO
1091 fi
1092 AC_SUBST([LdHasNoCompactUnwind])
1093 ])# FP_PROG_LD_NO_COMPACT_UNWIND
1094
1095
1096 # FP_PROG_LD_FILELIST
1097 # -------------------
1098
1099 # Sets the output variable LdHasFilelist to YES if ld supports
1100 # -filelist, or NO otherwise.
1101 AC_DEFUN([FP_PROG_LD_FILELIST],
1102 [
1103 AC_CACHE_CHECK([whether ld understands -filelist], [fp_cv_ld_has_filelist],
1104 [
1105     echo 'int foo() { return 0; }' > conftest1.c
1106     echo 'int bar() { return 0; }' > conftest2.c
1107     ${CC-cc} -c conftest1.c
1108     ${CC-cc} -c conftest2.c
1109     echo conftest1.o  > conftest.o-files
1110     echo conftest2.o >> conftest.o-files
1111     if ${LdCmd} -r -filelist conftest.o-files -o conftest.o > /dev/null 2>&1
1112     then
1113         fp_cv_ld_has_filelist=yes
1114     else
1115         fp_cv_ld_has_filelist=no
1116     fi
1117     rm -rf conftest*
1118 ])
1119 if test "$fp_cv_ld_has_filelist" = yes; then
1120     LdHasFilelist=YES
1121 else
1122     LdHasFilelist=NO
1123 fi
1124 AC_SUBST([LdHasFilelist])
1125 ])# FP_PROG_LD_FILELIST
1126
1127
1128 # FP_PROG_AR
1129 # ----------
1130 # Sets fp_prog_ar to a path to ar. Exits if no ar can be found
1131 AC_DEFUN([FP_PROG_AR],
1132 [AC_PATH_PROG([fp_prog_ar], [ar])
1133 if test -z "$fp_prog_ar"; then
1134   AC_MSG_ERROR([cannot find ar in your PATH, no idea how to make a library])
1135 fi
1136 ])# FP_PROG_AR
1137
1138
1139 # FP_PROG_AR_IS_GNU
1140 # -----------------
1141 # Sets fp_prog_ar_is_gnu to yes or no, depending on whether it is GNU ar or not.
1142 AC_DEFUN([FP_PROG_AR_IS_GNU],
1143 [AC_REQUIRE([FP_PROG_AR])
1144 AC_CACHE_CHECK([whether $fp_prog_ar is GNU ar], [fp_cv_prog_ar_is_gnu],
1145 [if "$fp_prog_ar" --version 2> /dev/null | grep "GNU" > /dev/null 2>&1; then
1146   fp_cv_prog_ar_is_gnu=yes
1147 else
1148   fp_cv_prog_ar_is_gnu=no
1149 fi])
1150 fp_prog_ar_is_gnu=$fp_cv_prog_ar_is_gnu
1151 AC_SUBST([ArIsGNUAr], [`echo $fp_prog_ar_is_gnu | tr 'a-z' 'A-Z'`])
1152 ])# FP_PROG_AR_IS_GNU
1153
1154
1155 # FP_PROG_AR_SUPPORTS_ATFILE
1156 # -----------------
1157 # Sets fp_prog_ar_supports_atfile to yes or no, depending on whether
1158 # or not it supports the @file syntax
1159 AC_DEFUN([FP_PROG_AR_SUPPORTS_ATFILE],
1160 [AC_REQUIRE([FP_PROG_AR])
1161  AC_REQUIRE([FP_PROG_AR_ARGS])
1162 AC_CACHE_CHECK([whether $fp_prog_ar supports @file], [fp_cv_prog_ar_supports_atfile],
1163 [
1164 rm -f conftest*
1165 touch conftest.file
1166 echo conftest.file  > conftest.atfile
1167 echo conftest.file >> conftest.atfile
1168 "$fp_prog_ar" $fp_prog_ar_args conftest.a @conftest.atfile > /dev/null 2>&1
1169 fp_prog_ar_supports_atfile_tmp=`"$fp_prog_ar" t conftest.a 2> /dev/null | grep -c conftest.file`
1170 rm -f conftest*
1171 if test "$fp_prog_ar_supports_atfile_tmp" -eq 2
1172 then
1173   fp_cv_prog_ar_supports_atfile=yes
1174 else
1175   fp_cv_prog_ar_supports_atfile=no
1176 fi])
1177 fp_prog_ar_supports_atfile=$fp_cv_prog_ar_supports_atfile
1178 AC_SUBST([ArSupportsAtFile], [`echo $fp_prog_ar_supports_atfile | tr 'a-z' 'A-Z'`])
1179 ])# FP_PROG_AR_SUPPORTS_ATFILE
1180
1181 # FP_PROG_AR_ARGS
1182 # ---------------
1183 # Sets fp_prog_ar_args to the arguments for ar and the output variable ArCmd
1184 # to an invocation of ar including these arguments.
1185 AC_DEFUN([FP_PROG_AR_ARGS],
1186 [AC_REQUIRE([FP_PROG_AR_IS_GNU])
1187 AC_CACHE_CHECK([for ar arguments], [fp_cv_prog_ar_args],
1188 [
1189 # GNU ar needs special treatment: it appears to have problems with
1190 # object files with the same name if you use the 's' modifier, but
1191 # simple 'ar q' works fine, and doesn't need a separate ranlib.
1192 if test $fp_prog_ar_is_gnu = yes; then
1193   fp_cv_prog_ar_args="q"
1194 else
1195   touch conftest.dummy
1196   for fp_var in clqsZ clqs cqs clq cq ; do
1197      rm -f conftest.a
1198      if "$fp_prog_ar" $fp_var conftest.a conftest.dummy > /dev/null 2> /dev/null; then
1199         fp_cv_prog_ar_args=$fp_var
1200         break
1201      fi
1202   done
1203   rm -f conftest*
1204   if test -z "$fp_cv_prog_ar_args"; then
1205     AC_MSG_ERROR([cannot figure out how to use your $fp_prog_ar])
1206   fi
1207 fi])
1208 fp_prog_ar_args=$fp_cv_prog_ar_args
1209 AC_SUBST([ArCmd], ["$fp_prog_ar"])
1210 AC_SUBST([ArArgs], ["$fp_prog_ar_args"])
1211
1212 ])# FP_PROG_AR_ARGS
1213
1214
1215 # FP_PROG_AR_NEEDS_RANLIB
1216 # -----------------------
1217 # Sets the output variable RANLIB_CMD to "ranlib" if it is needed and
1218 # found, to "true" otherwise. Sets REAL_RANLIB_CMD to the ranlib program,
1219 # even if we don't need ranlib (libffi might still need it).
1220 AC_DEFUN([FP_PROG_AR_NEEDS_RANLIB],[
1221     AC_REQUIRE([FP_PROG_AR_IS_GNU])
1222     AC_REQUIRE([FP_PROG_AR_ARGS])
1223     AC_REQUIRE([AC_PROG_CC])
1224
1225     AC_PROG_RANLIB
1226
1227     if test $fp_prog_ar_is_gnu = yes
1228     then
1229         fp_cv_prog_ar_needs_ranlib=no
1230     elif test "$TargetOS_CPP" = "darwin"
1231     then
1232         # It's quite tedious to check for Apple's crazy timestamps in
1233         # .a files, so we hardcode it.
1234         fp_cv_prog_ar_needs_ranlib=yes
1235     else
1236         case $fp_prog_ar_args in
1237         *s*)
1238             fp_cv_prog_ar_needs_ranlib=no;;
1239         *)
1240             fp_cv_prog_ar_needs_ranlib=yes;;
1241         esac
1242     fi
1243
1244     # workaround for AC_PROG_RANLIB which sets RANLIB to `:' when
1245     # ranlib is missing on the target OS. The problem is that
1246     # ghc-cabal cannot execute `:' which is a shell built-in but can
1247     # execute `true' which is usually simple program supported by the
1248     # OS.
1249     # Fixes #8795
1250     if test "$RANLIB" = ":"
1251     then
1252         RANLIB="true"
1253     fi
1254     REAL_RANLIB_CMD="$RANLIB"
1255     if test $fp_cv_prog_ar_needs_ranlib = yes
1256     then
1257         RANLIB_CMD="$RANLIB"
1258     else
1259         RANLIB_CMD="true"
1260     fi
1261     AC_SUBST([REAL_RANLIB_CMD])
1262     AC_SUBST([RANLIB_CMD])
1263 ])# FP_PROG_AR_NEEDS_RANLIB
1264
1265
1266 # FP_GCC_VERSION
1267 # -----------
1268 # Extra testing of the result AC_PROG_CC, testing the gcc version no. Sets the
1269 # output variable GccVersion.
1270 AC_DEFUN([FP_GCC_VERSION],
1271 [AC_REQUIRE([AC_PROG_CC])
1272 if test -z "$CC"
1273 then
1274   AC_MSG_ERROR([gcc is required])
1275 fi
1276 GccLT34=NO
1277 GccLT44=NO
1278 GccLT46=NO
1279 AC_CACHE_CHECK([version of gcc], [fp_cv_gcc_version],
1280 [
1281     fp_cv_gcc_version="`$CC -v 2>&1 | grep 'version ' | sed -e 's/.*version [[^0-9]]*\([[0-9.]]*\).*/\1/g'`"
1282     FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-lt], [3.0],
1283                         [AC_MSG_ERROR([Need at least gcc version 3.0 (3.4+ recommended)])])
1284     # See #2770: gcc 2.95 doesn't work any more, apparently.  There probably
1285     # isn't a very good reason for that, but for now just make configure
1286     # fail.
1287     FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-lt], [3.4], GccLT34=YES)
1288     FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-lt], [4.4], GccLT44=YES)
1289     FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-lt], [4.6], GccLT46=YES)
1290 ])
1291 AC_SUBST([GccVersion], [$fp_cv_gcc_version])
1292 AC_SUBST(GccLT34)
1293 AC_SUBST(GccLT44)
1294 AC_SUBST(GccLT46)
1295 ])# FP_GCC_VERSION
1296
1297 dnl Check to see if the C compiler is clang or llvm-gcc
1298 dnl
1299 GccIsClang=NO
1300 AC_DEFUN([FP_CC_LLVM_BACKEND],
1301 [AC_REQUIRE([AC_PROG_CC])
1302 AC_MSG_CHECKING([whether C compiler is clang])
1303 $CC -x c /dev/null -dM -E > conftest.txt 2>&1
1304 if grep "__clang__" conftest.txt >/dev/null 2>&1; then
1305   AC_SUBST([CC_CLANG_BACKEND], [1])
1306   AC_SUBST([CC_LLVM_BACKEND], [1])
1307   GccIsClang=YES
1308   AC_MSG_RESULT([yes])
1309 else
1310   AC_MSG_RESULT([no])
1311   AC_MSG_CHECKING([whether C compiler has an LLVM back end])
1312   if grep "__llvm__" conftest.txt >/dev/null 2>&1; then
1313     AC_SUBST([CC_CLANG_BACKEND], [0])
1314     AC_SUBST([CC_LLVM_BACKEND], [1])
1315     AC_MSG_RESULT([yes])
1316   else
1317     AC_SUBST([CC_CLANG_BACKEND], [0])
1318     AC_SUBST([CC_LLVM_BACKEND], [0])
1319     AC_MSG_RESULT([no])
1320   fi
1321 fi
1322 AC_SUBST(GccIsClang)
1323
1324 rm -f conftest.txt
1325 ])
1326
1327 # FP_GCC_SUPPORTS_NO_PIE
1328 # ----------------------
1329 # Does gcc support the -no-pie option? If so we should pass it to gcc when
1330 # joining objects since -pie may be enabled by default.
1331 AC_DEFUN([FP_GCC_SUPPORTS_NO_PIE],
1332 [
1333    AC_REQUIRE([AC_PROG_CC])
1334    AC_MSG_CHECKING([whether GCC supports -no-pie])
1335    echo 'int main() { return 0; }' > conftest.c
1336    # Some GCC versions only warn when passed an unrecognized flag.
1337    if $CC -no-pie -x c /dev/null -dM -E > conftest.txt 2>&1 && ! grep -i unrecognized conftest.txt > /dev/null 2>&1; then
1338        CONF_GCC_SUPPORTS_NO_PIE=YES
1339        AC_MSG_RESULT([yes])
1340    else
1341        CONF_GCC_SUPPORTS_NO_PIE=NO
1342        AC_MSG_RESULT([no])
1343    fi
1344    rm -f conftest.c conftest.o conftest
1345 ])
1346
1347 dnl Small feature test for perl version. Assumes PerlCmd
1348 dnl contains path to perl binary.
1349 dnl
1350 dnl (Perl versions prior to v5.6 does not contain the string "v5";
1351 dnl instead they display version strings such as "version 5.005".)
1352 dnl
1353 AC_DEFUN([FPTOOLS_CHECK_PERL_VERSION],
1354 [$PerlCmd -v >conftest.out 2>&1
1355    if grep "v5" conftest.out >/dev/null 2>&1; then
1356       :
1357    else
1358       AC_MSG_ERROR([your version of perl probably won't work, try upgrading it.])
1359    fi
1360 rm -fr conftest*
1361 ])
1362
1363
1364 # FP_CHECK_PROG(VARIABLE, PROG-TO-CHECK-FOR,
1365 #               [VALUE-IF-NOT-FOUND], [PATH], [REJECT])
1366 # -----------------------------------------------------
1367 # HACK: A small wrapper around AC_CHECK_PROG, setting VARIABLE to the full path
1368 # of PROG-TO-CHECK-FOR when found.
1369 AC_DEFUN([FP_CHECK_PROG],
1370 [AC_CHECK_PROG([$1], [$2], [$as_dir/$ac_word$ac_exec_ext], [$3], [$4], [$5])][]dnl
1371 )# FP_CHECK_PROC
1372
1373
1374 # FP_PROG_FIND
1375 # ------------
1376 # Find a non-WinDoze version of the "find" utility.
1377 AC_DEFUN([FP_PROG_FIND],
1378 [AC_PATH_PROGS([fp_prog_find], [gfind find], find)
1379 echo foo > conftest.txt
1380 $fp_prog_find conftest.txt -print > conftest.out 2>&1
1381 if grep '^conftest.txt$' conftest.out > /dev/null 2>&1 ; then
1382   # OK, looks like a real "find".
1383   FindCmd="$fp_prog_find"
1384 else
1385   # Found a poor WinDoze version of "find", ignore it.
1386   AC_MSG_WARN([$fp_prog_find looks like a non-*nix find, ignoring it])
1387   FP_CHECK_PROG([FindCmd], [find], [], [], [$fp_prog_find])
1388 fi
1389 rm -f conftest.txt conftest.out
1390 AC_SUBST([FindCmd])[]dnl
1391 ])# FP_PROG_FIND
1392
1393
1394 # FP_PROG_SORT
1395 # ------------
1396 # Find a Unix-like sort
1397 AC_DEFUN([FP_PROG_SORT],
1398 [AC_PATH_PROG([fp_prog_sort], [sort])
1399 echo conwip > conftest.txt
1400 $fp_prog_sort -f conftest.txt > conftest.out 2>&1
1401 if grep 'conwip' conftest.out > /dev/null 2>&1 ; then
1402   # The goods
1403   SortCmd="$fp_prog_sort"
1404 else
1405   # Summink else..pick next one.
1406   AC_MSG_WARN([$fp_prog_sort looks like a non-*nix sort, ignoring it])
1407   FP_CHECK_PROG([SortCmd], [sort], [], [], [$fp_prog_sort])
1408 fi
1409 rm -f conftest.txt conftest.out
1410 AC_SUBST([SortCmd])[]dnl
1411 ])# FP_PROG_SORT
1412
1413
1414 dnl
1415 dnl FPTOOLS_NOCACHE_CHECK prints a message, then sets the
1416 dnl values of the second argument to the result of running
1417 dnl the commands given by the third. It does not cache its
1418 dnl result, so it is suitable for checks which should be
1419 dnl run every time.
1420 dnl
1421 AC_DEFUN([FPTOOLS_NOCACHE_CHECK],
1422 [AC_MSG_CHECKING([$1])
1423  $3
1424  AC_MSG_RESULT([$][$2])
1425 ])
1426
1427 dnl
1428 dnl FPTOOLS_GHC_VERSION(version)
1429 dnl FPTOOLS_GHC_VERSION(major, minor [, patchlevel])
1430 dnl FPTOOLS_GHC_VERSION(version, major, minor, patchlevel)
1431 dnl
1432 dnl Test for version of installed ghc.  Uses $GHC.
1433 dnl [original version pinched from c2hs]
1434 dnl
1435 AC_DEFUN([FPTOOLS_GHC_VERSION],
1436 [FPTOOLS_NOCACHE_CHECK([version of ghc], [fptools_version_of_ghc],
1437 ["${WithGhc-ghc}" --version > conftestghc 2>&1
1438   cat conftestghc >&AS_MESSAGE_LOG_FD
1439 #Useless Use Of cat award...
1440   fptools_version_of_ghc=`cat conftestghc | sed -n -e 's/, patchlevel *\([[0-9]]\)/.\1/;s/.* version \([[0-9]][[0-9.]]*\).*/\1/p'`
1441   rm -fr conftest*
1442   if test "[$]fptools_version_of_ghc" = ""
1443   then
1444     fptools_version_of_ghc='unknown'
1445   fi
1446 fptools_version_of_ghc[_major]=`echo [$]fptools_version_of_ghc | sed -e 's/^\([[0-9]]\).*/\1/'`
1447 fptools_version_of_ghc[_minor]=`echo [$]fptools_version_of_ghc | sed -e 's/^[[0-9]]\.\([[0-9]]*\).*/\1/'`
1448 fptools_version_of_ghc[_pl]=`echo [$]fptools_version_of_ghc | sed -n -e 's/^[[0-9]]\.[[0-9]]*\.\([[0-9]]*\)/\1/p'`
1449 #
1450 if test "[$]fptools_version_of_ghc[_pl]" = ""
1451 then
1452   fptools_version_of_ghc[_all]="[$]fptools_version_of_ghc[_major].[$]fptools_version_of_ghc[_minor]"
1453   fptools_version_of_ghc[_pl]="0"
1454 else
1455   fptools_version_of_ghc[_all]="[$]fptools_version_of_ghc[_major].[$]fptools_version_of_ghc[_minor].[$]fptools_version_of_ghc[_pl]"
1456 fi
1457 #
1458 ifelse($#, [1], [dnl
1459 [$1]="[$]fptools_version_of_ghc[_all]"
1460 ], $#, [2], [dnl
1461 [$1]="[$]fptools_version_of_ghc[_major]"
1462 [$2]="[$]fptools_version_of_ghc[_minor]"
1463 ], $#, [3], [dnl
1464 [$1]="[$]fptools_version_of_ghc[_major]"
1465 [$2]="[$]fptools_version_of_ghc[_minor]"
1466 [$3]="[$]fptools_version_of_ghc[_pl]"
1467 ], $#, [4], [dnl
1468 [$1]="[$]fptools_version_of_ghc[_all]"
1469 [$2]="[$]fptools_version_of_ghc[_major]"
1470 [$3]="[$]fptools_version_of_ghc[_minor]"
1471 [$4]="[$]fptools_version_of_ghc[_pl]"
1472 ])
1473 ])
1474 ])dnl
1475
1476
1477 # FP_CHECK_FUNC(FUNCTION, PROLOGUE, BODY, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1478 # ---------------------------------------------------------------------------------
1479 # A variant of AC_CHECK_FUNCS, limited to a single FUNCTION, but with the
1480 # additional flexibility of specifying the PROLOGUE and BODY.
1481 AC_DEFUN([FP_CHECK_FUNC],
1482 [AS_VAR_PUSHDEF([fp_func], [fp_cv_func_$1])dnl
1483 AC_CACHE_CHECK([for $1], fp_func,
1484 [AC_LINK_IFELSE([AC_LANG_PROGRAM([$2], [$3])],
1485                 [AS_VAR_SET(fp_func, yes)],
1486                 [AS_VAR_SET(fp_func, no)])])
1487 AS_IF([test AS_VAR_GET(fp_func) = yes],
1488       [AC_DEFINE(AS_TR_CPP(HAVE_$1), [1],
1489                 [Define to 1 if you have the `]$1[' function.]) $4],
1490       [$5])dnl
1491 AS_VAR_POPDEF([fp_func])dnl
1492 ])# FP_CHECK_FUNC
1493
1494 # FP_PROG_GHC_PKG
1495 # ----------------
1496 # Try to find a ghc-pkg matching the ghc mentioned in the environment variable
1497 # WithGhc. Sets the output variable GhcPkgCmd.
1498 AC_DEFUN([FP_PROG_GHC_PKG],
1499 [AC_CACHE_CHECK([for ghc-pkg matching $WithGhc], fp_cv_matching_ghc_pkg,
1500 [
1501 # If we are told to use ghc-stage2, then we're using an in-tree
1502 # compiler. In this case, we just want ghc-pkg, not ghc-pkg-stage2,
1503 # so we sed off -stage[0-9]$. However, if we are told to use
1504 # ghc-6.12.1 then we want to use ghc-pkg-6.12.1, so we keep any
1505 # other suffix.
1506 fp_ghc_pkg_guess=`echo "$WithGhc" | sed -e 's/-stage@<:@0-9@:>@$//' -e 's,ghc\(@<:@^/\\@:>@*\)$,ghc-pkg\1,'`
1507 if "$fp_ghc_pkg_guess" list > /dev/null 2>&1; then
1508   fp_cv_matching_ghc_pkg=$fp_ghc_pkg_guess
1509 else
1510   AC_MSG_ERROR([Cannot find matching ghc-pkg])
1511 fi])
1512 GhcPkgCmd=$fp_cv_matching_ghc_pkg
1513 AC_SUBST([GhcPkgCmd])
1514 ])# FP_PROG_GHC_PKG
1515
1516
1517 # FP_GCC_EXTRA_FLAGS
1518 # ------------------
1519 # Determine which extra flags we need to pass gcc when we invoke it
1520 # to compile .hc code.
1521 #
1522 # -fwrapv is needed for gcc to emit well-behaved code in the presence of
1523 # integer wrap around. (Trac #952)
1524 #
1525 AC_DEFUN([FP_GCC_EXTRA_FLAGS],
1526 [AC_REQUIRE([FP_GCC_VERSION])
1527 AC_CACHE_CHECK([for extra options to pass gcc when compiling via C], [fp_cv_gcc_extra_opts],
1528 [fp_cv_gcc_extra_opts=
1529  FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-ge], [3.4],
1530   [fp_cv_gcc_extra_opts="$fp_cv_gcc_extra_opts -fwrapv"],
1531   [])
1532  FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-ge], [4.0],
1533   [fp_cv_gcc_extra_opts="$fp_cv_gcc_extra_opts -fno-builtin"],
1534   [])
1535 ])
1536 AC_SUBST([GccExtraViaCOpts],$fp_cv_gcc_extra_opts)
1537 ])
1538
1539
1540 # FP_SETUP_PROJECT_VERSION
1541 # ---------------------
1542 AC_DEFUN([FP_SETUP_PROJECT_VERSION],
1543 [
1544 if test "$RELEASE" = "NO"; then
1545     AC_MSG_CHECKING([for GHC version date])
1546     if test -f VERSION_DATE; then
1547         PACKAGE_VERSION=${PACKAGE_VERSION}.`cat VERSION_DATE`
1548         AC_MSG_RESULT(given $PACKAGE_VERSION)
1549     elif test -d .git; then
1550         changequote(, )dnl
1551         ver_posixtime=`git log -1 --pretty=format:%ct`
1552         ver_date=`perl -MPOSIX -e "print strftime('%Y%m%d', gmtime($ver_posixtime));"`
1553         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
1554         changequote([, ])dnl
1555                 AC_MSG_ERROR([failed to detect version date: check that git and perl are in your path])
1556         fi
1557         PACKAGE_VERSION=${PACKAGE_VERSION}.$ver_date
1558         AC_MSG_RESULT(inferred $PACKAGE_VERSION)
1559     elif test -f VERSION; then
1560         PACKAGE_VERSION=`cat VERSION`
1561         AC_MSG_RESULT(given $PACKAGE_VERSION)
1562     else
1563         AC_MSG_WARN([cannot determine snapshot version: no .git directory and no VERSION file])
1564         dnl We'd really rather this case didn't happen, but it might
1565         dnl do (in particular, people using lndir trees may find that
1566         dnl the build system can't find any other date). If it does
1567         dnl happen, then we use the current date.
1568         dnl This way we get some idea about how recent a build is.
1569         dnl It also means that packages built for 2 different builds
1570         dnl will probably use different version numbers, so things are
1571         dnl less likely to go wrong.
1572         PACKAGE_VERSION=${PACKAGE_VERSION}.`date +%Y%m%d`
1573     fi
1574 fi
1575
1576     AC_MSG_CHECKING([for GHC Git commit id])
1577     if test -d .git; then
1578         git_commit_id=`git rev-parse HEAD`
1579         if test -n "$git_commit_id" 2>&1 >/dev/null; then true; else
1580             AC_MSG_ERROR([failed to detect revision: check that git is in your path])
1581         fi
1582         PACKAGE_GIT_COMMIT_ID=$git_commit_id
1583         AC_MSG_RESULT(inferred $PACKAGE_GIT_COMMIT_ID)
1584     elif test -f GIT_COMMIT_ID; then
1585         PACKAGE_GIT_COMMIT_ID=`cat GIT_COMMIT_ID`
1586         AC_MSG_RESULT(given $PACKAGE_GIT_COMMIT_ID)
1587     else
1588         AC_MSG_WARN([cannot determine snapshot revision: no .git directory and no 'GIT_COMMIT_ID' file])
1589         PACKAGE_GIT_COMMIT_ID="0000000000000000000000000000000000000000"
1590     fi
1591
1592
1593 # Some renamings
1594 AC_SUBST([ProjectName], [$PACKAGE_NAME])
1595 AC_SUBST([ProjectVersion], [$PACKAGE_VERSION])
1596 AC_SUBST([ProjectGitCommitId], [$PACKAGE_GIT_COMMIT_ID])
1597
1598 # Split PACKAGE_VERSION into (possibly empty) parts
1599 VERSION_MAJOR=`echo $PACKAGE_VERSION | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\1'/`
1600 VERSION_TMP=`echo $PACKAGE_VERSION | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\3'/`
1601 VERSION_MINOR=`echo $VERSION_TMP | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\1'/`
1602 ProjectPatchLevel=`echo $VERSION_TMP | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\3'/`
1603
1604 # Calculate project version as an integer, using 2 digits for minor version
1605 case $VERSION_MINOR in
1606   ?) ProjectVersionInt=${VERSION_MAJOR}0${VERSION_MINOR} ;;
1607   ??) ProjectVersionInt=${VERSION_MAJOR}${VERSION_MINOR} ;;
1608   *) AC_MSG_ERROR([bad minor version in $PACKAGE_VERSION]) ;;
1609 esac
1610 AC_SUBST([ProjectVersionInt])
1611
1612 # The project patchlevel is zero unless stated otherwise
1613 test -z "$ProjectPatchLevel" && ProjectPatchLevel=0
1614
1615 # Save split version of ProjectPatchLevel
1616 ProjectPatchLevel1=`echo $ProjectPatchLevel | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\1/'`
1617 ProjectPatchLevel2=`echo $ProjectPatchLevel | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\3/'`
1618
1619 AC_SUBST([ProjectPatchLevel1])
1620 AC_SUBST([ProjectPatchLevel2])
1621
1622 # Remove dots from the patch level; this allows us to have versions like 6.4.1.20050508
1623 ProjectPatchLevel=`echo $ProjectPatchLevel | sed 's/\.//'`
1624
1625 AC_SUBST([ProjectPatchLevel])
1626
1627 # The version of the GHC package changes every day, since the
1628 # patchlevel is the current date.  We don't want to force
1629 # recompilation of the entire compiler when this happens, so for
1630 # GHC HEAD we omit the patchlevel from the package version number.
1631 #
1632 # The ProjectPatchLevel1 > 20000000 iff GHC HEAD. If it's for a stable
1633 # release like 7.10.1 or for a release candidate such as 7.10.1.20141224
1634 # then we don't omit the patchlevel components.
1635
1636 ProjectVersionMunged="$ProjectVersion"
1637 if test "$ProjectPatchLevel1" -gt 20000000; then
1638   ProjectVersionMunged="${VERSION_MAJOR}.${VERSION_MINOR}"
1639 fi
1640 AC_SUBST([ProjectVersionMunged])
1641 ])# FP_SETUP_PROJECT_VERSION
1642
1643 # Check for a working timer_create().  We need a pretty detailed check
1644 # here, because there exist partially-working implementations of
1645 # timer_create() in certain versions of Linux (see bug #1933).
1646 #
1647 AC_DEFUN([FP_CHECK_TIMER_CREATE],[
1648 AC_CHECK_FUNC([timer_create],[HAVE_timer_create=yes],[HAVE_timer_create=no])
1649
1650 if test "$HAVE_timer_create" = "yes"
1651 then
1652   if test "$cross_compiling" = "yes"
1653   then
1654     # We can't test timer_create when we're cross-compiling, so we
1655     # optimistiaclly assume that it actually works properly.
1656     AC_DEFINE([USE_TIMER_CREATE], 1,  [Define to 1 if we can use timer_create(CLOCK_REALTIME,...)])
1657   else
1658   AC_CACHE_CHECK([for a working timer_create(CLOCK_REALTIME)],
1659     [fptools_cv_timer_create_works],
1660     [AC_TRY_RUN([
1661 #include <stdio.h>
1662 #ifdef HAVE_STDLIB_H
1663 #include <stdlib.h>
1664 #endif
1665 #ifdef HAVE_TIME_H
1666 #include <time.h>
1667 #endif
1668 #ifdef HAVE_SIGNAL_H
1669 #include <signal.h>
1670 #endif
1671 #ifdef HAVE_UNISTD_H
1672 #include <unistd.h>
1673 #endif
1674
1675 static volatile int tock = 0;
1676 static void handler(int i)
1677 {
1678    tock = 1;
1679 }
1680
1681 static void timeout(int i)
1682 {
1683   // timer_settime() has been known to hang, so just in case
1684   // we install a 1-second timeout (see #2257)
1685   exit(99);
1686 }
1687
1688 int main(int argc, char *argv[])
1689 {
1690
1691     struct sigevent ev;
1692     timer_t timer;
1693     struct itimerspec it;
1694     struct sigaction action;
1695     int m,n,count = 0;
1696
1697     ev.sigev_notify = SIGEV_SIGNAL;
1698     ev.sigev_signo  = SIGVTALRM;
1699
1700     action.sa_handler = handler;
1701     action.sa_flags = 0;
1702     sigemptyset(&action.sa_mask);
1703     if (sigaction(SIGVTALRM, &action, NULL) == -1) {
1704         fprintf(stderr,"SIGVTALRM problem\n");
1705         exit(3);
1706     }
1707
1708     action.sa_handler = timeout;
1709     action.sa_flags = 0;
1710     sigemptyset(&action.sa_mask);
1711     if (sigaction(SIGALRM, &action, NULL) == -1) {
1712       fprintf(stderr,"SIGALRM problem\n");
1713       exit(3);
1714     }
1715     alarm(1);
1716
1717     if (timer_create(CLOCK_REALTIME, &ev, &timer) != 0) {
1718         fprintf(stderr,"No CLOCK_REALTIME timer\n");
1719         exit(2);
1720     }
1721
1722     tock = 0;
1723
1724     it.it_value.tv_sec = 0;
1725     it.it_value.tv_nsec = 1000000; // 1ms
1726     it.it_interval = it.it_value;
1727     if (timer_settime(timer, 0, &it, NULL) != 0) {
1728         fprintf(stderr,"settime problem\n");
1729         exit(4);
1730     }
1731
1732     // some environments have coarse scheduler/timer granularity of ~10ms and worse
1733     usleep(100000); // 100ms
1734
1735     if (!tock) {
1736         fprintf(stderr,"no CLOCK_REALTIME signal\n");
1737         exit(5);
1738     }
1739
1740     timer_delete(timer);
1741
1742     exit(0);
1743 }
1744      ],
1745      [fptools_cv_timer_create_works=yes],
1746      [fptools_cv_timer_create_works=no])
1747   ])
1748 case $fptools_cv_timer_create_works in
1749     yes) AC_DEFINE([USE_TIMER_CREATE], 1,
1750                    [Define to 1 if we can use timer_create(CLOCK_REALTIME,...)]);;
1751 esac
1752   fi
1753 fi
1754 ])
1755
1756 # FP_ICONV
1757 # -------------
1758 AC_DEFUN([FP_ICONV],
1759 [
1760   dnl--------------------------------------------------------------------
1761   dnl * Deal with arguments telling us iconv is somewhere odd
1762   dnl--------------------------------------------------------------------
1763
1764   dnl Note: ICONV_LIB_DIRS and ICONV_INCLUDE_DIRS are not predefined
1765   dnl to the empty string to allow them to be overridden from the
1766   dnl environment.
1767
1768   AC_ARG_WITH([iconv-includes],
1769     [AC_HELP_STRING([--with-iconv-includes],
1770       [directory containing iconv.h])],
1771       [ICONV_INCLUDE_DIRS=$withval])
1772
1773   AC_ARG_WITH([iconv-libraries],
1774     [AC_HELP_STRING([--with-iconv-libraries],
1775       [directory containing iconv library])],
1776       [ICONV_LIB_DIRS=$withval])
1777
1778   AC_SUBST(ICONV_INCLUDE_DIRS)
1779   AC_SUBST(ICONV_LIB_DIRS)
1780 ])# FP_ICONV
1781
1782 # FP_GMP
1783 # -------------
1784 AC_DEFUN([FP_GMP],
1785 [
1786   dnl--------------------------------------------------------------------
1787   dnl * Deal with arguments telling us gmp is somewhere odd
1788   dnl--------------------------------------------------------------------
1789
1790   AC_ARG_WITH([gmp-includes],
1791     [AC_HELP_STRING([--with-gmp-includes],
1792       [directory containing gmp.h])],
1793       [GMP_INCLUDE_DIRS=$withval])
1794
1795   AC_ARG_WITH([gmp-libraries],
1796     [AC_HELP_STRING([--with-gmp-libraries],
1797       [directory containing gmp library])],
1798       [GMP_LIB_DIRS=$withval])
1799
1800   AC_SUBST(GMP_INCLUDE_DIRS)
1801   AC_SUBST(GMP_LIB_DIRS)
1802 ])# FP_GMP
1803
1804 # FP_CURSES
1805 # -------------
1806 AC_DEFUN([FP_CURSES],
1807 [
1808   dnl--------------------------------------------------------------------
1809   dnl * Deal with arguments telling us curses is somewhere odd
1810   dnl--------------------------------------------------------------------
1811
1812   AC_ARG_WITH([curses-includes],
1813     [AC_HELP_STRING([--with-curses-includes],
1814       [directory containing curses headers])],
1815       [CURSES_INCLUDE_DIRS=$withval])
1816
1817   AC_ARG_WITH([curses-libraries],
1818     [AC_HELP_STRING([--with-curses-libraries],
1819       [directory containing curses libraries])],
1820       [CURSES_LIB_DIRS=$withval])
1821
1822   AC_SUBST(CURSES_INCLUDE_DIRS)
1823   AC_SUBST(CURSES_LIB_DIRS)
1824 ])# FP_CURSES
1825
1826 # --------------------------------------------------------------
1827 # Calculate absolute path to build tree
1828 # --------------------------------------------------------------
1829
1830 AC_DEFUN([FP_FIND_ROOT],[
1831 AC_MSG_CHECKING(for path to top of build tree)
1832     if test "$windows" = YES
1833     then
1834       dnl Make sure this is a c:/foo/bar (mixed) style path. Some parts of
1835       dnl the build system might depend on it (such as the sed expression
1836       dnl `"s|$(TOP)/||i"` in addCFileDeps in rules/build-dependencies.mk).
1837       hardtop=$(cygpath -m "$(pwd)")
1838     else
1839       hardtop=$(pwd)
1840     fi
1841
1842     dnl Remove common automounter nonsense
1843     hardtop=`echo $hardtop | sed 's|^/tmp_mnt.*\(/local/.*\)$|\1|' | sed 's|^/tmp_mnt/|/|'`
1844
1845     if ! test -d "$hardtop"; then
1846         AC_MSG_ERROR([cannot determine current directory])
1847     fi
1848
1849     dnl We don't support building in directories with spaces.
1850     case "$hardtop" in
1851     *' '*)
1852         AC_MSG_ERROR([
1853         The build system does not support building in a directory
1854         containing space characters.
1855         Suggestion: move the build tree somewhere else.])
1856         ;;
1857     esac
1858
1859     AC_SUBST(hardtop)
1860
1861     AC_MSG_RESULT($hardtop)
1862 ])
1863
1864 # GHC_CONVERT_CPU(cpu, target_var)
1865 # --------------------------------
1866 # converts cpu from gnu to ghc naming, and assigns the result to $target_var
1867 AC_DEFUN([GHC_CONVERT_CPU],[
1868 case "$1" in
1869   aarch64*)
1870     $2="aarch64"
1871     ;;
1872   alpha*)
1873     $2="alpha"
1874     ;;
1875   arm*)
1876     $2="arm"
1877     ;;
1878   hppa1.1*)
1879     $2="hppa1_1"
1880     ;;
1881   hppa*)
1882     $2="hppa"
1883     ;;
1884   i386|i486|i586|i686)
1885     $2="i386"
1886     ;;
1887   ia64)
1888     $2="ia64"
1889     ;;
1890   m68k*)
1891     $2="m68k"
1892     ;;
1893   mipseb*)
1894     $2="mipseb"
1895     ;;
1896   mipsel*)
1897     $2="mipsel"
1898     ;;
1899   mips*)
1900     $2="mips"
1901     ;;
1902   powerpc64le*)
1903     $2="powerpc64le"
1904     ;;
1905   powerpc64*)
1906     $2="powerpc64"
1907     ;;
1908   powerpc*)
1909     $2="powerpc"
1910     ;;
1911   rs6000)
1912     $2="rs6000"
1913     ;;
1914   s390x*)
1915     $2="s390x"
1916     ;;
1917   s390*)
1918     $2="s390"
1919     ;;
1920   sh4)
1921     $2="sh4"
1922     ;;
1923   sparc64*)
1924     $2="sparc64"
1925     ;;
1926   sparc*)
1927     $2="sparc"
1928     ;;
1929   vax)
1930     $2="vax"
1931     ;;
1932   x86_64|amd64)
1933     $2="x86_64"
1934     ;;
1935   *)
1936     echo "Unknown CPU $1"
1937     exit 1
1938     ;;
1939   esac
1940 ])
1941
1942 # GHC_CONVERT_VENDOR(vendor, target_var)
1943 # --------------------------------
1944 # converts vendor from gnu to ghc naming, and assigns the result to $target_var
1945 AC_DEFUN([GHC_CONVERT_VENDOR],[
1946   case "$1" in
1947   pc|gentoo|w64) # like i686-pc-linux-gnu, i686-gentoo-freebsd8, x86_64-w64-mingw32
1948     $2="unknown"
1949     ;;
1950   softfloat) # like armv5tel-softfloat-linux-gnueabi
1951     $2="unknown"
1952     ;;
1953   hardfloat) # like armv7a-hardfloat-linux-gnueabi
1954     $2="unknown"
1955     ;;
1956   *)
1957     #pass thru by default
1958     $2="$1"
1959     ;;
1960   esac
1961 ])
1962
1963 # GHC_CONVERT_OS(os, converted_cpu, target_var)
1964 # --------------------------------
1965 # converts os from gnu to ghc naming, and assigns the result to $target_var
1966 AC_DEFUN([GHC_CONVERT_OS],[
1967 case "$1-$2" in
1968   darwin10-arm|darwin11-i386|darwin14-aarch64|darwin14-x86_64)
1969     $3="ios"
1970     ;;
1971   *)
1972     case "$1" in
1973       linux-android*)
1974         $3="linux-android"
1975         ;;
1976       linux-*|linux)
1977         $3="linux"
1978         ;;
1979       # As far as I'm aware, none of these have relevant variants
1980       freebsd|netbsd|openbsd|dragonfly|hpux|linuxaout|kfreebsdgnu|freebsd2|solaris2|mingw32|darwin|gnu|nextstep2|nextstep3|sunos4|ultrix|haiku)
1981         $3="$1"
1982         ;;
1983       aix*) # e.g. powerpc-ibm-aix7.1.3.0
1984         $3="aix"
1985         ;;
1986       freebsd*) # like i686-gentoo-freebsd7
1987                 #      i686-gentoo-freebsd8
1988                 #      i686-gentoo-freebsd8.2
1989         $3="freebsd"
1990         ;;
1991       nto-qnx*)
1992         $3="nto-qnx"
1993         ;;
1994       *)
1995         echo "Unknown OS $1"
1996         exit 1
1997         ;;
1998       esac
1999       ;;
2000   esac
2001 ])
2002
2003 # BOOTSTRAPPING_GHC_INFO_FIELD
2004 # --------------------------------
2005 # Set the variable $1 to the value of the ghc --info field $2.
2006 AC_DEFUN([BOOTSTRAPPING_GHC_INFO_FIELD],[
2007 $1=`"$WithGhc" --info | grep "^ ,(\"$2\"," | sed -e 's/.*","//' -e 's/")$//'`
2008 tmp=${$1#\$topdir/}
2009 if test "${$1}" != "$tmp"
2010 then
2011     topdir=`"$WithGhc" --print-libdir | sed 's#\\\\#/#g'`
2012     $1="$topdir/$tmp"
2013 fi
2014 AC_SUBST($1)
2015 ])
2016
2017 # LIBRARY_VERSION(lib, [dir])
2018 # --------------------------------
2019 # Gets the version number of a library.
2020 # If $1 is ghc-prim, then we define LIBRARY_ghc_prim_VERSION as 1.2.3
2021 # $2 points to the directory under libraries/
2022 AC_DEFUN([LIBRARY_VERSION],[
2023 dir=m4_default([$2],[$1])
2024 LIBRARY_[]translit([$1], [-], [_])[]_VERSION=`grep -i "^version:" libraries/${dir}/$1.cabal | sed "s/.* //"`
2025 AC_SUBST(LIBRARY_[]translit([$1], [-], [_])[]_VERSION)
2026 ])
2027
2028 # XCODE_VERSION()
2029 # --------------------------------
2030 # Gets the version number of XCode, if on a Mac
2031 AC_DEFUN([XCODE_VERSION],[
2032     if test "$TargetOS_CPP" = "darwin"
2033     then
2034         AC_MSG_CHECKING(XCode version)
2035         XCodeVersion=`xcodebuild -version | grep Xcode | sed "s/Xcode //"`
2036         # Old XCode versions don't actually give the XCode version
2037         if test "$XCodeVersion" = ""
2038         then
2039             AC_MSG_RESULT(not found (too old?))
2040             XCodeVersion1=0
2041             XCodeVersion2=0
2042         else
2043             AC_MSG_RESULT($XCodeVersion)
2044             XCodeVersion1=`echo "$XCodeVersion" | sed 's/\..*//'`
2045             changequote(, )dnl
2046             XCodeVersion2=`echo "$XCodeVersion" | sed 's/[^.]*\.\([^.]*\).*/\1/'`
2047             changequote([, ])dnl
2048             AC_MSG_NOTICE(XCode version component 1: $XCodeVersion1)
2049             AC_MSG_NOTICE(XCode version component 2: $XCodeVersion2)
2050         fi
2051     fi
2052 ])
2053
2054 # FIND_LLVM_PROG()
2055 # --------------------------------
2056 # Find where the llvm tools are. We have a special function to handle when they
2057 # are installed with a version suffix (e.g., llc-3.1).
2058 #
2059 # $1 = the variable to set
2060 # $2 = the with option name
2061 # $3 = the command to look for
2062 # $4 = the version of the command to look for
2063 #
2064 AC_DEFUN([FIND_LLVM_PROG],[
2065     # Test for program with version name.
2066     FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL_NOTARGET([$1], [$2], [$3-$4])
2067     if test -z "$$1"; then
2068         # Test for program without version name.
2069         FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL_NOTARGET([$1], [$2], [$3])
2070         if test -n "$$1"; then
2071             AC_MSG_CHECKING([$$1 is version $4])
2072             if test `$$1 --version | grep -c "version $4"` -gt 0 ; then
2073                 AC_MSG_RESULT(yes)
2074             else
2075                 AC_MSG_RESULT(no)
2076                 $1=""
2077             fi
2078         fi
2079     fi
2080 ])
2081
2082 # FIND_LD
2083 # Find the version of `ld` to use. This is used in both in the top level
2084 # configure.ac and in distrib/configure.ac.in.
2085 #
2086 # $1 = the variable to set
2087 #
2088 AC_DEFUN([FIND_LD],[
2089     FP_ARG_WITH_PATH_GNU_PROG([LD], [ld], [ld])
2090     case $target in
2091         arm*linux*       | \
2092         aarch64*linux*   )
2093             # Arm and Aarch64 requires use of the binutils ld.gold linker.
2094             # This case should catch at least arm-unknown-linux-gnueabihf,
2095             # arm-linux-androideabi, arm64-unknown-linux and
2096             # aarch64-linux-android
2097             FP_ARG_WITH_PATH_GNU_PROG([LD_GOLD], [ld.gold], [ld.gold])
2098             $1="$LD_GOLD"
2099             ;;
2100         *)
2101             $1="$LD"
2102             ;;
2103     esac
2104 ])
2105
2106 # FIND_GHC_BOOTSTRAP_PROG()
2107 # --------------------------------
2108 # Parse the bootstrap GHC's compier settings file for the location of things
2109 # like the `llc` and `opt` commands.
2110 #
2111 # $1 = the variable to set
2112 # $2 = The bootstrap compiler.
2113 # $3 = The string to grep for to find the correct line.
2114 #
2115 AC_DEFUN([FIND_GHC_BOOTSTRAP_PROG],[
2116     BootstrapTmpCmd=`grep $3 $($2 --print-libdir)/settings 2>/dev/null | sed 's/.*", "//;s/".*//'`
2117     if test -n "$BootstrapTmpCmd" && test `basename $BootstrapTmpCmd` = $BootstrapTmpCmd ; then
2118         AC_PATH_PROG([$1], [$BootstrapTmpCmd], "")
2119     else
2120         $1=$BootstrapTmpCmd
2121     fi
2122 ])
2123
2124
2125 AC_DEFUN([MAYBE_OVERRIDE_STAGE0],[
2126   if test ! -z "$With_$1" -a "$CrossCompiling" != "YES"; then
2127       AC_MSG_NOTICE([Not cross-compiling, so --with-$1 also sets $2])
2128       $2=$With_$1
2129   fi
2130 ])
2131
2132
2133 # FP_CPP_CMD_WITH_ARGS()
2134 # ----------------------
2135 # sets CPP command and its arguments
2136 #
2137 # $1 = the variable to set to CPP command
2138 # $2 = the varibale to set to CPP command arguments
2139
2140 AC_DEFUN([FP_CPP_CMD_WITH_ARGS],[
2141 dnl ** what cpp to use?
2142 dnl --------------------------------------------------------------
2143 AC_ARG_WITH(hs-cpp,
2144 [AC_HELP_STRING([--with-hs-cpp=ARG],
2145       [Path to the (C) preprocessor for Haskell files [default=autodetect]])],
2146 [
2147     if test "$HostOS" = "mingw32"
2148     then
2149         AC_MSG_WARN([Request to use $withval will be ignored])
2150     else
2151         HS_CPP_CMD=$withval
2152     fi
2153 ],
2154 [
2155
2156     # We can't use $CPP here, since HS_CPP_CMD is expected to be a single
2157     # command (no flags), and AC_PROG_CPP defines CPP as "/usr/bin/gcc -E".
2158     HS_CPP_CMD=$CC
2159
2160     SOLARIS_GCC_CPP_BROKEN=NO
2161     SOLARIS_FOUND_GOOD_CPP=NO
2162     case $host in
2163         i386-*-solaris2)
2164         GCC_MAJOR_MINOR=`$CC --version|grep "gcc (GCC)"|cut -d ' ' -f 3-3|cut -d '.' -f 1-2`
2165         if test "$GCC_MAJOR_MINOR" != "3.4"; then
2166           # this is not 3.4.x release so with broken CPP
2167           SOLARIS_GCC_CPP_BROKEN=YES
2168         fi
2169         ;;
2170     esac
2171
2172     if test "$SOLARIS_GCC_CPP_BROKEN" = "YES"; then
2173       # let's try to find if GNU C 3.4.x is installed
2174       if test -x /usr/sfw/bin/gcc; then
2175         # something executable is in expected path so let's
2176         # see if it's really GNU C
2177         NEW_GCC_MAJOR_MINOR=`/usr/sfw/bin/gcc --version|grep "gcc (GCC)"|cut -d ' ' -f 3-3|cut -d '.' -f 1-2`
2178         if test "$NEW_GCC_MAJOR_MINOR" = "3.4"; then
2179           # this is GNU C 3.4.x which provides non-broken CPP on Solaris
2180           # let's use it as CPP then.
2181           HS_CPP_CMD=/usr/sfw/bin/gcc
2182           SOLARIS_FOUND_GOOD_CPP=YES
2183         fi
2184       fi
2185       if test "$SOLARIS_FOUND_GOOD_CPP" = "NO"; then
2186         AC_MSG_WARN([Your GNU C provides broken CPP and you do not have GNU C 3.4.x installed.])
2187         AC_MSG_WARN([Please install GNU C 3.4.x to solve this issue. It will be used as CPP only.])
2188       fi
2189     fi
2190 ]
2191 )
2192
2193
2194
2195 dnl ** what cpp flags to use?
2196 dnl -----------------------------------------------------------
2197 AC_ARG_WITH(hs-cpp-flags,
2198   [AC_HELP_STRING([--with-hs-cpp-flags=ARG],
2199       [Flags to the (C) preprocessor for Haskell files [default=autodetect]])],
2200   [
2201       if test "$HostOS" = "mingw32"
2202       then
2203           AC_MSG_WARN([Request to use $withval will be ignored])
2204       else
2205           HS_CPP_ARGS=$withval
2206       fi
2207   ],
2208 [
2209   $HS_CPP_CMD -x c /dev/null -dM -E > conftest.txt 2>&1
2210   if grep "__clang__" conftest.txt >/dev/null 2>&1; then
2211     HS_CPP_ARGS="-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs"
2212   else
2213       $HS_CPP_CMD  -v > conftest.txt 2>&1
2214       if  grep "gcc" conftest.txt >/dev/null 2>&1; then
2215           HS_CPP_ARGS="-E -undef -traditional"
2216         else
2217           $HS_CPP_CMD  --version > conftest.txt 2>&1
2218           if grep "cpphs" conftest.txt >/dev/null 2>&1; then
2219             HS_CPP_ARGS="--cpp -traditional"
2220           else
2221             AC_MSG_WARN([configure can't recognize your CPP program, you may need to set --with-hs-cpp-flags=FLAGS explicitly])
2222             HS_CPP_ARGS=""
2223           fi
2224       fi
2225   fi
2226   ]
2227 )
2228
2229 $1=$HS_CPP_CMD
2230 $2=$HS_CPP_ARGS
2231
2232 ])
2233
2234 # FP_BFD_SUPPORT()
2235 # ----------------------
2236 # whether to use libbfd for debugging RTS
2237 AC_DEFUN([FP_BFD_SUPPORT], [
2238     AC_ARG_ENABLE(bfd-debug,
2239         [AC_HELP_STRING([--enable-bfd-debug],
2240               [Enable symbol resolution for -debug rts ('+RTS -Di') via binutils' libbfd [default=no]])],
2241         [
2242             # don't pollute general LIBS environment
2243             save_LIBS="$LIBS"
2244             AC_CHECK_HEADERS([bfd.h])
2245             dnl ** check whether this machine has BFD and libiberty installed (used for debugging)
2246             dnl    the order of these tests matters: bfd needs libiberty
2247             AC_CHECK_LIB(iberty, xmalloc)
2248             dnl 'bfd_init' is a rare non-macro in libbfd
2249             AC_CHECK_LIB(bfd,    bfd_init)
2250
2251             AC_TRY_LINK([#include <bfd.h>],
2252                         [
2253                                 /* mimic our rts/Printer.c */
2254                                 bfd* abfd;
2255                                 const char * name;
2256                                 char **matching;
2257
2258                                 name = "some.executable";
2259                                 bfd_init();
2260                                 abfd = bfd_openr(name, "default");
2261                                 bfd_check_format_matches (abfd, bfd_object, &matching);
2262                                 {
2263                                     long storage_needed;
2264                                     storage_needed = bfd_get_symtab_upper_bound (abfd);
2265                                 }
2266                                 {
2267                                     asymbol **symbol_table;
2268                                     long number_of_symbols;
2269                                     symbol_info info;
2270
2271                                     number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
2272                                     bfd_get_symbol_info(abfd,symbol_table[0],&info);
2273                                 }
2274                         ],
2275                         [],dnl bfd seems to work
2276                         [AC_MSG_ERROR([can't use 'bfd' library])])
2277             LIBS="$save_LIBS"
2278         ]
2279     )
2280 ])
2281
2282 # LocalWords:  fi