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