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