Refactor the typechecker to use ExpTypes.
[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         osf3)
275             test -z "[$]2" || eval "[$]2=OSOsf3"
276             ;;
277         nto-qnx)
278             test -z "[$]2" || eval "[$]2=OSQNXNTO"
279             ;;
280         dragonfly|osf1|hpux|linuxaout|freebsd2|gnu|nextstep2|nextstep3|sunos4|ultrix|irix)
281             test -z "[$]2" || eval "[$]2=OSUnknown"
282             ;;
283         aix)
284             test -z "[$]2" || eval "[$]2=OSAIX"
285             ;;
286         linux-android)
287             test -z "[$]2" || eval "[$]2=OSAndroid"
288             ;;
289         *)
290             echo "Unknown OS '[$]1'"
291             exit 1
292             ;;
293         esac
294     }
295
296     dnl ** check for Apple-style dead-stripping support
297     dnl    (.subsections-via-symbols assembler directive)
298
299     AC_MSG_CHECKING(for .subsections_via_symbols)
300     AC_COMPILE_IFELSE(
301         [AC_LANG_PROGRAM([], [__asm__ (".subsections_via_symbols");])],
302         [AC_MSG_RESULT(yes)
303          HaskellHaveSubsectionsViaSymbols=True
304          AC_DEFINE([HAVE_SUBSECTIONS_VIA_SYMBOLS],[1],
305                    [Define to 1 if Apple-style dead-stripping is supported.])
306         ],
307         [HaskellHaveSubsectionsViaSymbols=False
308          AC_MSG_RESULT(no)])
309
310     dnl ** check for .ident assembler directive
311
312     AC_MSG_CHECKING(whether your assembler supports .ident directive)
313     AC_COMPILE_IFELSE(
314         [AC_LANG_SOURCE([__asm__ (".ident \"GHC x.y.z\"");])],
315         [AC_MSG_RESULT(yes)
316          HaskellHaveIdentDirective=True],
317         [AC_MSG_RESULT(no)
318          HaskellHaveIdentDirective=False])
319
320     dnl *** check for GNU non-executable stack note support (ELF only)
321     dnl     (.section .note.GNU-stack,"",@progbits)
322
323     dnl This test doesn't work with "gcc -g" in gcc 4.4 (GHC trac #3889:
324     dnl     Error: can't resolve `.note.GNU-stack' {.note.GNU-stack section} - `.Ltext0' {.text section}
325     dnl so we empty CFLAGS while running this test
326     CFLAGS2="$CFLAGS"
327     CFLAGS=
328     AC_MSG_CHECKING(for GNU non-executable stack support)
329     AC_COMPILE_IFELSE(
330         [AC_LANG_PROGRAM([__asm__ (".section .note.GNU-stack,\"\",@progbits");], [0])],
331         [AC_MSG_RESULT(yes)
332          HaskellHaveGnuNonexecStack=True],
333         [AC_MSG_RESULT(no)
334          HaskellHaveGnuNonexecStack=False])
335     CFLAGS="$CFLAGS2"
336
337     checkArch "$BuildArch" "HaskellBuildArch"
338     checkVendor "$BuildVendor"
339     checkOS "$BuildOS" ""
340
341     checkArch "$HostArch" "HaskellHostArch"
342     checkVendor "$HostVendor"
343     checkOS "$HostOS" ""
344
345     checkArch "$TargetArch" "HaskellTargetArch"
346     checkVendor "$TargetVendor"
347     checkOS "$TargetOS" "HaskellTargetOs"
348
349     AC_SUBST(HaskellTargetArch)
350     AC_SUBST(HaskellTargetOs)
351     AC_SUBST(HaskellHaveSubsectionsViaSymbols)
352     AC_SUBST(HaskellHaveIdentDirective)
353     AC_SUBST(HaskellHaveGnuNonexecStack)
354 ])
355
356
357 # GET_ARM_ISA
358 # ----------------------------------
359 # Get info about the ISA on the ARM arch
360 AC_DEFUN([GET_ARM_ISA],
361 [
362     AC_COMPILE_IFELSE([
363         AC_LANG_PROGRAM(
364             [],
365             [#if defined(__ARM_ARCH_2__)  || \
366                  defined(__ARM_ARCH_3__)  || \
367                  defined(__ARM_ARCH_3M__) || \
368                  defined(__ARM_ARCH_4__)  || \
369                  defined(__ARM_ARCH_4T__) || \
370                  defined(__ARM_ARCH_5__)  || \
371                  defined(__ARM_ARCH_5T__) || \
372                  defined(__ARM_ARCH_5E__) || \
373                  defined(__ARM_ARCH_5TE__)
374                  return 0;
375              #else
376                  not pre arm v6
377              #endif]
378         )],
379         [AC_DEFINE(arm_HOST_ARCH_PRE_ARMv6, 1, [ARM pre v6])
380          AC_DEFINE(arm_HOST_ARCH_PRE_ARMv7, 1, [ARM pre v7])
381          changequote(, )dnl
382          ARM_ISA=ARMv5
383          ARM_ISA_EXT="[]"
384          changequote([, ])dnl
385         ],
386         [
387             AC_COMPILE_IFELSE([
388                 AC_LANG_PROGRAM(
389                     [],
390                     [#if defined(__ARM_ARCH_6__)   || \
391                          defined(__ARM_ARCH_6J__)  || \
392                          defined(__ARM_ARCH_6T2__) || \
393                          defined(__ARM_ARCH_6Z__)  || \
394                          defined(__ARM_ARCH_6ZK__) || \
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="$WhatGccIsCalled"
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     SettingsLdFlags="$CONF_LD_LINKER_OPTS_STAGE2"
503     AC_SUBST(SettingsCCompilerCommand)
504     AC_SUBST(SettingsHaskellCPPCommand)
505     AC_SUBST(SettingsHaskellCPPFlags)
506     AC_SUBST(SettingsCCompilerFlags)
507     AC_SUBST(SettingsCCompilerLinkFlags)
508     AC_SUBST(SettingsLdCommand)
509     AC_SUBST(SettingsLdFlags)
510     AC_SUBST(SettingsArCommand)
511     AC_SUBST(SettingsPerlCommand)
512     AC_SUBST(SettingsDllWrapCommand)
513     AC_SUBST(SettingsWindresCommand)
514     AC_SUBST(SettingsLibtoolCommand)
515     AC_SUBST(SettingsTouchCommand)
516     AC_SUBST(SettingsLlcCommand)
517     AC_SUBST(SettingsOptCommand)
518 ])
519
520
521 # FPTOOLS_SET_C_LD_FLAGS
522 # ----------------------------------
523 # Set the C, LD and CPP flags for a given platform
524 # $1 is the platform
525 # $2 is the name of the CC flags variable
526 # $3 is the name of the linker flags variable when linking with gcc
527 # $4 is the name of the linker flags variable when linking with ld
528 # $5 is the name of the CPP flags variable
529 AC_DEFUN([FPTOOLS_SET_C_LD_FLAGS],
530 [
531     AC_MSG_CHECKING([Setting up $2, $3, $4 and $5])
532     case $$1 in
533     i386-*)
534         # Workaround for #7799
535         $2="$$2 -U__i686"
536         ;;
537     esac
538
539     case $$1 in
540     i386-unknown-mingw32)
541         $2="$$2 -march=i686"
542         ;;
543     i386-portbld-freebsd*)
544         $2="$$2 -march=i686"
545         ;;
546     i386-apple-darwin)
547         $2="$$2 -m32"
548         $3="$$3 -m32"
549         $4="$$4 -arch i386"
550         $5="$$5 -m32"
551         ;;
552     x86_64-apple-darwin)
553         $2="$$2 -m64"
554         $3="$$3 -m64"
555         $4="$$4 -arch x86_64"
556         $5="$$5 -m64"
557         ;;
558     x86_64-unknown-solaris2)
559         $2="$$2 -m64"
560         $3="$$3 -m64"
561         $4="$$4 -m64"
562         $5="$$5 -m64"
563         ;;
564     alpha-*)
565         # For now, to suppress the gcc warning "call-clobbered
566         # register used for global register variable", we simply
567         # disable all warnings altogether using the -w flag. Oh well.
568         $2="$$2 -w -mieee -D_REENTRANT"
569         $3="$$3 -w -mieee -D_REENTRANT"
570         $5="$$5 -w -mieee -D_REENTRANT"
571         ;;
572     hppa*)
573         # ___HPUX_SOURCE, not _HPUX_SOURCE, is #defined if -ansi!
574         # (very nice, but too bad the HP /usr/include files don't agree.)
575         $2="$$2 -D_HPUX_SOURCE"
576         $3="$$3 -D_HPUX_SOURCE"
577         $5="$$5 -D_HPUX_SOURCE"
578         ;;
579     arm*linux*)
580         # On arm/linux and arm/android, tell gcc to generate Arm
581         # instructions (ie not Thumb) and to link using the gold linker.
582         # Forcing LD to be ld.gold is done in FIND_LD m4 macro.
583         $2="$$2 -marm"
584         $3="$$3 -fuse-ld=gold -Wl,-z,noexecstack"
585         $4="$$4 -z noexecstack"
586         ;;
587
588     aarch64*linux*)
589         # On aarch64/linux and aarch64/android, tell gcc to link using the
590         # gold linker.
591         # Forcing LD to be ld.gold is done in FIND_LD m4 macro.
592         $3="$$3 -fuse-ld=gold -Wl,-z,noexecstack"
593         $4="$$4 -z noexecstack"
594         ;;
595
596     powerpc-ibm-aix*)
597         # On IBM AIX, we need to workaround XCOFF's limitations. Specifically,
598         # there's a TOC which only supports at most 16k entries (see
599         # http://www.ibm.com/developerworks/rational/library/overview-toc-aix/
600         # for more details), and by using `-mminimal-toc` we use up only one TOC
601         # entry per translation unit, at the cost of an additional pointer
602         # indirection. However, see note in `compiler/ghc.mk` about `Parser.hs`.
603         # Finally, we need `-D_THREAD_SAFE` to unlock a thread-local `errno`.
604         $2="$$2 -mminimal-toc -D_THREAD_SAFE"
605         $3="$$3 -mminimal-toc -D_THREAD_SAFE"
606         $5="$$5 -D_THREAD_SAFE"
607         ;;
608
609     esac
610
611     # If gcc knows about the stack protector, turn it off.
612     # Otherwise the stack-smash handler gets triggered.
613     echo 'int main(void) {return 0;}' > conftest.c
614     if $CC -c conftest.c -fno-stack-protector > /dev/null 2>&1
615     then
616         $2="$$2 -fno-stack-protector"
617     fi
618
619     rm -f conftest.c conftest.o
620     AC_MSG_RESULT([done])
621 ])
622
623
624 # FP_VISIBILITY_HIDDEN
625 # ----------------------------------
626 # Is the visibility hidden attribute supported?
627 AC_DEFUN([FP_VISIBILITY_HIDDEN],
628 [
629     AC_MSG_CHECKING([whether __attribute__((visibility("hidden"))) is supported])
630     echo '__attribute__((visibility("hidden"))) void foo(void) {}' > conftest.c
631     if $CC -Wall -Werror -c conftest.c > /dev/null 2>&1
632     then
633         AC_MSG_RESULT([yes])
634         AC_DEFINE(HAS_VISIBILITY_HIDDEN, 1, [Has visibility hidden])
635     else
636         AC_MSG_RESULT([no])
637     fi
638     rm -f conftest.c conftest.o
639 ])
640
641
642 # FPTOOLS_FLOAT_WORD_ORDER_BIGENDIAN
643 # ----------------------------------
644 # Little endian ARM on Linux with some ABIs has big endian word order
645 # in doubles. Define FLOAT_WORDS_BIGENDIAN if this is the case.
646 AC_DEFUN([FPTOOLS_FLOAT_WORD_ORDER_BIGENDIAN],
647   [AC_CACHE_CHECK([whether float word order is big endian], [fptools_cv_float_word_order_bigendian],
648     [AC_COMPILE_IFELSE(
649       [AC_LANG_PROGRAM(
650         [#include <endian.h>],
651         [#if defined(__FLOAT_WORD_ORDER) && __FLOAT_WORD_ORDER == BIG_ENDIAN
652              return 0;
653          #else
654              not float word order big endian
655          #endif]
656       )],
657       [fptools_cv_float_word_order_bigendian=yes],
658       [fptools_cv_float_word_order_bigendian=no])
659     ])
660   case $fptools_cv_float_word_order_bigendian in
661       yes)
662           AC_DEFINE([FLOAT_WORDS_BIGENDIAN], 1,
663           [Define to 1 if your processor stores words of floats with
664            the most significant byte first]) ;;
665   esac
666 ])
667
668
669 # FP_ARG_WITH_PATH_GNU_PROG_GENERAL
670 # --------------------
671 # Find the specified command on the path or allow a user to set it manually
672 # with a --with-<command> option.
673 #
674 # This is ignored on the mingw32 platform.
675 #
676 # $1 = the variable to set
677 # $2 = the with option name
678 # $3 = the command to look for
679 # $4 = prepend target to program name? if 'no', use the name unchanged
680 # $5 = optional? if 'no', then raise an error if the command isn't found
681 #
682 AC_DEFUN([FP_ARG_WITH_PATH_GNU_PROG_GENERAL],
683 [
684 AC_ARG_WITH($2,
685 [AC_HELP_STRING([--with-$2=ARG],
686         [Use ARG as the path to $2 [default=autodetect]])],
687 [
688     if test "$HostOS" = "mingw32"
689     then
690         AC_MSG_WARN([Request to use $withval will be ignored])
691     else
692         $1=$withval
693     fi
694
695     # Remember that we set this manually.  Used to override CC_STAGE0
696     # and friends later, if we are not cross-compiling.
697     With_$2=$withval
698 ],
699 [
700     if test "$HostOS" != "mingw32"
701     then
702         if test "$4" = "no" -o "$target_alias" = "" ; then
703             AC_PATH_PROG([$1], [$3])
704         else
705             AC_PATH_PROG([$1], [$target_alias-$3])
706         fi
707         if test "$5" = "no" -a -z "$$1"
708         then
709             AC_MSG_ERROR([cannot find $3 in your PATH])
710         fi
711     fi
712 ]
713 )
714 ]) # FP_ARG_WITH_PATH_GNU_PROG_GENERAL
715
716
717 # FP_ARG_WITH_PATH_GNU_PROG
718 # --------------------
719 # The usual case: prepend the target, and the program is not optional.
720 AC_DEFUN([FP_ARG_WITH_PATH_GNU_PROG],
721 [FP_ARG_WITH_PATH_GNU_PROG_GENERAL([$1], [$2], [$3], [yes], [no])])
722
723 # FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL
724 # --------------------
725 # Same as FP_ARG_WITH_PATH_GNU_PROG but no error will be thrown if the command
726 # isn't found.
727 AC_DEFUN([FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL],
728 [FP_ARG_WITH_PATH_GNU_PROG_GENERAL([$1], [$2], [$3], [yes], [yes])])
729
730 # FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL_NOTARGET
731 # --------------------
732 # Same as FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL but don't prepend the target name
733 # (used for LLVM).
734 AC_DEFUN([FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL_NOTARGET],
735 [FP_ARG_WITH_PATH_GNU_PROG_GENERAL([$1], [$2], [$3], [no], [yes])])
736
737
738 # FP_PROG_CONTEXT_DIFF
739 # --------------------
740 # Figure out how to do context diffs. Sets the output variable ContextDiffCmd.
741 #
742 # Note: NeXTStep thinks diff'ing a file against itself is "trouble".
743 AC_DEFUN([FP_PROG_CONTEXT_DIFF],
744 [AC_CACHE_CHECK([for a working context diff], [fp_cv_context_diff],
745 [echo foo > conftest1
746 echo foo > conftest2
747 fp_cv_context_diff=no
748 for fp_var in '-U 1' '-u1' '-C 1' '-c1'
749 do
750   if diff $fp_var conftest1 conftest2 > /dev/null 2>&1; then
751     fp_cv_context_diff="diff $fp_var"
752     break
753   fi
754 done])
755 if test x"$fp_cv_context_diff" = xno; then
756    AC_MSG_ERROR([cannot figure out how to do context diffs])
757 fi
758 AC_SUBST(ContextDiffCmd, [$fp_cv_context_diff])
759 ])# FP_PROG_CONTEXT_DIFF
760
761
762 # FP_COMPUTE_INT(EXPRESSION, VARIABLE, INCLUDES, IF-FAILS)
763 # --------------------------------------------------------
764 # Assign VARIABLE the value of the compile-time EXPRESSION using INCLUDES for
765 # compilation. Execute IF-FAILS when unable to determine the value. Works for
766 # cross-compilation, too.
767 #
768 # Implementation note: We are lazy and use an internal autoconf macro, but it
769 # is supported in autoconf versions 2.50 up to the actual 2.57, so there is
770 # little risk.
771 AC_DEFUN([FP_COMPUTE_INT],
772 [_AC_COMPUTE_INT([$1], [$2], [$3], [$4])[]dnl
773 ])# FP_COMPUTE_INT
774
775
776 # FP_CHECK_ALIGNMENT(TYPE, [IGNORED], [INCLUDES = DEFAULT-INCLUDES])
777 # ------------------------------------------------------------------
778 # A variation of AC_CHECK_SIZEOF for computing the alignment restrictions of a
779 # given type. Defines ALIGNMENT_TYPE.
780 AC_DEFUN([FP_CHECK_ALIGNMENT],
781 [AS_LITERAL_IF(m4_translit([[$1]], [*], [p]), [],
782                [AC_FATAL([$0: requires literal arguments])])[]dnl
783 AC_CHECK_TYPE([$1], [], [], [$3])[]dnl
784 m4_pushdef([fp_Cache], [AS_TR_SH([fp_cv_alignment_$1])])[]dnl
785 AC_CACHE_CHECK([alignment of $1], [fp_Cache],
786 [if test "$AS_TR_SH([ac_cv_type_$1])" = yes; then
787   FP_COMPUTE_INT([offsetof(struct { char c; $1 ty; },ty)],
788                  [fp_Cache],
789                  [AC_INCLUDES_DEFAULT([$3])],
790                  [AC_MSG_ERROR([cannot compute alignment ($1)
791 See `config.log' for more details.], [77])])
792 else
793   fp_Cache=0
794 fi])[]dnl
795 AC_DEFINE_UNQUOTED(AS_TR_CPP(alignment_$1), $fp_Cache, [The alignment of a `$1'.])[]dnl
796 m4_popdef([fp_Cache])[]dnl
797 ])# FP_CHECK_ALIGNMENT
798
799
800 # FP_LEADING_UNDERSCORE
801 # ---------------------
802 # Test for determining whether symbol names have a leading underscore. We assume
803 # that they _haven't_ if anything goes wrong. Sets the output variable
804 # LeadingUnderscore to YES or NO and defines LEADING_UNDERSCORE correspondingly.
805 #
806 # Some nlist implementations seem to try to be compatible by ignoring a leading
807 # underscore sometimes (eg. FreeBSD). We therefore have to work around this by
808 # checking for *no* leading underscore first. Sigh.  --SDM
809 #
810 # Similarly on OpenBSD, but this test doesn't help. -- dons
811 AC_DEFUN([FP_LEADING_UNDERSCORE],
812 [AC_CHECK_LIB([elf], [nlist], [LIBS="-lelf $LIBS"])
813 AC_CACHE_CHECK([leading underscore in symbol names], [fptools_cv_leading_underscore], [
814 # Hack!: nlist() under Digital UNIX insist on there being an _,
815 # but symbol table listings shows none. What is going on here?!?
816 case $HostPlatform in
817 *openbsd*) # x86 openbsd is ELF from 3.4 >, meaning no leading uscore
818   case $build in
819     i386-*2\.@<:@0-9@:>@ | i386-*3\.@<:@0-3@:>@ ) fptools_cv_leading_underscore=yes ;;
820     *) fptools_cv_leading_underscore=no ;;
821   esac ;;
822 alpha-dec-osf*) fptools_cv_leading_underscore=no;;
823 i386-unknown-mingw32) fptools_cv_leading_underscore=yes;;
824 x86_64-unknown-mingw32) fptools_cv_leading_underscore=no;;
825
826     # HACK: Apple doesn't seem to provide nlist in the 64-bit-libraries
827 x86_64-apple-darwin*) fptools_cv_leading_underscore=yes;;
828 *-apple-ios) fptools_cv_leading_underscore=yes;;
829
830 *) AC_RUN_IFELSE([AC_LANG_SOURCE([[#ifdef HAVE_NLIST_H
831 #include <nlist.h>
832 struct nlist xYzzY1[] = {{"xYzzY1", 0},{0}};
833 struct nlist xYzzY2[] = {{"_xYzzY2", 0},{0}};
834 #endif
835
836 int main(argc, argv)
837 int argc;
838 char **argv;
839 {
840 #ifdef HAVE_NLIST_H
841     if(nlist(argv[0], xYzzY1) == 0 && xYzzY1[0].n_value != 0)
842         exit(1);
843     if(nlist(argv[0], xYzzY2) == 0 && xYzzY2[0].n_value != 0)
844         exit(0);
845 #endif
846     exit(1);
847 }]])],[fptools_cv_leading_underscore=yes],[fptools_cv_leading_underscore=no],[fptools_cv_leading_underscore=no])
848 ;;
849 esac]);
850 AC_SUBST([LeadingUnderscore], [`echo $fptools_cv_leading_underscore | sed 'y/yesno/YESNO/'`])
851 if test x"$fptools_cv_leading_underscore" = xyes; then
852    AC_DEFINE([LEADING_UNDERSCORE], [1], [Define to 1 if C symbols have a leading underscore added by the compiler.])
853 fi])# FP_LEADING_UNDERSCORE
854
855
856 # FP_COMPARE_VERSIONS(VERSION1, TEST, VERSION2, [ACTION-IF-TRUE], [ACTION-IF-FALSE])
857 # ----------------------------------------------------------------------------------
858 # Compare dotted version numbers VERSION1 and VERSION2 lexicographically according
859 # to TEST (one of -eq, -ne, -lt, -le, -gt, or -ge).
860 AC_DEFUN([FP_COMPARE_VERSIONS],
861 [fp_version1=$1; fp_version2=$3
862 fp_save_IFS=$IFS; IFS='.'
863 while test x"$fp_version1" != x || test x"$fp_version2" != x
864 do
865
866   set dummy $fp_version1; shift
867   fp_num1=""
868   test $[@%:@] = 0 || { fp_num1="[$]1"; shift; }
869   test x"$fp_num1" = x && fp_num1="0"
870   fp_version1="[$]*"
871
872   set dummy $fp_version2; shift
873   fp_num2=""
874   test $[@%:@] = 0 || { fp_num2="[$]1"; shift; }
875   test x"$fp_num2" = x && fp_num2="0"
876   fp_version2="[$]*"
877
878   test "$fp_num1" = "$fp_num2" || break;
879 done
880 IFS=$fp_save_IFS
881 AS_IF([test "$fp_num1" $2 "$fp_num2"], [$4], [$5])[]dnl
882 ])# FP_COMPARE_VERSIONS
883
884
885 dnl
886 dnl Check for Happy and version.
887 dnl If there's no installed Happy, we look
888 dnl for a happy source tree and point the build system at that instead.
889 dnl If you increase the minimum version requirement, please also update:
890 dnl https://ghc.haskell.org/trac/ghc/wiki/Building/Preparation/Tools
891 dnl
892 AC_DEFUN([FPTOOLS_HAPPY],
893 [AC_PATH_PROG(HappyCmd,happy,)
894
895 AC_CACHE_CHECK([for version of happy], fptools_cv_happy_version,
896 changequote(, )dnl
897 [if test x"$HappyCmd" != x; then
898    fptools_cv_happy_version=`"$HappyCmd" -v |
899               grep 'Happy Version' | sed -e 's/Happy Version \([^ ]*\).*/\1/g'` ;
900 else
901    fptools_cv_happy_version="";
902 fi;
903 changequote([, ])dnl
904 ])
905 if test ! -f compiler/parser/Parser.hs || test ! -f compiler/cmm/CmmParse.hs
906 then
907     FP_COMPARE_VERSIONS([$fptools_cv_happy_version],[-lt],[1.19.4],
908       [AC_MSG_ERROR([Happy version 1.19.4 or later is required to compile GHC.])])[]
909 fi
910 HappyVersion=$fptools_cv_happy_version;
911 AC_SUBST(HappyVersion)
912 ])
913
914 dnl
915 dnl Check for Alex and version.
916 dnl If you increase the minimum version requirement, please also update:
917 dnl https://ghc.haskell.org/trac/ghc/wiki/Building/Preparation/Tools
918 dnl
919 AC_DEFUN([FPTOOLS_ALEX],
920 [
921 AC_PATH_PROG(AlexCmd,alex,)
922
923 AC_CACHE_CHECK([for version of alex], fptools_cv_alex_version,
924 changequote(, )dnl
925 [if test x"$AlexCmd" != x; then
926    fptools_cv_alex_version=`"$AlexCmd" -v |
927               grep 'Alex [Vv]ersion' | sed -e 's/Alex [Vv]ersion \([0-9\.]*\).*/\1/g'` ;
928 else
929    fptools_cv_alex_version="";
930 fi;
931 changequote([, ])dnl
932 ])
933 FP_COMPARE_VERSIONS([$fptools_cv_alex_version],[-ge],[3.0],
934   [Alex3=YES],[Alex3=NO])
935 if test ! -f compiler/cmm/CmmLex.hs || test ! -f compiler/parser/Lexer.hs
936 then
937     FP_COMPARE_VERSIONS([$fptools_cv_alex_version],[-lt],[3.1.0],
938       [AC_MSG_ERROR([Alex version 3.1.0 or later is required to compile GHC.])])[]
939 fi
940 AlexVersion=$fptools_cv_alex_version;
941 AC_SUBST(AlexVersion)
942 AC_SUBST(Alex3)
943 ])
944
945
946 # FP_PROG_LD_FLAG
947 # ---------------
948 # Sets the output variable $2 to $1 if ld supports the $1 flag.
949 # Otherwise the variable's value is empty.
950 AC_DEFUN([FP_PROG_LD_FLAG],
951 [
952 AC_CACHE_CHECK([whether ld understands $1], [fp_cv_$2],
953 [echo 'int foo() { return 0; }' > conftest.c
954 ${CC-cc} -c conftest.c
955 if ${LdCmd} -r $1 -o conftest2.o conftest.o > /dev/null 2>&1; then
956    fp_cv_$2=$1
957 else
958    fp_cv_$2=
959 fi
960 rm -rf conftest*])
961 $2=$fp_cv_$2
962 ])# FP_PROG_LD_FLAG
963
964
965 # FP_PROG_LD_BUILD_ID
966 # ------------
967
968 # Sets the output variable LdHasBuildId to YES if ld supports
969 # --build-id, or NO otherwise.
970 AC_DEFUN([FP_PROG_LD_BUILD_ID],
971 [
972 AC_CACHE_CHECK([whether ld understands --build-id], [fp_cv_ld_build_id],
973 [echo 'int foo() { return 0; }' > conftest.c
974 ${CC-cc} -c conftest.c
975 if ${LdCmd} -r --build-id=none -o conftest2.o conftest.o > /dev/null 2>&1; then
976    fp_cv_ld_build_id=yes
977 else
978    fp_cv_ld_build_id=no
979 fi
980 rm -rf conftest*])
981 if test "$fp_cv_ld_build_id" = yes; then
982   LdHasBuildId=YES
983 else
984   LdHasBuildId=NO
985 fi
986 AC_SUBST([LdHasBuildId])
987 ])# FP_PROG_LD_BUILD_ID
988
989
990 # FP_PROG_LD_IS_GNU
991 # -----------------
992 # Sets the output variable LdIsGNULd to YES or NO, depending on whether it is
993 # GNU ld or not.
994 AC_DEFUN([FP_PROG_LD_IS_GNU],
995 [
996 AC_CACHE_CHECK([whether ld is GNU ld], [fp_cv_gnu_ld],
997 [if ${LdCmd} --version 2> /dev/null | grep "GNU" > /dev/null 2>&1; then
998   fp_cv_gnu_ld=yes
999 else
1000   fp_cv_gnu_ld=no
1001 fi])
1002 AC_SUBST([LdIsGNULd], [`echo $fp_cv_gnu_ld | sed 'y/yesno/YESNO/'`])
1003 ])# FP_PROG_LD_IS_GNU
1004
1005
1006 # FP_PROG_LD_NO_COMPACT_UNWIND
1007 # ----------------------------
1008
1009 # Sets the output variable LdHasNoCompactUnwind to YES if ld supports
1010 # -no_compact_unwind, or NO otherwise.
1011 AC_DEFUN([FP_PROG_LD_NO_COMPACT_UNWIND],
1012 [
1013 AC_CACHE_CHECK([whether ld understands -no_compact_unwind], [fp_cv_ld_no_compact_unwind],
1014 [echo 'int foo() { return 0; }' > conftest.c
1015 ${CC-cc} -c conftest.c
1016 if ${LdCmd} -r -no_compact_unwind -o conftest2.o conftest.o > /dev/null 2>&1; then
1017    fp_cv_ld_no_compact_unwind=yes
1018 else
1019    fp_cv_ld_no_compact_unwind=no
1020 fi
1021 rm -rf conftest*])
1022 if test "$fp_cv_ld_no_compact_unwind" = yes; then
1023   LdHasNoCompactUnwind=YES
1024 else
1025   LdHasNoCompactUnwind=NO
1026 fi
1027 AC_SUBST([LdHasNoCompactUnwind])
1028 ])# FP_PROG_LD_NO_COMPACT_UNWIND
1029
1030
1031 # FP_PROG_LD_FILELIST
1032 # -------------------
1033
1034 # Sets the output variable LdHasFilelist to YES if ld supports
1035 # -filelist, or NO otherwise.
1036 AC_DEFUN([FP_PROG_LD_FILELIST],
1037 [
1038 AC_CACHE_CHECK([whether ld understands -filelist], [fp_cv_ld_has_filelist],
1039 [
1040     echo 'int foo() { return 0; }' > conftest1.c
1041     echo 'int bar() { return 0; }' > conftest2.c
1042     ${CC-cc} -c conftest1.c
1043     ${CC-cc} -c conftest2.c
1044     echo conftest1.o  > conftest.o-files
1045     echo conftest2.o >> conftest.o-files
1046     if ${LdCmd} -r -filelist conftest.o-files -o conftest.o > /dev/null 2>&1
1047     then
1048         fp_cv_ld_has_filelist=yes
1049     else
1050         fp_cv_ld_has_filelist=no
1051     fi
1052     rm -rf conftest*
1053 ])
1054 if test "$fp_cv_ld_has_filelist" = yes; then
1055     LdHasFilelist=YES
1056 else
1057     LdHasFilelist=NO
1058 fi
1059 AC_SUBST([LdHasFilelist])
1060 ])# FP_PROG_LD_FILELIST
1061
1062
1063 # FP_PROG_AR
1064 # ----------
1065 # Sets fp_prog_ar to a path to ar. Exits if no ar can be found
1066 AC_DEFUN([FP_PROG_AR],
1067 [AC_PATH_PROG([fp_prog_ar], [ar])
1068 if test -z "$fp_prog_ar"; then
1069   AC_MSG_ERROR([cannot find ar in your PATH, no idea how to make a library])
1070 fi
1071 ])# FP_PROG_AR
1072
1073
1074 # FP_PROG_AR_IS_GNU
1075 # -----------------
1076 # Sets fp_prog_ar_is_gnu to yes or no, depending on whether it is GNU ar or not.
1077 AC_DEFUN([FP_PROG_AR_IS_GNU],
1078 [AC_REQUIRE([FP_PROG_AR])
1079 AC_CACHE_CHECK([whether $fp_prog_ar is GNU ar], [fp_cv_prog_ar_is_gnu],
1080 [if "$fp_prog_ar" --version 2> /dev/null | grep "GNU" > /dev/null 2>&1; then
1081   fp_cv_prog_ar_is_gnu=yes
1082 else
1083   fp_cv_prog_ar_is_gnu=no
1084 fi])
1085 fp_prog_ar_is_gnu=$fp_cv_prog_ar_is_gnu
1086 AC_SUBST([ArIsGNUAr], [`echo $fp_prog_ar_is_gnu | tr 'a-z' 'A-Z'`])
1087 ])# FP_PROG_AR_IS_GNU
1088
1089
1090 # FP_PROG_AR_SUPPORTS_ATFILE
1091 # -----------------
1092 # Sets fp_prog_ar_supports_atfile to yes or no, depending on whether
1093 # or not it supports the @file syntax
1094 AC_DEFUN([FP_PROG_AR_SUPPORTS_ATFILE],
1095 [AC_REQUIRE([FP_PROG_AR])
1096  AC_REQUIRE([FP_PROG_AR_ARGS])
1097 AC_CACHE_CHECK([whether $fp_prog_ar supports @file], [fp_cv_prog_ar_supports_atfile],
1098 [
1099 rm -f conftest*
1100 touch conftest.file
1101 echo conftest.file  > conftest.atfile
1102 echo conftest.file >> conftest.atfile
1103 "$fp_prog_ar" $fp_prog_ar_args conftest.a @conftest.atfile > /dev/null 2>&1
1104 fp_prog_ar_supports_atfile_tmp=`"$fp_prog_ar" t conftest.a 2> /dev/null | grep -c conftest.file`
1105 rm -f conftest*
1106 if test "$fp_prog_ar_supports_atfile_tmp" -eq 2
1107 then
1108   fp_cv_prog_ar_supports_atfile=yes
1109 else
1110   fp_cv_prog_ar_supports_atfile=no
1111 fi])
1112 fp_prog_ar_supports_atfile=$fp_cv_prog_ar_supports_atfile
1113 AC_SUBST([ArSupportsAtFile], [`echo $fp_prog_ar_supports_atfile | tr 'a-z' 'A-Z'`])
1114 ])# FP_PROG_AR_SUPPORTS_ATFILE
1115
1116 # FP_PROG_AR_ARGS
1117 # ---------------
1118 # Sets fp_prog_ar_args to the arguments for ar and the output variable ArCmd
1119 # to an invocation of ar including these arguments.
1120 AC_DEFUN([FP_PROG_AR_ARGS],
1121 [AC_REQUIRE([FP_PROG_AR_IS_GNU])
1122 AC_CACHE_CHECK([for ar arguments], [fp_cv_prog_ar_args],
1123 [
1124 # GNU ar needs special treatment: it appears to have problems with
1125 # object files with the same name if you use the 's' modifier, but
1126 # simple 'ar q' works fine, and doesn't need a separate ranlib.
1127 if test $fp_prog_ar_is_gnu = yes; then
1128   fp_cv_prog_ar_args="q"
1129 else
1130   touch conftest.dummy
1131   for fp_var in clqsZ clqs cqs clq cq ; do
1132      rm -f conftest.a
1133      if "$fp_prog_ar" $fp_var conftest.a conftest.dummy > /dev/null 2> /dev/null; then
1134         fp_cv_prog_ar_args=$fp_var
1135         break
1136      fi
1137   done
1138   rm -f conftest*
1139   if test -z "$fp_cv_prog_ar_args"; then
1140     AC_MSG_ERROR([cannot figure out how to use your $fp_prog_ar])
1141   fi
1142 fi])
1143 fp_prog_ar_args=$fp_cv_prog_ar_args
1144 AC_SUBST([ArCmd], ["$fp_prog_ar"])
1145 AC_SUBST([ArArgs], ["$fp_prog_ar_args"])
1146
1147 ])# FP_PROG_AR_ARGS
1148
1149
1150 # FP_PROG_AR_NEEDS_RANLIB
1151 # -----------------------
1152 # Sets the output variable RANLIB_CMD to "ranlib" if it is needed and
1153 # found, to "true" otherwise. Sets REAL_RANLIB_CMD to the ranlib program,
1154 # even if we don't need ranlib (libffi might still need it).
1155 AC_DEFUN([FP_PROG_AR_NEEDS_RANLIB],[
1156     AC_REQUIRE([FP_PROG_AR_IS_GNU])
1157     AC_REQUIRE([FP_PROG_AR_ARGS])
1158     AC_REQUIRE([AC_PROG_CC])
1159
1160     AC_PROG_RANLIB
1161
1162     if test $fp_prog_ar_is_gnu = yes
1163     then
1164         fp_cv_prog_ar_needs_ranlib=no
1165     elif test "$TargetOS_CPP" = "darwin"
1166     then
1167         # It's quite tedious to check for Apple's crazy timestamps in
1168         # .a files, so we hardcode it.
1169         fp_cv_prog_ar_needs_ranlib=yes
1170     else
1171         case $fp_prog_ar_args in
1172         *s*)
1173             fp_cv_prog_ar_needs_ranlib=no;;
1174         *)
1175             fp_cv_prog_ar_needs_ranlib=yes;;
1176         esac
1177     fi
1178
1179     # workaround for AC_PROG_RANLIB which sets RANLIB to `:' when
1180     # ranlib is missing on the target OS. The problem is that
1181     # ghc-cabal cannot execute `:' which is a shell built-in but can
1182     # execute `true' which is usually simple program supported by the
1183     # OS.
1184     # Fixes #8795
1185     if test "$RANLIB" = ":"
1186     then
1187         RANLIB="true"
1188     fi
1189     REAL_RANLIB_CMD="$RANLIB"
1190     if test $fp_cv_prog_ar_needs_ranlib = yes
1191     then
1192         RANLIB_CMD="$RANLIB"
1193     else
1194         RANLIB_CMD="true"
1195     fi
1196     AC_SUBST([REAL_RANLIB_CMD])
1197     AC_SUBST([RANLIB_CMD])
1198 ])# FP_PROG_AR_NEEDS_RANLIB
1199
1200
1201 # FP_GCC_VERSION
1202 # -----------
1203 # Extra testing of the result AC_PROG_CC, testing the gcc version no. Sets the
1204 # output variable GccVersion.
1205 AC_DEFUN([FP_GCC_VERSION],
1206 [AC_REQUIRE([AC_PROG_CC])
1207 if test -z "$CC"
1208 then
1209   AC_MSG_ERROR([gcc is required])
1210 fi
1211 GccLT34=NO
1212 GccLT46=NO
1213 AC_CACHE_CHECK([version of gcc], [fp_cv_gcc_version],
1214 [
1215     fp_cv_gcc_version="`$CC -v 2>&1 | grep 'version ' | sed -e 's/.*version [[^0-9]]*\([[0-9.]]*\).*/\1/g'`"
1216     FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-lt], [3.0],
1217                         [AC_MSG_ERROR([Need at least gcc version 3.0 (3.4+ recommended)])])
1218     # See #2770: gcc 2.95 doesn't work any more, apparently.  There probably
1219     # isn't a very good reason for that, but for now just make configure
1220     # fail.
1221     FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-lt], [3.4], GccLT34=YES)
1222     FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-lt], [4.6], GccLT46=YES)
1223 ])
1224 AC_SUBST([GccVersion], [$fp_cv_gcc_version])
1225 AC_SUBST(GccLT34)
1226 AC_SUBST(GccLT46)
1227 ])# FP_GCC_VERSION
1228
1229 dnl Check to see if the C compiler is clang or llvm-gcc
1230 dnl
1231 GccIsClang=NO
1232 AC_DEFUN([FP_CC_LLVM_BACKEND],
1233 [AC_REQUIRE([AC_PROG_CC])
1234 AC_MSG_CHECKING([whether C compiler is clang])
1235 $CC -x c /dev/null -dM -E > conftest.txt 2>&1
1236 if grep "__clang__" conftest.txt >/dev/null 2>&1; then
1237   AC_SUBST([CC_CLANG_BACKEND], [1])
1238   AC_SUBST([CC_LLVM_BACKEND], [1])
1239   GccIsClang=YES
1240   AC_MSG_RESULT([yes])
1241 else
1242   AC_MSG_RESULT([no])
1243   AC_MSG_CHECKING([whether C compiler has an LLVM back end])
1244   if grep "__llvm__" conftest.txt >/dev/null 2>&1; then
1245     AC_SUBST([CC_CLANG_BACKEND], [0])
1246     AC_SUBST([CC_LLVM_BACKEND], [1])
1247     AC_MSG_RESULT([yes])
1248   else
1249     AC_SUBST([CC_CLANG_BACKEND], [0])
1250     AC_SUBST([CC_LLVM_BACKEND], [0])
1251     AC_MSG_RESULT([no])
1252   fi
1253 fi
1254 AC_SUBST(GccIsClang)
1255
1256 rm -f conftest.txt
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)
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|osf1|osf3|hpux|linuxaout|kfreebsdgnu|freebsd2|solaris2|mingw32|darwin|gnu|nextstep2|nextstep3|sunos4|ultrix|irix|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 with option name
1973 # $3 = the command to look for
1974 # $4 = the version of the command to look for
1975 #
1976 AC_DEFUN([FIND_LLVM_PROG],[
1977     # Test for program with version name.
1978     FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL_NOTARGET([$1], [$2], [$3-$4])
1979     if test -z "$$1"; then
1980         # Test for program without version name.
1981         FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL_NOTARGET([$1], [$2], [$3])
1982         if test -n "$$1"; then
1983             AC_MSG_CHECKING([$$1 is version $4])
1984             if test `$$1 --version | grep -c "version $4"` -gt 0 ; then
1985                 AC_MSG_RESULT(yes)
1986             else
1987                 AC_MSG_RESULT(no)
1988                 $1=""
1989             fi
1990         fi
1991     fi
1992 ])
1993
1994 # FIND_LD
1995 # Find the version of `ld` to use. This is used in both in the top level
1996 # configure.ac and in distrib/configure.ac.in.
1997 #
1998 # $1 = the variable to set
1999 #
2000 AC_DEFUN([FIND_LD],[
2001     FP_ARG_WITH_PATH_GNU_PROG([LD], [ld], [ld])
2002     case $target in
2003         arm*linux*       | \
2004         aarch64*linux*   )
2005             # Arm and Aarch64 requires use of the binutils ld.gold linker.
2006             # This case should catch at least arm-unknown-linux-gnueabihf,
2007             # arm-linux-androideabi, arm64-unknown-linux and
2008             # aarch64-linux-android
2009             FP_ARG_WITH_PATH_GNU_PROG([LD_GOLD], [ld.gold], [ld.gold])
2010             $1="$LD_GOLD"
2011             ;;
2012         *)
2013             $1="$LD"
2014             ;;
2015     esac
2016 ])
2017
2018 # FIND_GHC_BOOTSTRAP_PROG()
2019 # --------------------------------
2020 # Parse the bootstrap GHC's compier settings file for the location of things
2021 # like the `llc` and `opt` commands.
2022 #
2023 # $1 = the variable to set
2024 # $2 = The bootstrap compiler.
2025 # $3 = The string to grep for to find the correct line.
2026 #
2027 AC_DEFUN([FIND_GHC_BOOTSTRAP_PROG],[
2028     BootstrapTmpCmd=`grep $3 $($2 --print-libdir)/settings 2>/dev/null | sed 's/.*", "//;s/".*//'`
2029     if test -n "$BootstrapTmpCmd" && test `basename $BootstrapTmpCmd` = $BootstrapTmpCmd ; then
2030         AC_PATH_PROG([$1], [$BootstrapTmpCmd], "")
2031     else
2032         $1=$BootstrapTmpCmd
2033     fi
2034 ])
2035
2036
2037 # FIND_GCC()
2038 # --------------------------------
2039 # Finds where gcc is
2040 #
2041 # $1 = the variable to set
2042 # $2 = the with option name
2043 # $3 = the command to look for
2044 AC_DEFUN([FIND_GCC],[
2045     if test "$TargetOS_CPP" = "darwin" &&
2046        test "$XCodeVersion1" -eq 4 &&
2047        test "$XCodeVersion2" -lt 2
2048     then
2049         # In Xcode 4.1, 'gcc-4.2' is the gcc legacy backend (rather
2050         # than the LLVM backend). We prefer the legacy gcc, but in
2051         # Xcode 4.2 'gcc-4.2' was removed.
2052         FP_ARG_WITH_PATH_GNU_PROG([$1], [gcc-4.2], [gcc-4.2])
2053     elif test "$windows" = YES
2054     then
2055         $1="$CC"
2056     else
2057         FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL([$1], [$2], [$3])
2058         # From Xcode 5 on/, OS X command line tools do not include gcc
2059         # anymore. Use clang.
2060         if test -z "$$1"
2061         then
2062             FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL([$1], [clang], [clang])
2063         fi
2064         if test -z "$$1"
2065         then
2066             AC_MSG_ERROR([cannot find $3 nor clang in your PATH])
2067         fi
2068     fi
2069     AC_SUBST($1)
2070 ])
2071
2072 AC_DEFUN([MAYBE_OVERRIDE_STAGE0],[
2073   if test ! -z "$With_$1" -a "$CrossCompiling" != "YES"; then
2074       AC_MSG_NOTICE([Not cross-compiling, so --with-$1 also sets $2])
2075       $2=$With_$1
2076   fi
2077 ])
2078
2079
2080 # FP_CPP_CMD_WITH_ARGS()
2081 # ----------------------
2082 # sets CPP command and its arguments
2083 #
2084 # $1 = the variable to set to CPP command
2085 # $2 = the varibale to set to CPP command arguments
2086
2087 AC_DEFUN([FP_CPP_CMD_WITH_ARGS],[
2088 dnl ** what cpp to use?
2089 dnl --------------------------------------------------------------
2090 AC_ARG_WITH(hs-cpp,
2091 [AC_HELP_STRING([--with-hs-cpp=ARG],
2092       [Path to the (C) preprocessor for Haskell files [default=autodetect]])],
2093 [
2094     if test "$HostOS" = "mingw32"
2095     then
2096         AC_MSG_WARN([Request to use $withval will be ignored])
2097     else
2098         HS_CPP_CMD=$withval
2099     fi
2100 ],
2101 [
2102
2103     # We can't use $CPP here, since HS_CPP_CMD is expected to be a single
2104     # command (no flags), and AC_PROG_CPP defines CPP as "/usr/bin/gcc -E".
2105     HS_CPP_CMD=$WhatGccIsCalled
2106
2107     SOLARIS_GCC_CPP_BROKEN=NO
2108     SOLARIS_FOUND_GOOD_CPP=NO
2109     case $host in
2110         i386-*-solaris2)
2111         GCC_MAJOR_MINOR=`$WhatGccIsCalled --version|grep "gcc (GCC)"|cut -d ' ' -f 3-3|cut -d '.' -f 1-2`
2112         if test "$GCC_MAJOR_MINOR" != "3.4"; then
2113           # this is not 3.4.x release so with broken CPP
2114           SOLARIS_GCC_CPP_BROKEN=YES
2115         fi
2116         ;;
2117     esac
2118
2119     if test "$SOLARIS_GCC_CPP_BROKEN" = "YES"; then
2120       # let's try to find if GNU C 3.4.x is installed
2121       if test -x /usr/sfw/bin/gcc; then
2122         # something executable is in expected path so let's
2123         # see if it's really GNU C
2124         NEW_GCC_MAJOR_MINOR=`/usr/sfw/bin/gcc --version|grep "gcc (GCC)"|cut -d ' ' -f 3-3|cut -d '.' -f 1-2`
2125         if test "$NEW_GCC_MAJOR_MINOR" = "3.4"; then
2126           # this is GNU C 3.4.x which provides non-broken CPP on Solaris
2127           # let's use it as CPP then.
2128           HS_CPP_CMD=/usr/sfw/bin/gcc
2129           SOLARIS_FOUND_GOOD_CPP=YES
2130         fi
2131       fi
2132       if test "$SOLARIS_FOUND_GOOD_CPP" = "NO"; then
2133         AC_MSG_WARN([Your GNU C provides broken CPP and you do not have GNU C 3.4.x installed.])
2134         AC_MSG_WARN([Please install GNU C 3.4.x to solve this issue. It will be used as CPP only.])
2135       fi
2136     fi
2137 ]
2138 )
2139
2140
2141
2142 dnl ** what cpp flags to use?
2143 dnl -----------------------------------------------------------
2144 AC_ARG_WITH(hs-cpp-flags,
2145   [AC_HELP_STRING([--with-hs-cpp-flags=ARG],
2146       [Flags to the (C) preprocessor for Haskell files [default=autodetect]])],
2147   [
2148       if test "$HostOS" = "mingw32"
2149       then
2150           AC_MSG_WARN([Request to use $withval will be ignored])
2151       else
2152           HS_CPP_ARGS=$withval
2153       fi
2154   ],
2155 [
2156   $HS_CPP_CMD -x c /dev/null -dM -E > conftest.txt 2>&1
2157   if grep "__clang__" conftest.txt >/dev/null 2>&1; then
2158     HS_CPP_ARGS="-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs"
2159   else
2160       $HS_CPP_CMD  -v > conftest.txt 2>&1
2161       if  grep "gcc" conftest.txt >/dev/null 2>&1; then
2162           HS_CPP_ARGS="-E -undef -traditional"
2163         else
2164           $HS_CPP_CMD  --version > conftest.txt 2>&1
2165           if grep "cpphs" conftest.txt >/dev/null 2>&1; then
2166             HS_CPP_ARGS="--cpp -traditional"
2167           else
2168             AC_MSG_WARN([configure can't recognize your CPP program, you may need to set --with-hs-cpp-flags=FLAGS explicitly])
2169             HS_CPP_ARGS=""
2170           fi
2171       fi
2172   fi
2173   ]
2174 )
2175
2176 $1=$HS_CPP_CMD
2177 $2=$HS_CPP_ARGS
2178
2179 ])
2180
2181 # FP_BFD_SUPPORT()
2182 # ----------------------
2183 # whether to use libbfd for debugging RTS
2184 AC_DEFUN([FP_BFD_SUPPORT], [
2185     AC_ARG_ENABLE(bfd-debug,
2186         [AC_HELP_STRING([--enable-bfd-debug],
2187               [Enable symbol resolution for -debug rts ('+RTS -Di') via binutils' libbfd [default=no]])],
2188         [
2189             # don't pollute general LIBS environment
2190             save_LIBS="$LIBS"
2191             AC_CHECK_HEADERS([bfd.h])
2192             dnl ** check whether this machine has BFD and libiberty installed (used for debugging)
2193             dnl    the order of these tests matters: bfd needs libiberty
2194             AC_CHECK_LIB(iberty, xmalloc)
2195             dnl 'bfd_init' is a rare non-macro in libbfd
2196             AC_CHECK_LIB(bfd,    bfd_init)
2197
2198             AC_TRY_LINK([#include <bfd.h>],
2199                         [
2200                                 /* mimic our rts/Printer.c */
2201                                 bfd* abfd;
2202                                 const char * name;
2203                                 char **matching;
2204
2205                                 name = "some.executable";
2206                                 bfd_init();
2207                                 abfd = bfd_openr(name, "default");
2208                                 bfd_check_format_matches (abfd, bfd_object, &matching);
2209                                 {
2210                                     long storage_needed;
2211                                     storage_needed = bfd_get_symtab_upper_bound (abfd);
2212                                 }
2213                                 {
2214                                     asymbol **symbol_table;
2215                                     long number_of_symbols;
2216                                     symbol_info info;
2217
2218                                     number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
2219                                     bfd_get_symbol_info(abfd,symbol_table[0],&info);
2220                                 }
2221                         ],
2222                         [],dnl bfd seems to work
2223                         [AC_MSG_ERROR([can't use 'bfd' library])])
2224             LIBS="$save_LIBS"
2225         ]
2226     )
2227 ])
2228
2229 # LocalWords:  fi