Add network submodule.
[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|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)
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_SUBST([CabalLeadingUnderscore],[True])
862    AC_DEFINE([LEADING_UNDERSCORE], [1], [Define to 1 if C symbols have a leading underscore added by the compiler.])
863 else
864    AC_SUBST([CabalLeadingUnderscore],[False])
865 fi
866 ])# FP_LEADING_UNDERSCORE
867
868
869 # FP_COMPARE_VERSIONS(VERSION1, TEST, VERSION2, [ACTION-IF-TRUE], [ACTION-IF-FALSE])
870 # ----------------------------------------------------------------------------------
871 # Compare dotted version numbers VERSION1 and VERSION2 lexicographically according
872 # to TEST (one of -eq, -ne, -lt, -le, -gt, or -ge).
873 AC_DEFUN([FP_COMPARE_VERSIONS],
874 [fp_version1=$1; fp_version2=$3
875 fp_save_IFS=$IFS; IFS='.'
876 while test x"$fp_version1" != x || test x"$fp_version2" != x
877 do
878
879   set dummy $fp_version1; shift
880   fp_num1=""
881   test $[@%:@] = 0 || { fp_num1="[$]1"; shift; }
882   test x"$fp_num1" = x && fp_num1="0"
883   fp_version1="[$]*"
884
885   set dummy $fp_version2; shift
886   fp_num2=""
887   test $[@%:@] = 0 || { fp_num2="[$]1"; shift; }
888   test x"$fp_num2" = x && fp_num2="0"
889   fp_version2="[$]*"
890
891   test "$fp_num1" = "$fp_num2" || break;
892 done
893 IFS=$fp_save_IFS
894 AS_IF([test "$fp_num1" $2 "$fp_num2"], [$4], [$5])[]dnl
895 ])# FP_COMPARE_VERSIONS
896
897
898 dnl
899 dnl Check for Happy and version.
900 dnl If there's no installed Happy, we look
901 dnl for a happy source tree and point the build system at that instead.
902 dnl If you increase the minimum version requirement, please also update:
903 dnl https://ghc.haskell.org/trac/ghc/wiki/Building/Preparation/Tools
904 dnl
905 AC_DEFUN([FPTOOLS_HAPPY],
906 [AC_PATH_PROG(HappyCmd,happy,)
907
908 AC_CACHE_CHECK([for version of happy], fptools_cv_happy_version,
909 changequote(, )dnl
910 [if test x"$HappyCmd" != x; then
911    fptools_cv_happy_version=`"$HappyCmd" -v |
912               grep 'Happy Version' | sed -e 's/Happy Version \([^ ]*\).*/\1/g'` ;
913 else
914    fptools_cv_happy_version="";
915 fi;
916 changequote([, ])dnl
917 ])
918 if test ! -f compiler/parser/Parser.hs || test ! -f compiler/cmm/CmmParse.hs
919 then
920     FP_COMPARE_VERSIONS([$fptools_cv_happy_version],[-lt],[1.19.4],
921       [AC_MSG_ERROR([Happy version 1.19.4 or later is required to compile GHC.])])[]
922 fi
923 HappyVersion=$fptools_cv_happy_version;
924 AC_SUBST(HappyVersion)
925 ])
926
927 dnl
928 dnl Check for Alex and version.
929 dnl If you increase the minimum version requirement, please also update:
930 dnl https://ghc.haskell.org/trac/ghc/wiki/Building/Preparation/Tools
931 dnl
932 AC_DEFUN([FPTOOLS_ALEX],
933 [
934 AC_PATH_PROG(AlexCmd,alex,)
935
936 AC_CACHE_CHECK([for version of alex], fptools_cv_alex_version,
937 changequote(, )dnl
938 [if test x"$AlexCmd" != x; then
939    fptools_cv_alex_version=`"$AlexCmd" -v |
940               grep 'Alex [Vv]ersion' | sed -e 's/Alex [Vv]ersion \([0-9\.]*\).*/\1/g'` ;
941 else
942    fptools_cv_alex_version="";
943 fi;
944 changequote([, ])dnl
945 ])
946 FP_COMPARE_VERSIONS([$fptools_cv_alex_version],[-ge],[3.0],
947   [Alex3=YES],[Alex3=NO])
948 if test ! -f compiler/cmm/CmmLex.hs || test ! -f compiler/parser/Lexer.hs
949 then
950     FP_COMPARE_VERSIONS([$fptools_cv_alex_version],[-lt],[3.1.0],
951       [AC_MSG_ERROR([Alex version 3.1.0 or later is required to compile GHC.])])[]
952 fi
953 AlexVersion=$fptools_cv_alex_version;
954 AC_SUBST(AlexVersion)
955 AC_SUBST(Alex3)
956 ])
957
958
959 # FP_PROG_LD_FLAG
960 # ---------------
961 # Sets the output variable $2 to $1 if ld supports the $1 flag.
962 # Otherwise the variable's value is empty.
963 AC_DEFUN([FP_PROG_LD_FLAG],
964 [
965 AC_CACHE_CHECK([whether ld understands $1], [fp_cv_$2],
966 [echo 'int foo() { return 0; }' > conftest.c
967 ${CC-cc} -c conftest.c
968 if ${LdCmd} -r $1 -o conftest2.o conftest.o > /dev/null 2>&1; then
969    fp_cv_$2=$1
970 else
971    fp_cv_$2=
972 fi
973 rm -rf conftest*])
974 $2=$fp_cv_$2
975 ])# FP_PROG_LD_FLAG
976
977
978 # FP_PROG_LD_BUILD_ID
979 # ------------
980
981 # Sets the output variable LdHasBuildId to YES if ld supports
982 # --build-id, or NO otherwise.
983 AC_DEFUN([FP_PROG_LD_BUILD_ID],
984 [
985 AC_CACHE_CHECK([whether ld understands --build-id], [fp_cv_ld_build_id],
986 [echo 'int foo() { return 0; }' > conftest.c
987 ${CC-cc} -c conftest.c
988 if ${LdCmd} -r --build-id=none -o conftest2.o conftest.o > /dev/null 2>&1; then
989    fp_cv_ld_build_id=yes
990 else
991    fp_cv_ld_build_id=no
992 fi
993 rm -rf conftest*])
994 if test "$fp_cv_ld_build_id" = yes; then
995   LdHasBuildId=YES
996 else
997   LdHasBuildId=NO
998 fi
999 AC_SUBST([LdHasBuildId])
1000 ])# FP_PROG_LD_BUILD_ID
1001
1002
1003 # FP_PROG_LD_IS_GNU
1004 # -----------------
1005 # Sets the output variable LdIsGNULd to YES or NO, depending on whether it is
1006 # GNU ld or not.
1007 AC_DEFUN([FP_PROG_LD_IS_GNU],[
1008 AC_CACHE_CHECK([whether ld is GNU ld], [fp_cv_gnu_ld],
1009 [[if ${LdCmd} --version 2> /dev/null | grep "GNU" > /dev/null 2>&1; then
1010   fp_cv_gnu_ld=YES
1011 else
1012   fp_cv_gnu_ld=NO
1013 fi]])
1014 AC_SUBST([LdIsGNULd],["$fp_cv_gnu_ld"])
1015 ])# FP_PROG_LD_IS_GNU
1016
1017
1018 # FP_PROG_LD_NO_COMPACT_UNWIND
1019 # ----------------------------
1020
1021 # Sets the output variable LdHasNoCompactUnwind to YES if ld supports
1022 # -no_compact_unwind, or NO otherwise.
1023 AC_DEFUN([FP_PROG_LD_NO_COMPACT_UNWIND],
1024 [
1025 AC_CACHE_CHECK([whether ld understands -no_compact_unwind], [fp_cv_ld_no_compact_unwind],
1026 [echo 'int foo() { return 0; }' > conftest.c
1027 ${CC-cc} -c conftest.c
1028 if ${LdCmd} -r -no_compact_unwind -o conftest2.o conftest.o > /dev/null 2>&1; then
1029    fp_cv_ld_no_compact_unwind=yes
1030 else
1031    fp_cv_ld_no_compact_unwind=no
1032 fi
1033 rm -rf conftest*])
1034 if test "$fp_cv_ld_no_compact_unwind" = yes; then
1035   LdHasNoCompactUnwind=YES
1036 else
1037   LdHasNoCompactUnwind=NO
1038 fi
1039 AC_SUBST([LdHasNoCompactUnwind])
1040 ])# FP_PROG_LD_NO_COMPACT_UNWIND
1041
1042
1043 # FP_PROG_LD_FILELIST
1044 # -------------------
1045
1046 # Sets the output variable LdHasFilelist to YES if ld supports
1047 # -filelist, or NO otherwise.
1048 AC_DEFUN([FP_PROG_LD_FILELIST],
1049 [
1050 AC_CACHE_CHECK([whether ld understands -filelist], [fp_cv_ld_has_filelist],
1051 [
1052     echo 'int foo() { return 0; }' > conftest1.c
1053     echo 'int bar() { return 0; }' > conftest2.c
1054     ${CC-cc} -c conftest1.c
1055     ${CC-cc} -c conftest2.c
1056     echo conftest1.o  > conftest.o-files
1057     echo conftest2.o >> conftest.o-files
1058     if ${LdCmd} -r -filelist conftest.o-files -o conftest.o > /dev/null 2>&1
1059     then
1060         fp_cv_ld_has_filelist=yes
1061     else
1062         fp_cv_ld_has_filelist=no
1063     fi
1064     rm -rf conftest*
1065 ])
1066 if test "$fp_cv_ld_has_filelist" = yes; then
1067     LdHasFilelist=YES
1068 else
1069     LdHasFilelist=NO
1070 fi
1071 AC_SUBST([LdHasFilelist])
1072 ])# FP_PROG_LD_FILELIST
1073
1074
1075 # FP_PROG_AR
1076 # ----------
1077 # Sets fp_prog_ar to a path to ar. Exits if no ar can be found
1078 # The host normalization on Windows breaks autoconf, it no longer
1079 # thinks that target == host so it never checks the unqualified
1080 # tools for Windows. See #14274.
1081 AC_DEFUN([FP_PROG_AR],
1082 [if test -z "$fp_prog_ar"; then
1083   if test "$HostOS" = "mingw32"
1084   then
1085     AC_PATH_PROG([fp_prog_ar], [ar])
1086     if test -n "$fp_prog_ar"; then
1087       fp_prog_ar=$(cygpath -m $fp_prog_ar)
1088     fi
1089   else
1090     AC_CHECK_TARGET_TOOL([fp_prog_ar], [ar])
1091   fi
1092 fi
1093 if test -z "$fp_prog_ar"; then
1094   AC_MSG_ERROR([cannot find ar in your PATH, no idea how to make a library])
1095 fi
1096 ])# FP_PROG_AR
1097
1098
1099 # FP_PROG_AR_IS_GNU
1100 # -----------------
1101 # Sets fp_prog_ar_is_gnu to yes or no, depending on whether it is GNU ar or not.
1102 AC_DEFUN([FP_PROG_AR_IS_GNU],
1103 [AC_REQUIRE([FP_PROG_AR])
1104 AC_CACHE_CHECK([whether $fp_prog_ar is GNU ar], [fp_cv_prog_ar_is_gnu],
1105 [if "$fp_prog_ar" --version 2> /dev/null | grep "GNU" > /dev/null 2>&1; then
1106   fp_cv_prog_ar_is_gnu=yes
1107 else
1108   fp_cv_prog_ar_is_gnu=no
1109 fi])
1110 fp_prog_ar_is_gnu=$fp_cv_prog_ar_is_gnu
1111 AC_SUBST([ArIsGNUAr], [`echo $fp_prog_ar_is_gnu | tr 'a-z' 'A-Z'`])
1112 ])# FP_PROG_AR_IS_GNU
1113
1114
1115 # FP_PROG_AR_SUPPORTS_ATFILE
1116 # -----------------
1117 # Sets fp_prog_ar_supports_atfile to yes or no, depending on whether
1118 # or not it supports the @file syntax
1119 AC_DEFUN([FP_PROG_AR_SUPPORTS_ATFILE],
1120 [AC_REQUIRE([FP_PROG_AR])
1121  AC_REQUIRE([FP_PROG_AR_ARGS])
1122 AC_CACHE_CHECK([whether $fp_prog_ar supports @file], [fp_cv_prog_ar_supports_atfile],
1123 [
1124 rm -f conftest*
1125 touch conftest.file
1126 echo conftest.file  > conftest.atfile
1127 echo conftest.file >> conftest.atfile
1128 "$fp_prog_ar" $fp_prog_ar_args conftest.a @conftest.atfile > /dev/null 2>&1
1129 fp_prog_ar_supports_atfile_tmp=`"$fp_prog_ar" t conftest.a 2> /dev/null | grep -c conftest.file`
1130 rm -f conftest*
1131 if test "$fp_prog_ar_supports_atfile_tmp" -eq 2
1132 then
1133   fp_cv_prog_ar_supports_atfile=yes
1134 else
1135   fp_cv_prog_ar_supports_atfile=no
1136 fi])
1137 fp_prog_ar_supports_atfile=$fp_cv_prog_ar_supports_atfile
1138 AC_SUBST([ArSupportsAtFile], [`echo $fp_prog_ar_supports_atfile | tr 'a-z' 'A-Z'`])
1139 ])# FP_PROG_AR_SUPPORTS_ATFILE
1140
1141 # FP_PROG_AR_ARGS
1142 # ---------------
1143 # Sets fp_prog_ar_args to the arguments for ar and the output variable ArCmd
1144 # to an invocation of ar including these arguments.
1145 AC_DEFUN([FP_PROG_AR_ARGS],
1146 [AC_REQUIRE([FP_PROG_AR_IS_GNU])
1147 AC_CACHE_CHECK([for ar arguments], [fp_cv_prog_ar_args],
1148 [
1149 # GNU ar needs special treatment: it appears to have problems with
1150 # object files with the same name if you use the 's' modifier, but
1151 # simple 'ar q' works fine, and doesn't need a separate ranlib.
1152 if test $fp_prog_ar_is_gnu = yes; then
1153   fp_cv_prog_ar_args="q"
1154 else
1155   touch conftest.dummy
1156   for fp_var in qclsZ qcls qcs qcl qc ; do
1157      rm -f conftest.a
1158      if "$fp_prog_ar" $fp_var conftest.a conftest.dummy > /dev/null 2> /dev/null ; then
1159        # Also check that a result was created; it seems some llvm-ar versions
1160        # exit with code zero even if they fail to parse the command line.
1161        if test -f conftest.a ; then
1162          fp_cv_prog_ar_args=$fp_var
1163          break
1164        fi
1165      fi
1166   done
1167   rm -f conftest*
1168   if test -z "$fp_cv_prog_ar_args"; then
1169     AC_MSG_ERROR([cannot figure out how to use your $fp_prog_ar])
1170   fi
1171 fi])
1172 fp_prog_ar_args=$fp_cv_prog_ar_args
1173 AC_SUBST([ArCmd], ["$fp_prog_ar"])
1174 AC_SUBST([ArArgs], ["$fp_prog_ar_args"])
1175
1176 ])# FP_PROG_AR_ARGS
1177
1178
1179 # FP_PROG_AR_NEEDS_RANLIB
1180 # -----------------------
1181 # Sets the output variable RANLIB_CMD to "ranlib" if it is needed and
1182 # found, to "true" otherwise. Sets REAL_RANLIB_CMD to the ranlib program,
1183 # even if we don't need ranlib (libffi might still need it).
1184 AC_DEFUN([FP_PROG_AR_NEEDS_RANLIB],[
1185     AC_REQUIRE([FP_PROG_AR_IS_GNU])
1186     AC_REQUIRE([FP_PROG_AR_ARGS])
1187     AC_REQUIRE([AC_PROG_CC])
1188
1189     AC_PROG_RANLIB
1190
1191     if test $fp_prog_ar_is_gnu = yes
1192     then
1193         fp_cv_prog_ar_needs_ranlib=no
1194     elif test "$TargetVendor_CPP" = "apple"
1195     then
1196         # It's quite tedious to check for Apple's crazy timestamps in
1197         # .a files, so we hardcode it.
1198         fp_cv_prog_ar_needs_ranlib=yes
1199     else
1200         case $fp_prog_ar_args in
1201         *s*)
1202             fp_cv_prog_ar_needs_ranlib=no;;
1203         *)
1204             fp_cv_prog_ar_needs_ranlib=yes;;
1205         esac
1206     fi
1207
1208     # workaround for AC_PROG_RANLIB which sets RANLIB to `:' when
1209     # ranlib is missing on the target OS. The problem is that
1210     # ghc-cabal cannot execute `:' which is a shell built-in but can
1211     # execute `true' which is usually simple program supported by the
1212     # OS.
1213     # Fixes #8795
1214     if test "$RANLIB" = ":"
1215     then
1216         RANLIB="true"
1217     fi
1218     REAL_RANLIB_CMD="$RANLIB"
1219     if test $fp_cv_prog_ar_needs_ranlib = yes
1220     then
1221         RANLIB_CMD="$RANLIB"
1222     else
1223         RANLIB_CMD="true"
1224     fi
1225     AC_SUBST([REAL_RANLIB_CMD])
1226     AC_SUBST([RANLIB_CMD])
1227 ])# FP_PROG_AR_NEEDS_RANLIB
1228
1229
1230 # FP_GCC_VERSION
1231 # -----------
1232 # Extra testing of the result AC_PROG_CC, testing the gcc version no. Sets the
1233 # output variable GccVersion.
1234 AC_DEFUN([FP_GCC_VERSION],
1235 [AC_REQUIRE([AC_PROG_CC])
1236 if test -z "$CC"
1237 then
1238   AC_MSG_ERROR([gcc is required])
1239 fi
1240 GccLT46=NO
1241 AC_CACHE_CHECK([version of gcc], [fp_cv_gcc_version],
1242 [
1243     # Be sure only to look at the first occurrence of the "version " string;
1244     # Some Apple compilers emit multiple messages containing this string.
1245     fp_cv_gcc_version="`$CC -v 2>&1 | sed -n -e '1,/version /s/.*version [[^0-9]]*\([[0-9.]]*\).*/\1/p'`"
1246     FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-lt], [4.4],
1247                         [AC_MSG_ERROR([Need at least gcc version 4.4 (4.7+ recommended)])])
1248     FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-lt], [4.6], GccLT46=YES)
1249 ])
1250 AC_SUBST([GccVersion], [$fp_cv_gcc_version])
1251 AC_SUBST(GccLT46)
1252 ])# FP_GCC_VERSION
1253
1254 dnl Check to see if the C compiler is clang or llvm-gcc
1255 dnl
1256 GccIsClang=NO
1257 AC_DEFUN([FP_CC_LLVM_BACKEND],
1258 [AC_REQUIRE([AC_PROG_CC])
1259 AC_MSG_CHECKING([whether C compiler is clang])
1260 $CC -x c /dev/null -dM -E > conftest.txt 2>&1
1261 if grep "__clang__" conftest.txt >/dev/null 2>&1; then
1262   AC_SUBST([CC_CLANG_BACKEND], [1])
1263   AC_SUBST([CC_LLVM_BACKEND], [1])
1264   GccIsClang=YES
1265   AC_MSG_RESULT([yes])
1266 else
1267   AC_MSG_RESULT([no])
1268   AC_MSG_CHECKING([whether C compiler has an LLVM back end])
1269   if grep "__llvm__" conftest.txt >/dev/null 2>&1; then
1270     AC_SUBST([CC_CLANG_BACKEND], [0])
1271     AC_SUBST([CC_LLVM_BACKEND], [1])
1272     AC_MSG_RESULT([yes])
1273   else
1274     AC_SUBST([CC_CLANG_BACKEND], [0])
1275     AC_SUBST([CC_LLVM_BACKEND], [0])
1276     AC_MSG_RESULT([no])
1277   fi
1278 fi
1279 AC_SUBST(GccIsClang)
1280
1281 rm -f conftest.txt
1282 ])
1283
1284 # FP_GCC_SUPPORTS__ATOMICS
1285 # ------------------------
1286 # Does gcc support the __atomic_* family of builtins?
1287 AC_DEFUN([FP_GCC_SUPPORTS__ATOMICS],
1288 [
1289    AC_REQUIRE([AC_PROG_CC])
1290    AC_MSG_CHECKING([whether GCC supports __atomic_ builtins])
1291    echo 'int test(int *x) { int y; __atomic_load(&x, &y, __ATOMIC_SEQ_CST); return x; }' > conftest.c
1292    if $CC -c conftest.c > /dev/null 2>&1; then
1293        CONF_GCC_SUPPORTS__ATOMICS=YES
1294        AC_MSG_RESULT([yes])
1295    else
1296        CONF_GCC_SUPPORTS__ATOMICS=NO
1297        AC_MSG_RESULT([no])
1298    fi
1299    rm -f conftest.c conftest.o
1300 ])
1301
1302 # FP_GCC_SUPPORTS_NO_PIE
1303 # ----------------------
1304 # Does gcc support the -no-pie option? If so we should pass it to gcc when
1305 # joining objects since -pie may be enabled by default.
1306 AC_DEFUN([FP_GCC_SUPPORTS_NO_PIE],
1307 [
1308    AC_REQUIRE([AC_PROG_CC])
1309    AC_MSG_CHECKING([whether GCC supports -no-pie])
1310    echo 'int main() { return 0; }' > conftest.c
1311    # Some GCC versions only warn when passed an unrecognized flag.
1312    if $CC -no-pie -x c /dev/null -dM -E > conftest.txt 2>&1 && ! grep -i unrecognized conftest.txt > /dev/null 2>&1; then
1313        CONF_GCC_SUPPORTS_NO_PIE=YES
1314        AC_MSG_RESULT([yes])
1315    else
1316        CONF_GCC_SUPPORTS_NO_PIE=NO
1317        AC_MSG_RESULT([no])
1318    fi
1319    rm -f conftest.c conftest.o conftest
1320 ])
1321
1322 dnl Small feature test for perl version. Assumes PerlCmd
1323 dnl contains path to perl binary.
1324 dnl
1325 dnl (Perl versions prior to v5.6 does not contain the string "v5";
1326 dnl instead they display version strings such as "version 5.005".)
1327 dnl
1328 AC_DEFUN([FPTOOLS_CHECK_PERL_VERSION],
1329 [$PerlCmd -v >conftest.out 2>&1
1330    if grep "v5" conftest.out >/dev/null 2>&1; then
1331       :
1332    else
1333       AC_MSG_ERROR([your version of perl probably won't work, try upgrading it.])
1334    fi
1335 rm -fr conftest*
1336 ])
1337
1338
1339 # FP_CHECK_PROG(VARIABLE, PROG-TO-CHECK-FOR,
1340 #               [VALUE-IF-NOT-FOUND], [PATH], [REJECT])
1341 # -----------------------------------------------------
1342 # HACK: A small wrapper around AC_CHECK_PROG, setting VARIABLE to the full path
1343 # of PROG-TO-CHECK-FOR when found.
1344 AC_DEFUN([FP_CHECK_PROG],
1345 [AC_CHECK_PROG([$1], [$2], [$as_dir/$ac_word$ac_exec_ext], [$3], [$4], [$5])][]dnl
1346 )# FP_CHECK_PROC
1347
1348
1349 # FP_PROG_FIND
1350 # ------------
1351 # Find a non-WinDoze version of the "find" utility.
1352 AC_DEFUN([FP_PROG_FIND],
1353 [AC_PATH_PROGS([fp_prog_find], [gfind find], find)
1354 echo foo > conftest.txt
1355 $fp_prog_find conftest.txt -print > conftest.out 2>&1
1356 if grep '^conftest.txt$' conftest.out > /dev/null 2>&1 ; then
1357   # OK, looks like a real "find".
1358   FindCmd="$fp_prog_find"
1359 else
1360   # Found a poor WinDoze version of "find", ignore it.
1361   AC_MSG_WARN([$fp_prog_find looks like a non-*nix find, ignoring it])
1362   FP_CHECK_PROG([FindCmd], [find], [], [], [$fp_prog_find])
1363 fi
1364 rm -f conftest.txt conftest.out
1365 AC_SUBST([FindCmd])[]dnl
1366 ])# FP_PROG_FIND
1367
1368
1369 # FP_PROG_SORT
1370 # ------------
1371 # Find a Unix-like sort
1372 AC_DEFUN([FP_PROG_SORT],
1373 [AC_PATH_PROG([fp_prog_sort], [sort])
1374 echo conwip > conftest.txt
1375 $fp_prog_sort -f conftest.txt > conftest.out 2>&1
1376 if grep 'conwip' conftest.out > /dev/null 2>&1 ; then
1377   # The goods
1378   SortCmd="$fp_prog_sort"
1379 else
1380   # Summink else..pick next one.
1381   AC_MSG_WARN([$fp_prog_sort looks like a non-*nix sort, ignoring it])
1382   FP_CHECK_PROG([SortCmd], [sort], [], [], [$fp_prog_sort])
1383 fi
1384 rm -f conftest.txt conftest.out
1385 AC_SUBST([SortCmd])[]dnl
1386 ])# FP_PROG_SORT
1387
1388
1389 dnl
1390 dnl FPTOOLS_NOCACHE_CHECK prints a message, then sets the
1391 dnl values of the second argument to the result of running
1392 dnl the commands given by the third. It does not cache its
1393 dnl result, so it is suitable for checks which should be
1394 dnl run every time.
1395 dnl
1396 AC_DEFUN([FPTOOLS_NOCACHE_CHECK],
1397 [AC_MSG_CHECKING([$1])
1398  $3
1399  AC_MSG_RESULT([$][$2])
1400 ])
1401
1402 dnl
1403 dnl FPTOOLS_GHC_VERSION(version)
1404 dnl FPTOOLS_GHC_VERSION(major, minor [, patchlevel])
1405 dnl FPTOOLS_GHC_VERSION(version, major, minor, patchlevel)
1406 dnl
1407 dnl Test for version of installed ghc.  Uses $GHC.
1408 dnl [original version pinched from c2hs]
1409 dnl
1410 AC_DEFUN([FPTOOLS_GHC_VERSION],
1411 [FPTOOLS_NOCACHE_CHECK([version of ghc], [fptools_version_of_ghc],
1412 ["${WithGhc-ghc}" --version > conftestghc 2>&1
1413   cat conftestghc >&AS_MESSAGE_LOG_FD
1414 #Useless Use Of cat award...
1415   fptools_version_of_ghc=`cat conftestghc | sed -n -e 's/, patchlevel *\([[0-9]]\)/.\1/;s/.* version \([[0-9]][[0-9.]]*\).*/\1/p'`
1416   rm -fr conftest*
1417   if test "[$]fptools_version_of_ghc" = ""
1418   then
1419     fptools_version_of_ghc='unknown'
1420   fi
1421 fptools_version_of_ghc[_major]=`echo [$]fptools_version_of_ghc | sed -e 's/^\([[0-9]]\).*/\1/'`
1422 fptools_version_of_ghc[_minor]=`echo [$]fptools_version_of_ghc | sed -e 's/^[[0-9]]\.\([[0-9]]*\).*/\1/'`
1423 fptools_version_of_ghc[_pl]=`echo [$]fptools_version_of_ghc | sed -n -e 's/^[[0-9]]\.[[0-9]]*\.\([[0-9]]*\)/\1/p'`
1424 #
1425 if test "[$]fptools_version_of_ghc[_pl]" = ""
1426 then
1427   fptools_version_of_ghc[_all]="[$]fptools_version_of_ghc[_major].[$]fptools_version_of_ghc[_minor]"
1428   fptools_version_of_ghc[_pl]="0"
1429 else
1430   fptools_version_of_ghc[_all]="[$]fptools_version_of_ghc[_major].[$]fptools_version_of_ghc[_minor].[$]fptools_version_of_ghc[_pl]"
1431 fi
1432 #
1433 ifelse($#, [1], [dnl
1434 [$1]="[$]fptools_version_of_ghc[_all]"
1435 ], $#, [2], [dnl
1436 [$1]="[$]fptools_version_of_ghc[_major]"
1437 [$2]="[$]fptools_version_of_ghc[_minor]"
1438 ], $#, [3], [dnl
1439 [$1]="[$]fptools_version_of_ghc[_major]"
1440 [$2]="[$]fptools_version_of_ghc[_minor]"
1441 [$3]="[$]fptools_version_of_ghc[_pl]"
1442 ], $#, [4], [dnl
1443 [$1]="[$]fptools_version_of_ghc[_all]"
1444 [$2]="[$]fptools_version_of_ghc[_major]"
1445 [$3]="[$]fptools_version_of_ghc[_minor]"
1446 [$4]="[$]fptools_version_of_ghc[_pl]"
1447 ])
1448 ])
1449 ])dnl
1450
1451
1452 # FP_CHECK_FUNC(FUNCTION, PROLOGUE, BODY, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1453 # ---------------------------------------------------------------------------------
1454 # A variant of AC_CHECK_FUNCS, limited to a single FUNCTION, but with the
1455 # additional flexibility of specifying the PROLOGUE and BODY.
1456 AC_DEFUN([FP_CHECK_FUNC],
1457 [AS_VAR_PUSHDEF([fp_func], [fp_cv_func_$1])dnl
1458 AC_CACHE_CHECK([for $1], fp_func,
1459 [AC_LINK_IFELSE([AC_LANG_PROGRAM([$2], [$3])],
1460                 [AS_VAR_SET(fp_func, yes)],
1461                 [AS_VAR_SET(fp_func, no)])])
1462 AS_IF([test AS_VAR_GET(fp_func) = yes],
1463       [AC_DEFINE(AS_TR_CPP(HAVE_$1), [1],
1464                 [Define to 1 if you have the `]$1[' function.]) $4],
1465       [$5])dnl
1466 AS_VAR_POPDEF([fp_func])dnl
1467 ])# FP_CHECK_FUNC
1468
1469 # FP_PROG_GHC_PKG
1470 # ----------------
1471 # Try to find a ghc-pkg matching the ghc mentioned in the environment variable
1472 # WithGhc. Sets the output variable GhcPkgCmd.
1473 AC_DEFUN([FP_PROG_GHC_PKG],
1474 [AC_CACHE_CHECK([for ghc-pkg matching $WithGhc], fp_cv_matching_ghc_pkg,
1475 [
1476 # If we are told to use ghc-stage2, then we're using an in-tree
1477 # compiler. In this case, we just want ghc-pkg, not ghc-pkg-stage2,
1478 # so we sed off -stage[0-9]$. However, if we are told to use
1479 # ghc-6.12.1 then we want to use ghc-pkg-6.12.1, so we keep any
1480 # other suffix.
1481 fp_ghc_pkg_guess=`echo "$WithGhc" | sed -e 's/-stage@<:@0-9@:>@$//' -e 's,ghc\(@<:@^/\\@:>@*\)$,ghc-pkg\1,'`
1482 if "$fp_ghc_pkg_guess" list > /dev/null 2>&1; then
1483   fp_cv_matching_ghc_pkg=$fp_ghc_pkg_guess
1484 else
1485   AC_MSG_ERROR([Cannot find matching ghc-pkg])
1486 fi])
1487 GhcPkgCmd=$fp_cv_matching_ghc_pkg
1488 AC_SUBST([GhcPkgCmd])
1489 ])# FP_PROG_GHC_PKG
1490
1491
1492 # FP_GCC_EXTRA_FLAGS
1493 # ------------------
1494 # Determine which extra flags we need to pass gcc when we invoke it
1495 # to compile .hc code.
1496 #
1497 # -fwrapv is needed for gcc to emit well-behaved code in the presence of
1498 # integer wrap around. (Trac #952)
1499 #
1500 AC_DEFUN([FP_GCC_EXTRA_FLAGS],
1501 [AC_REQUIRE([FP_GCC_VERSION])
1502 AC_CACHE_CHECK([for extra options to pass gcc when compiling via C], [fp_cv_gcc_extra_opts],
1503 [fp_cv_gcc_extra_opts=
1504  FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-ge], [3.4],
1505   [fp_cv_gcc_extra_opts="$fp_cv_gcc_extra_opts -fwrapv"],
1506   [])
1507  FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-ge], [4.0],
1508   [fp_cv_gcc_extra_opts="$fp_cv_gcc_extra_opts -fno-builtin"],
1509   [])
1510 ])
1511 AC_SUBST([GccExtraViaCOpts],$fp_cv_gcc_extra_opts)
1512 ])
1513
1514
1515 # FP_SETUP_PROJECT_VERSION
1516 # ---------------------
1517 AC_DEFUN([FP_SETUP_PROJECT_VERSION],
1518 [
1519 if test "$RELEASE" = "NO"; then
1520     AC_MSG_CHECKING([for GHC version date])
1521     if test -f VERSION_DATE; then
1522         PACKAGE_VERSION=${PACKAGE_VERSION}.`cat VERSION_DATE`
1523         AC_MSG_RESULT(given $PACKAGE_VERSION)
1524     elif test -d .git; then
1525         changequote(, )dnl
1526         ver_posixtime=`git log -1 --pretty=format:%ct`
1527         ver_date=`perl -MPOSIX -e "print strftime('%Y%m%d', gmtime($ver_posixtime));"`
1528         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
1529         changequote([, ])dnl
1530                 AC_MSG_ERROR([failed to detect version date: check that git and perl are in your path])
1531         fi
1532         PACKAGE_VERSION=${PACKAGE_VERSION}.$ver_date
1533         AC_MSG_RESULT(inferred $PACKAGE_VERSION)
1534     elif test -f VERSION; then
1535         PACKAGE_VERSION=`cat VERSION`
1536         AC_MSG_RESULT(given $PACKAGE_VERSION)
1537     else
1538         AC_MSG_WARN([cannot determine snapshot version: no .git directory and no VERSION file])
1539         dnl We'd really rather this case didn't happen, but it might
1540         dnl do (in particular, people using lndir trees may find that
1541         dnl the build system can't find any other date). If it does
1542         dnl happen, then we use the current date.
1543         dnl This way we get some idea about how recent a build is.
1544         dnl It also means that packages built for 2 different builds
1545         dnl will probably use different version numbers, so things are
1546         dnl less likely to go wrong.
1547         PACKAGE_VERSION=${PACKAGE_VERSION}.`date +%Y%m%d`
1548     fi
1549 fi
1550
1551     AC_MSG_CHECKING([for GHC Git commit id])
1552     if test -d .git; then
1553         git_commit_id=`git rev-parse HEAD`
1554         if test -n "$git_commit_id" 2>&1 >/dev/null; then true; else
1555             AC_MSG_ERROR([failed to detect revision: check that git is in your path])
1556         fi
1557         PACKAGE_GIT_COMMIT_ID=$git_commit_id
1558         AC_MSG_RESULT(inferred $PACKAGE_GIT_COMMIT_ID)
1559     elif test -f GIT_COMMIT_ID; then
1560         PACKAGE_GIT_COMMIT_ID=`cat GIT_COMMIT_ID`
1561         AC_MSG_RESULT(given $PACKAGE_GIT_COMMIT_ID)
1562     else
1563         AC_MSG_WARN([cannot determine snapshot revision: no .git directory and no 'GIT_COMMIT_ID' file])
1564         PACKAGE_GIT_COMMIT_ID="0000000000000000000000000000000000000000"
1565     fi
1566
1567
1568 # Some renamings
1569 AC_SUBST([ProjectName], [$PACKAGE_NAME])
1570 AC_SUBST([ProjectVersion], [$PACKAGE_VERSION])
1571 AC_SUBST([ProjectGitCommitId], [$PACKAGE_GIT_COMMIT_ID])
1572
1573 # Split PACKAGE_VERSION into (possibly empty) parts
1574 VERSION_MAJOR=`echo $PACKAGE_VERSION | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\1'/`
1575 VERSION_TMP=`echo $PACKAGE_VERSION | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\3'/`
1576 VERSION_MINOR=`echo $VERSION_TMP | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\1'/`
1577 ProjectPatchLevel=`echo $VERSION_TMP | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\3'/`
1578
1579 # Calculate project version as an integer, using 2 digits for minor version
1580 case $VERSION_MINOR in
1581   ?) ProjectVersionInt=${VERSION_MAJOR}0${VERSION_MINOR} ;;
1582   ??) ProjectVersionInt=${VERSION_MAJOR}${VERSION_MINOR} ;;
1583   *) AC_MSG_ERROR([bad minor version in $PACKAGE_VERSION]) ;;
1584 esac
1585 AC_SUBST([ProjectVersionInt])
1586
1587 # The project patchlevel is zero unless stated otherwise
1588 test -z "$ProjectPatchLevel" && ProjectPatchLevel=0
1589
1590 # Save split version of ProjectPatchLevel
1591 ProjectPatchLevel1=`echo $ProjectPatchLevel | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\1/'`
1592 ProjectPatchLevel2=`echo $ProjectPatchLevel | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\3/'`
1593
1594 AC_SUBST([ProjectPatchLevel1])
1595 AC_SUBST([ProjectPatchLevel2])
1596
1597 # Remove dots from the patch level; this allows us to have versions like 6.4.1.20050508
1598 ProjectPatchLevel=`echo $ProjectPatchLevel | sed 's/\.//'`
1599
1600 AC_SUBST([ProjectPatchLevel])
1601
1602 # The version of the GHC package changes every day, since the
1603 # patchlevel is the current date.  We don't want to force
1604 # recompilation of the entire compiler when this happens, so for
1605 # GHC HEAD we omit the patchlevel from the package version number.
1606 #
1607 # The ProjectPatchLevel1 > 20000000 iff GHC HEAD. If it's for a stable
1608 # release like 7.10.1 or for a release candidate such as 7.10.1.20141224
1609 # then we don't omit the patchlevel components.
1610
1611 ProjectVersionMunged="$ProjectVersion"
1612 if test "$ProjectPatchLevel1" -gt 20000000; then
1613   ProjectVersionMunged="${VERSION_MAJOR}.${VERSION_MINOR}"
1614 fi
1615 AC_SUBST([ProjectVersionMunged])
1616 ])# FP_SETUP_PROJECT_VERSION
1617
1618 # Check for a working timer_create().  We need a pretty detailed check
1619 # here, because there exist partially-working implementations of
1620 # timer_create() in certain versions of Linux (see bug #1933).
1621 #
1622 AC_DEFUN([FP_CHECK_TIMER_CREATE],[
1623 AC_CHECK_FUNC([timer_create],[HAVE_timer_create=yes],[HAVE_timer_create=no])
1624
1625 if test "$HAVE_timer_create" = "yes"
1626 then
1627   if test "$cross_compiling" = "yes"
1628   then
1629     # We can't test timer_create when we're cross-compiling, so we
1630     # optimistiaclly assume that it actually works properly.
1631     AC_DEFINE([USE_TIMER_CREATE], 1,  [Define to 1 if we can use timer_create(CLOCK_REALTIME,...)])
1632   else
1633   AC_CACHE_CHECK([for a working timer_create(CLOCK_REALTIME)],
1634     [fptools_cv_timer_create_works],
1635     [AC_TRY_RUN([
1636 #include <stdio.h>
1637 #ifdef HAVE_STDLIB_H
1638 #include <stdlib.h>
1639 #endif
1640 #ifdef HAVE_TIME_H
1641 #include <time.h>
1642 #endif
1643 #ifdef HAVE_SIGNAL_H
1644 #include <signal.h>
1645 #endif
1646 #ifdef HAVE_UNISTD_H
1647 #include <unistd.h>
1648 #endif
1649
1650 static volatile int tock = 0;
1651 static void handler(int i)
1652 {
1653    tock = 1;
1654 }
1655
1656 static void timeout(int i)
1657 {
1658   // timer_settime() has been known to hang, so just in case
1659   // we install a 1-second timeout (see #2257)
1660   exit(99);
1661 }
1662
1663 int main(int argc, char *argv[])
1664 {
1665
1666     struct sigevent ev;
1667     timer_t timer;
1668     struct itimerspec it;
1669     struct sigaction action;
1670     int m,n,count = 0;
1671
1672     ev.sigev_notify = SIGEV_SIGNAL;
1673     ev.sigev_signo  = SIGVTALRM;
1674
1675     action.sa_handler = handler;
1676     action.sa_flags = 0;
1677     sigemptyset(&action.sa_mask);
1678     if (sigaction(SIGVTALRM, &action, NULL) == -1) {
1679         fprintf(stderr,"SIGVTALRM problem\n");
1680         exit(3);
1681     }
1682
1683     action.sa_handler = timeout;
1684     action.sa_flags = 0;
1685     sigemptyset(&action.sa_mask);
1686     if (sigaction(SIGALRM, &action, NULL) == -1) {
1687       fprintf(stderr,"SIGALRM problem\n");
1688       exit(3);
1689     }
1690     alarm(1);
1691
1692     if (timer_create(CLOCK_REALTIME, &ev, &timer) != 0) {
1693         fprintf(stderr,"No CLOCK_REALTIME timer\n");
1694         exit(2);
1695     }
1696
1697     tock = 0;
1698
1699     it.it_value.tv_sec = 0;
1700     it.it_value.tv_nsec = 1000000; // 1ms
1701     it.it_interval = it.it_value;
1702     if (timer_settime(timer, 0, &it, NULL) != 0) {
1703         fprintf(stderr,"settime problem\n");
1704         exit(4);
1705     }
1706
1707     // some environments have coarse scheduler/timer granularity of ~10ms and worse
1708     usleep(100000); // 100ms
1709
1710     if (!tock) {
1711         fprintf(stderr,"no CLOCK_REALTIME signal\n");
1712         exit(5);
1713     }
1714
1715     timer_delete(timer);
1716
1717     exit(0);
1718 }
1719      ],
1720      [fptools_cv_timer_create_works=yes],
1721      [fptools_cv_timer_create_works=no])
1722   ])
1723 case $fptools_cv_timer_create_works in
1724     yes) AC_DEFINE([USE_TIMER_CREATE], 1,
1725                    [Define to 1 if we can use timer_create(CLOCK_REALTIME,...)]);;
1726 esac
1727   fi
1728 fi
1729 ])
1730
1731 # FP_ICONV
1732 # -------------
1733 AC_DEFUN([FP_ICONV],
1734 [
1735   dnl--------------------------------------------------------------------
1736   dnl * Deal with arguments telling us iconv is somewhere odd
1737   dnl--------------------------------------------------------------------
1738
1739   dnl Note: ICONV_LIB_DIRS and ICONV_INCLUDE_DIRS are not predefined
1740   dnl to the empty string to allow them to be overridden from the
1741   dnl environment.
1742
1743   AC_ARG_WITH([iconv-includes],
1744     [AC_HELP_STRING([--with-iconv-includes],
1745       [directory containing iconv.h])],
1746       [ICONV_INCLUDE_DIRS=$withval])
1747
1748   AC_ARG_WITH([iconv-libraries],
1749     [AC_HELP_STRING([--with-iconv-libraries],
1750       [directory containing iconv library])],
1751       [ICONV_LIB_DIRS=$withval])
1752
1753   AC_SUBST(ICONV_INCLUDE_DIRS)
1754   AC_SUBST(ICONV_LIB_DIRS)
1755 ])# FP_ICONV
1756
1757 # FP_GMP
1758 # -------------
1759 AC_DEFUN([FP_GMP],
1760 [
1761   dnl--------------------------------------------------------------------
1762   dnl * Deal with arguments telling us gmp is somewhere odd
1763   dnl--------------------------------------------------------------------
1764
1765   AC_ARG_WITH([gmp-includes],
1766     [AC_HELP_STRING([--with-gmp-includes],
1767       [directory containing gmp.h])],
1768       [GMP_INCLUDE_DIRS=$withval])
1769
1770   AC_ARG_WITH([gmp-libraries],
1771     [AC_HELP_STRING([--with-gmp-libraries],
1772       [directory containing gmp library])],
1773       [GMP_LIB_DIRS=$withval])
1774
1775   AC_SUBST(GMP_INCLUDE_DIRS)
1776   AC_SUBST(GMP_LIB_DIRS)
1777 ])# FP_GMP
1778
1779 # FP_CURSES
1780 # -------------
1781 AC_DEFUN([FP_CURSES],
1782 [
1783   dnl--------------------------------------------------------------------
1784   dnl * Deal with arguments telling us curses is somewhere odd
1785   dnl--------------------------------------------------------------------
1786
1787   AC_ARG_WITH([curses-libraries],
1788     [AC_HELP_STRING([--with-curses-libraries],
1789       [directory containing curses libraries])],
1790       [CURSES_LIB_DIRS=$withval])
1791
1792   AC_SUBST(CURSES_INCLUDE_DIRS)
1793   AC_SUBST(CURSES_LIB_DIRS)
1794 ])# FP_CURSES
1795
1796 # --------------------------------------------------------------
1797 # Calculate absolute path to build tree
1798 # --------------------------------------------------------------
1799
1800 AC_DEFUN([FP_FIND_ROOT],[
1801 AC_MSG_CHECKING(for path to top of build tree)
1802     if test "$windows" = YES
1803     then
1804       dnl Make sure this is a c:/foo/bar (mixed) style path. Some parts of
1805       dnl the build system might depend on it (such as the sed expression
1806       dnl `"s|$(TOP)/||i"` in addCFileDeps in rules/build-dependencies.mk).
1807       hardtop=$(cygpath -m "$(pwd)")
1808     else
1809       hardtop=$(pwd)
1810     fi
1811
1812     dnl Remove common automounter nonsense
1813     hardtop=`echo $hardtop | sed 's|^/tmp_mnt.*\(/local/.*\)$|\1|' | sed 's|^/tmp_mnt/|/|'`
1814
1815     if ! test -d "$hardtop"; then
1816         AC_MSG_ERROR([cannot determine current directory])
1817     fi
1818
1819     dnl We don't support building in directories with spaces.
1820     case "$hardtop" in
1821     *' '*)
1822         AC_MSG_ERROR([
1823         The build system does not support building in a directory
1824         containing space characters.
1825         Suggestion: move the build tree somewhere else.])
1826         ;;
1827     esac
1828
1829     AC_SUBST(hardtop)
1830
1831     AC_MSG_RESULT($hardtop)
1832 ])
1833
1834 # GHC_CONVERT_CPU(cpu, target_var)
1835 # --------------------------------
1836 # converts cpu from gnu to ghc naming, and assigns the result to $target_var
1837 AC_DEFUN([GHC_CONVERT_CPU],[
1838 case "$1" in
1839   aarch64*)
1840     $2="aarch64"
1841     ;;
1842   alpha*)
1843     $2="alpha"
1844     ;;
1845   arm*)
1846     $2="arm"
1847     ;;
1848   hppa1.1*)
1849     $2="hppa1_1"
1850     ;;
1851   hppa*)
1852     $2="hppa"
1853     ;;
1854   i386|i486|i586|i686)
1855     $2="i386"
1856     ;;
1857   ia64)
1858     $2="ia64"
1859     ;;
1860   m68k*)
1861     $2="m68k"
1862     ;;
1863   mipseb*)
1864     $2="mipseb"
1865     ;;
1866   mipsel*)
1867     $2="mipsel"
1868     ;;
1869   mips*)
1870     $2="mips"
1871     ;;
1872   powerpc64le*)
1873     $2="powerpc64le"
1874     ;;
1875   powerpc64*)
1876     $2="powerpc64"
1877     ;;
1878   powerpc*)
1879     $2="powerpc"
1880     ;;
1881   rs6000)
1882     $2="rs6000"
1883     ;;
1884   s390x*)
1885     $2="s390x"
1886     ;;
1887   s390*)
1888     $2="s390"
1889     ;;
1890   sh4)
1891     $2="sh4"
1892     ;;
1893   sparc64*)
1894     $2="sparc64"
1895     ;;
1896   sparc*)
1897     $2="sparc"
1898     ;;
1899   vax)
1900     $2="vax"
1901     ;;
1902   x86_64|amd64)
1903     $2="x86_64"
1904     ;;
1905   *)
1906     echo "Unknown CPU $1"
1907     exit 1
1908     ;;
1909   esac
1910 ])
1911
1912 # GHC_LLVM_TARGET(target_cpu, target_vendor, target_os, llvm_target_var)
1913 # --------------------------------
1914 # converts the canonicalized target into someting llvm can understand
1915 AC_DEFUN([GHC_LLVM_TARGET], [
1916   case "$2-$3" in
1917     hardfloat-*eabi)
1918       llvm_target_vendor="unknown"
1919       llvm_target_os="$3""hf"
1920       ;;
1921     *-mingw32|*-mingw64|*-msys)
1922       llvm_target_vendor="unknown"
1923       llvm_target_os="windows"
1924       ;;
1925     # retain any android and gnueabi linux flavours
1926     # for the LLVM Target. Otherwise these would be
1927     # turned into just `-linux` and fail to be found
1928     # in the `llvm-targets` file.
1929     *-android*|*-gnueabi*)
1930       GHC_CONVERT_VENDOR([$2],[llvm_target_vendor])
1931       llvm_target_os="$3"
1932       ;;
1933     *)
1934       GHC_CONVERT_VENDOR([$2],[llvm_target_vendor])
1935       GHC_CONVERT_OS([$3],[$1],[llvm_target_os])
1936       ;;
1937   esac
1938   $4="$1-$llvm_target_vendor-$llvm_target_os"
1939 ])
1940
1941
1942 # GHC_CONVERT_VENDOR(vendor, target_var)
1943 # --------------------------------
1944 # converts vendor from gnu to ghc naming, and assigns the result to $target_var
1945 AC_DEFUN([GHC_CONVERT_VENDOR],[
1946   case "$1" in
1947   pc|gentoo|w64) # like i686-pc-linux-gnu, i686-gentoo-freebsd8, x86_64-w64-mingw32
1948     $2="unknown"
1949     ;;
1950   softfloat) # like armv5tel-softfloat-linux-gnueabi
1951     $2="unknown"
1952     ;;
1953   hardfloat) # like armv7a-hardfloat-linux-gnueabi
1954     $2="unknown"
1955     ;;
1956   *)
1957     #pass thru by default
1958     $2="$1"
1959     ;;
1960   esac
1961 ])
1962
1963 # GHC_CONVERT_OS(os, converted_cpu, target_var)
1964 # --------------------------------
1965 # converts os from gnu to ghc naming, and assigns the result to $target_var
1966 AC_DEFUN([GHC_CONVERT_OS],[
1967     case "$1" in
1968       # watchos and tvos are ios variants as of May 2017.
1969       ios|watchos|tvos)
1970         $3="ios"
1971         ;;
1972       linux-android*)
1973         $3="linux-android"
1974         ;;
1975       linux-*|linux)
1976         $3="linux"
1977         ;;
1978       # As far as I'm aware, none of these have relevant variants
1979       freebsd|netbsd|openbsd|dragonfly|hpux|linuxaout|kfreebsdgnu|freebsd2|solaris2|mingw32|darwin|gnu|nextstep2|nextstep3|sunos4|ultrix|haiku)
1980         $3="$1"
1981         ;;
1982       aix*) # e.g. powerpc-ibm-aix7.1.3.0
1983         $3="aix"
1984         ;;
1985       darwin*) # e.g. aarch64-apple-darwin14
1986         $3="darwin"
1987         ;;
1988       freebsd*) # like i686-gentoo-freebsd7
1989                 #      i686-gentoo-freebsd8
1990                 #      i686-gentoo-freebsd8.2
1991         $3="freebsd"
1992         ;;
1993       nto-qnx*)
1994         $3="nto-qnx"
1995         ;;
1996       *)
1997         echo "Unknown OS $1"
1998         exit 1
1999         ;;
2000       esac
2001 ])
2002
2003 # BOOTSTRAPPING_GHC_INFO_FIELD
2004 # --------------------------------
2005 # Set the variable $1 to the value of the ghc --info field $2.
2006 AC_DEFUN([BOOTSTRAPPING_GHC_INFO_FIELD],[
2007 $1=`"$WithGhc" --info | grep "^ ,(\"$2\"," | sed -e 's/.*","//' -e 's/")$//'`
2008 tmp=${$1#\$topdir/}
2009 if test "${$1}" != "$tmp"
2010 then
2011     topdir=`"$WithGhc" --print-libdir | sed 's#\\\\#/#g'`
2012     $1="$topdir/$tmp"
2013 fi
2014 AC_SUBST($1)
2015 ])
2016
2017 # LIBRARY_VERSION(lib, [dir])
2018 # --------------------------------
2019 # Gets the version number of a library.
2020 # If $1 is ghc-prim, then we define LIBRARY_ghc_prim_VERSION as 1.2.3
2021 # $2 points to the directory under libraries/
2022 AC_DEFUN([LIBRARY_VERSION],[
2023 dir=m4_default([$2],[$1])
2024 LIBRARY_[]translit([$1], [-], [_])[]_VERSION=`grep -i "^version:" libraries/${dir}/$1.cabal | sed "s/.* //"`
2025 AC_SUBST(LIBRARY_[]translit([$1], [-], [_])[]_VERSION)
2026 ])
2027
2028 # XCODE_VERSION()
2029 # --------------------------------
2030 # Gets the version number of XCode, if on a Mac
2031 AC_DEFUN([XCODE_VERSION],[
2032     if test "$TargetVendor_CPP" = "apple"
2033     then
2034         AC_MSG_CHECKING(XCode version)
2035         XCodeVersion=`xcodebuild -version | grep Xcode | sed "s/Xcode //"`
2036         # Old XCode versions don't actually give the XCode version
2037         if test "$XCodeVersion" = ""
2038         then
2039             AC_MSG_RESULT(not found (too old?))
2040             XCodeVersion1=0
2041             XCodeVersion2=0
2042         else
2043             AC_MSG_RESULT($XCodeVersion)
2044             XCodeVersion1=`echo "$XCodeVersion" | sed 's/\..*//'`
2045             changequote(, )dnl
2046             XCodeVersion2=`echo "$XCodeVersion" | sed 's/[^.]*\.\([^.]*\).*/\1/'`
2047             changequote([, ])dnl
2048             AC_MSG_NOTICE(XCode version component 1: $XCodeVersion1)
2049             AC_MSG_NOTICE(XCode version component 2: $XCodeVersion2)
2050         fi
2051     fi
2052 ])
2053
2054 # FIND_LLVM_PROG()
2055 # --------------------------------
2056 # Find where the llvm tools are. We have a special function to handle when they
2057 # are installed with a version suffix (e.g., llc-3.1).
2058 #
2059 # $1 = the variable to set
2060 # $2 = the command to look for
2061 # $3 = the version of the command to look for
2062 #
2063 AC_DEFUN([FIND_LLVM_PROG],[
2064     # Test for program with and without version name.
2065     AC_CHECK_TOOLS([$1], [$2-$3 $2], [:])
2066     if test "$$1" != ":"; then
2067         AC_MSG_CHECKING([$$1 is version $3])
2068         if test `$$1 --version | grep -c "version $3"` -gt 0 ; then
2069             AC_MSG_RESULT(yes)
2070         else
2071             AC_MSG_RESULT(no)
2072             $1=""
2073         fi
2074     else
2075         $1=""
2076     fi
2077 ])
2078
2079 # CHECK_LD_COPY_BUG()
2080 # -------------------
2081 # Check for binutils bug #16177 present in some versions of the bfd ld
2082 # implementation affecting ARM relocations.
2083 # https://sourceware.org/bugzilla/show_bug.cgi?id=16177
2084 #
2085 # $1 = the platform
2086 #
2087 AC_DEFUN([CHECK_LD_COPY_BUG],[
2088     case $1 in
2089       arm*linux*)
2090         AC_CHECK_TARGET_TOOL([READELF], [readelf])
2091         AC_CHECK_TARGET_TOOL([AS], [as])
2092         AC_MSG_CHECKING([for ld bug 16177])
2093         cat >actest.s <<-EOF
2094           .globl _start
2095           .p2align 4
2096         _start:
2097           bkpt
2098
2099         .data
2100           .globl data_object
2101         object_reference:
2102           .long data_object
2103           .size object_reference, 4
2104 EOF
2105
2106         cat >aclib.s <<-EOF
2107           .data
2108           .globl data_object
2109           .type data_object, %object
2110           .size data_object, 4
2111         data_object:
2112             .long 123
2113 EOF
2114
2115         $AS -o aclib.o aclib.s
2116         $LD -shared -o aclib.so aclib.o
2117
2118         $AS -o actest.o actest.s
2119         $LD -o actest actest.o aclib.so
2120
2121         if $READELF -r actest | grep R_ARM_COPY > /dev/null; then
2122             AC_MSG_RESULT([affected])
2123             AC_MSG_ERROR(
2124               [Your linker is affected by binutils #16177, which
2125                critically breaks linkage of GHC objects. Please either upgrade
2126                binutils or supply a different linker with the LD environment
2127                variable.])
2128         else
2129             AC_MSG_RESULT([unaffected])
2130         fi
2131
2132         rm -f aclib.s aclib.o aclib.so actest.s actest.o actest
2133         ;;
2134       *)
2135         ;;
2136     esac
2137 ])
2138
2139 # FIND_GHC_BOOTSTRAP_PROG()
2140 # --------------------------------
2141 # Parse the bootstrap GHC's compier settings file for the location of things
2142 # like the `llc` and `opt` commands.
2143 #
2144 # $1 = the variable to set
2145 # $2 = The bootstrap compiler.
2146 # $3 = The string to grep for to find the correct line.
2147 #
2148 AC_DEFUN([FIND_GHC_BOOTSTRAP_PROG],[
2149     BootstrapTmpCmd=`grep $3 $($2 --print-libdir)/settings 2>/dev/null | sed 's/.*", "//;s/".*//'`
2150     if test -n "$BootstrapTmpCmd" && test `basename $BootstrapTmpCmd` = $BootstrapTmpCmd ; then
2151         AC_PATH_PROG([$1], [$BootstrapTmpCmd], "")
2152     else
2153         $1=$BootstrapTmpCmd
2154     fi
2155 ])
2156
2157
2158 AC_DEFUN([MAYBE_OVERRIDE_STAGE0],[
2159   if test ! -z "$With_$1" -a "$CrossCompiling" != "YES"; then
2160       AC_MSG_NOTICE([Not cross-compiling, so --with-$1 also sets $2])
2161       $2=$With_$1
2162   fi
2163 ])
2164
2165
2166 # FP_CPP_CMD_WITH_ARGS()
2167 # ----------------------
2168 # sets CPP command and its arguments
2169 #
2170 # $1 = the variable to set to CPP command
2171 # $2 = the variable to set to CPP command arguments
2172
2173 AC_DEFUN([FP_CPP_CMD_WITH_ARGS],[
2174 dnl ** what cpp to use?
2175 dnl --------------------------------------------------------------
2176 AC_ARG_WITH(hs-cpp,
2177 [AC_HELP_STRING([--with-hs-cpp=ARG],
2178       [Path to the (C) preprocessor for Haskell files [default=autodetect]])],
2179 [
2180     if test "$HostOS" = "mingw32"
2181     then
2182         AC_MSG_WARN([Request to use $withval will be ignored])
2183     else
2184         HS_CPP_CMD=$withval
2185     fi
2186 ],
2187 [
2188
2189     # We can't use $CPP here, since HS_CPP_CMD is expected to be a single
2190     # command (no flags), and AC_PROG_CPP defines CPP as "/usr/bin/gcc -E".
2191     HS_CPP_CMD=$CC
2192
2193     SOLARIS_GCC_CPP_BROKEN=NO
2194     SOLARIS_FOUND_GOOD_CPP=NO
2195     case $host in
2196         i386-*-solaris2)
2197         GCC_MAJOR_MINOR=`$CC --version|grep "gcc (GCC)"|cut -d ' ' -f 3-3|cut -d '.' -f 1-2`
2198         if test "$GCC_MAJOR_MINOR" != "3.4"; then
2199           # this is not 3.4.x release so with broken CPP
2200           SOLARIS_GCC_CPP_BROKEN=YES
2201         fi
2202         ;;
2203     esac
2204
2205     if test "$SOLARIS_GCC_CPP_BROKEN" = "YES"; then
2206       # let's try to find if GNU C 3.4.x is installed
2207       if test -x /usr/sfw/bin/gcc; then
2208         # something executable is in expected path so let's
2209         # see if it's really GNU C
2210         NEW_GCC_MAJOR_MINOR=`/usr/sfw/bin/gcc --version|grep "gcc (GCC)"|cut -d ' ' -f 3-3|cut -d '.' -f 1-2`
2211         if test "$NEW_GCC_MAJOR_MINOR" = "3.4"; then
2212           # this is GNU C 3.4.x which provides non-broken CPP on Solaris
2213           # let's use it as CPP then.
2214           HS_CPP_CMD=/usr/sfw/bin/gcc
2215           SOLARIS_FOUND_GOOD_CPP=YES
2216         fi
2217       fi
2218       if test "$SOLARIS_FOUND_GOOD_CPP" = "NO"; then
2219         AC_MSG_WARN([Your GNU C provides broken CPP and you do not have GNU C 3.4.x installed.])
2220         AC_MSG_WARN([Please install GNU C 3.4.x to solve this issue. It will be used as CPP only.])
2221       fi
2222     fi
2223 ]
2224 )
2225
2226
2227
2228 dnl ** what cpp flags to use?
2229 dnl -----------------------------------------------------------
2230 AC_ARG_WITH(hs-cpp-flags,
2231   [AC_HELP_STRING([--with-hs-cpp-flags=ARG],
2232       [Flags to the (C) preprocessor for Haskell files [default=autodetect]])],
2233   [
2234       if test "$HostOS" = "mingw32"
2235       then
2236           AC_MSG_WARN([Request to use $withval will be ignored])
2237       else
2238           HS_CPP_ARGS=$withval
2239       fi
2240   ],
2241 [
2242   $HS_CPP_CMD -x c /dev/null -dM -E > conftest.txt 2>&1
2243   if grep "__clang__" conftest.txt >/dev/null 2>&1; then
2244     HS_CPP_ARGS="-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs"
2245   else
2246       $HS_CPP_CMD  -v > conftest.txt 2>&1
2247       if  grep "gcc" conftest.txt >/dev/null 2>&1; then
2248           HS_CPP_ARGS="-E -undef -traditional"
2249         else
2250           $HS_CPP_CMD  --version > conftest.txt 2>&1
2251           if grep "cpphs" conftest.txt >/dev/null 2>&1; then
2252             HS_CPP_ARGS="--cpp -traditional"
2253           else
2254             AC_MSG_WARN([configure can't recognize your CPP program, you may need to set --with-hs-cpp-flags=FLAGS explicitly])
2255             HS_CPP_ARGS=""
2256           fi
2257       fi
2258   fi
2259   ]
2260 )
2261
2262 $1=$HS_CPP_CMD
2263 $2=$HS_CPP_ARGS
2264
2265 ])
2266
2267 # FP_BFD_SUPPORT()
2268 # ----------------------
2269 # whether to use libbfd for debugging RTS
2270 AC_DEFUN([FP_BFD_SUPPORT], [
2271     AC_SUBST([CabalHaveLibbfd], [False])
2272     AC_ARG_ENABLE(bfd-debug,
2273         [AC_HELP_STRING([--enable-bfd-debug],
2274               [Enable symbol resolution for -debug rts ('+RTS -Di') via binutils' libbfd [default=no]])],
2275         [
2276             # don't pollute general LIBS environment
2277             save_LIBS="$LIBS"
2278             AC_CHECK_HEADERS([bfd.h])
2279             dnl ** check whether this machine has BFD and libiberty installed (used for debugging)
2280             dnl    the order of these tests matters: bfd needs libiberty
2281             AC_CHECK_LIB(iberty, xmalloc)
2282             dnl 'bfd_init' is a rare non-macro in libbfd
2283             AC_CHECK_LIB(bfd,    bfd_init)
2284
2285             AC_TRY_LINK([#include <bfd.h>],
2286                         [
2287                                 /* mimic our rts/Printer.c */
2288                                 bfd* abfd;
2289                                 const char * name;
2290                                 char **matching;
2291
2292                                 name = "some.executable";
2293                                 bfd_init();
2294                                 abfd = bfd_openr(name, "default");
2295                                 bfd_check_format_matches (abfd, bfd_object, &matching);
2296                                 {
2297                                     long storage_needed;
2298                                     storage_needed = bfd_get_symtab_upper_bound (abfd);
2299                                 }
2300                                 {
2301                                     asymbol **symbol_table;
2302                                     long number_of_symbols;
2303                                     symbol_info info;
2304
2305                                     number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
2306                                     bfd_get_symbol_info(abfd,symbol_table[0],&info);
2307                                 }
2308                         ],
2309                         [AC_SUBST([CabalHaveLibbfd], [True])],dnl bfd seems to work
2310                         [AC_MSG_ERROR([can't use 'bfd' library])])
2311             LIBS="$save_LIBS"
2312         ]
2313     )
2314 ])
2315
2316
2317 # FP_CC_LINKER_FLAG_TRY()
2318 # --------------------
2319 # Try a particular linker to see whether we can use it. In particular, determine
2320 # whether we can convince gcc to use it via a -fuse-ld=... flag.
2321 #
2322 # $1 = the name of the linker to try
2323 # $2 = the variable to set with the appropriate GHC flag if the linker is
2324 # found to be usable
2325 AC_DEFUN([FP_CC_LINKER_FLAG_TRY], [
2326     AC_MSG_CHECKING([whether C compiler supports -fuse-ld=$1])
2327     echo 'int main(void) {return 0;}' > conftest.c
2328     if $CC -o conftest.o -fuse-ld=$1 conftest.c > /dev/null 2>&1
2329     then
2330         $2="-fuse-ld=$1"
2331         AC_MSG_RESULT([yes])
2332     else
2333         AC_MSG_RESULT([no])
2334     fi
2335     rm -f conftest.c conftest.o
2336 ])
2337
2338 # FIND_LD
2339 # ---------
2340 # Find the version of `ld` to use and figure out how to get gcc to use it for
2341 # linking (if --enable-ld-override is enabled). This is used in both in the top
2342 # level configure.ac and in distrib/configure.ac.in.
2343 #
2344 # $1 = the platform
2345 # $2 = the variable to set with GHC options to configure gcc to use the chosen linker
2346 #
2347 AC_DEFUN([FIND_LD],[
2348     AC_ARG_ENABLE(ld-override,
2349       [AC_HELP_STRING([--disable-ld-override],
2350         [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]])],
2351       [],
2352       [enable_ld_override=yes])
2353
2354     find_ld() {
2355         # Make sure the user didn't specify LD manually.
2356         if test "z$LD" != "z"; then
2357             AC_CHECK_TARGET_TOOL([LD], [ld])
2358             return
2359         fi
2360
2361         # Manually iterate over possible names since we want to ensure that, e.g.,
2362         # if ld.lld is installed but gcc doesn't support -fuse-ld=lld, that we
2363         # then still try ld.gold and -fuse-ld=gold.
2364         for possible_ld in ld.lld ld.gold ld; do
2365             TmpLd="" # In case the user set LD
2366             AC_CHECK_TARGET_TOOL([TmpLd], [$possible_ld])
2367             if test "x$TmpLd" = "x"; then continue; fi
2368
2369             out=`$TmpLd --version`
2370             case $out in
2371               "GNU ld"*)   FP_CC_LINKER_FLAG_TRY(bfd, $2) ;;
2372               "GNU gold"*) FP_CC_LINKER_FLAG_TRY(gold, $2) ;;
2373               "LLD"*)      FP_CC_LINKER_FLAG_TRY(lld, $2) ;;
2374               *) AC_MSG_NOTICE([unknown linker version $out]) ;;
2375             esac
2376             if test "z$$2" = "z"; then
2377                 AC_MSG_NOTICE([unable to convince '$CC' to use linker '$TmpLd'])
2378                 # a terrible hack to prevent autoconf from caching the previous
2379                 # AC_CHECK_TARGET_TOOL result since next time we'll be looking
2380                 # for another ld variant.
2381                 $as_unset ac_cv_prog_ac_ct_TmpLd
2382             else
2383                 LD="$TmpLd"
2384                 return
2385             fi
2386         done
2387
2388         # Fallback
2389         AC_CHECK_TARGET_TOOL([LD], [ld])
2390     }
2391
2392     if test "x$enable_ld_override" = "xyes"; then
2393         find_ld
2394     else
2395         AC_CHECK_TARGET_TOOL([LD], [ld])
2396     fi
2397
2398     CHECK_LD_COPY_BUG([$1])
2399 ])
2400
2401 # LocalWords:  fi