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