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