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