aclocal.m4: Fix llc/opt detection code
[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
456
457 # FP_SETTINGS
458 # ----------------------------------
459 # Set the variables used in the settings file
460 AC_DEFUN([FP_SETTINGS],
461 [
462     if test "$windows" = YES
463     then
464         mingw_bin_prefix=mingw/bin/
465         SettingsCCompilerCommand="\$topdir/../${mingw_bin_prefix}gcc.exe"
466         SettingsHaskellCPPCommand="\$topdir/../${mingw_bin_prefix}gcc.exe"
467         SettingsHaskellCPPFlags="$HaskellCPPArgs"
468         SettingsLdCommand="\$topdir/../${mingw_bin_prefix}ld.exe"
469         SettingsArCommand="\$topdir/../${mingw_bin_prefix}ar.exe"
470         SettingsPerlCommand='$topdir/../perl/perl.exe'
471         SettingsDllWrapCommand="\$topdir/../${mingw_bin_prefix}dllwrap.exe"
472         SettingsWindresCommand="\$topdir/../${mingw_bin_prefix}windres.exe"
473         SettingsTouchCommand='$topdir/bin/touchy.exe'
474     else
475         SettingsCCompilerCommand="$WhatGccIsCalled"
476         SettingsHaskellCPPCommand="$HaskellCPPCmd"
477         SettingsHaskellCPPFlags="$HaskellCPPArgs"
478         SettingsLdCommand="$LdCmd"
479         SettingsArCommand="$ArCmd"
480         SettingsPerlCommand="$PerlCmd"
481         SettingsDllWrapCommand="/bin/false"
482         SettingsWindresCommand="/bin/false"
483         SettingsLibtoolCommand="libtool"
484         SettingsTouchCommand='touch'
485     fi
486     if test -z "$LlcCmd"
487     then
488       SettingsLlcCommand="llc"
489     else
490       SettingsLlcCommand="$LlcCmd"
491     fi
492     if test -z "$OptCmd"
493     then
494       SettingsOptCommand="opt"
495     else
496       SettingsOptCommand="$OptCmd"
497     fi
498     SettingsCCompilerFlags="$CONF_CC_OPTS_STAGE2"
499     SettingsCCompilerLinkFlags="$CONF_GCC_LINKER_OPTS_STAGE2"
500     SettingsLdFlags="$CONF_LD_LINKER_OPTS_STAGE2"
501     AC_SUBST(SettingsCCompilerCommand)
502     AC_SUBST(SettingsHaskellCPPCommand)
503     AC_SUBST(SettingsHaskellCPPFlags)
504     AC_SUBST(SettingsCCompilerFlags)
505     AC_SUBST(SettingsCCompilerLinkFlags)
506     AC_SUBST(SettingsLdCommand)
507     AC_SUBST(SettingsLdFlags)
508     AC_SUBST(SettingsArCommand)
509     AC_SUBST(SettingsPerlCommand)
510     AC_SUBST(SettingsDllWrapCommand)
511     AC_SUBST(SettingsWindresCommand)
512     AC_SUBST(SettingsLibtoolCommand)
513     AC_SUBST(SettingsTouchCommand)
514     AC_SUBST(SettingsLlcCommand)
515     AC_SUBST(SettingsOptCommand)
516 ])
517
518
519 # FPTOOLS_SET_C_LD_FLAGS
520 # ----------------------------------
521 # Set the C, LD and CPP flags for a given platform
522 # $1 is the platform
523 # $2 is the name of the CC flags variable
524 # $3 is the name of the linker flags variable when linking with gcc
525 # $4 is the name of the linker flags variable when linking with ld
526 # $5 is the name of the CPP flags variable
527 AC_DEFUN([FPTOOLS_SET_C_LD_FLAGS],
528 [
529     AC_MSG_CHECKING([Setting up $2, $3, $4 and $5])
530     case $$1 in
531     i386-*)
532         # Workaround for #7799
533         $2="$$2 -U__i686"
534         ;;
535     esac
536
537     case $$1 in
538     i386-unknown-mingw32)
539         $2="$$2 -march=i686"
540         ;;
541     i386-portbld-freebsd*)
542         $2="$$2 -march=i686"
543         ;;
544     i386-apple-darwin)
545         $2="$$2 -m32"
546         $3="$$3 -m32"
547         $4="$$4 -arch i386"
548         $5="$$5 -m32"
549         ;;
550     x86_64-apple-darwin)
551         $2="$$2 -m64"
552         $3="$$3 -m64"
553         $4="$$4 -arch x86_64"
554         $5="$$5 -m64"
555         ;;
556     x86_64-unknown-solaris2)
557         $2="$$2 -m64"
558         $3="$$3 -m64"
559         $4="$$4 -m64"
560         $5="$$5 -m64"
561         ;;
562     alpha-*)
563         # For now, to suppress the gcc warning "call-clobbered
564         # register used for global register variable", we simply
565         # disable all warnings altogether using the -w flag. Oh well.
566         $2="$$2 -w -mieee -D_REENTRANT"
567         $3="$$3 -w -mieee -D_REENTRANT"
568         $5="$$5 -w -mieee -D_REENTRANT"
569         ;;
570     hppa*)
571         # ___HPUX_SOURCE, not _HPUX_SOURCE, is #defined if -ansi!
572         # (very nice, but too bad the HP /usr/include files don't agree.)
573         $2="$$2 -D_HPUX_SOURCE"
574         $3="$$3 -D_HPUX_SOURCE"
575         $5="$$5 -D_HPUX_SOURCE"
576         ;;
577     arm*linux*)
578         # On arm/linux and arm/android, tell gcc to generate Arm
579         # instructions (ie not Thumb) and to link using the gold linker.
580         # Forcing LD to be ld.gold is done in FIND_LD m4 macro.
581         $2="$$2 -marm"
582         $3="$$3 -fuse-ld=gold -Wl,-z,noexecstack"
583         $4="$$4 -z noexecstack"
584         ;;
585
586     aarch64*linux*)
587         # On aarch64/linux and aarch64/android, tell gcc to link using the
588         # gold linker.
589         # Forcing LD to be ld.gold is done in FIND_LD m4 macro.
590         $3="$$3 -fuse-ld=gold -Wl,-z,noexecstack"
591         $4="$$4 -z noexecstack"
592         ;;
593
594     powerpc-ibm-aix*)
595         # On IBM AIX, we need to workaround XCOFF's limitations. Specifically,
596         # there's a TOC which only supports at most 16k entries (see
597         # http://www.ibm.com/developerworks/rational/library/overview-toc-aix/
598         # for more details), and by using `-mminimal-toc` we use up only one TOC
599         # entry per translation unit, at the cost of an additional pointer
600         # indirection. However, see note in `compiler/ghc.mk` about `Parser.hs`.
601         # Finally, we need `-D_THREAD_SAFE` to unlock a thread-local `errno`.
602         $2="$$2 -mminimal-toc -D_THREAD_SAFE"
603         $3="$$3 -mminimal-toc -D_THREAD_SAFE"
604         $5="$$5 -D_THREAD_SAFE"
605         ;;
606
607     esac
608
609     # If gcc knows about the stack protector, turn it off.
610     # Otherwise the stack-smash handler gets triggered.
611     echo 'int main(void) {return 0;}' > conftest.c
612     if $CC -c conftest.c -fno-stack-protector > /dev/null 2>&1
613     then
614         $2="$$2 -fno-stack-protector"
615     fi
616
617     rm -f conftest.c conftest.o
618     AC_MSG_RESULT([done])
619 ])
620
621
622 # FP_VISIBILITY_HIDDEN
623 # ----------------------------------
624 # Is the visibility hidden attribute supported?
625 AC_DEFUN([FP_VISIBILITY_HIDDEN],
626 [
627     AC_MSG_CHECKING([whether __attribute__((visibility("hidden"))) is supported])
628     echo '__attribute__((visibility("hidden"))) void foo(void) {}' > conftest.c
629     if $CC -Wall -Werror -c conftest.c > /dev/null 2>&1
630     then
631         AC_MSG_RESULT([yes])
632         AC_DEFINE(HAS_VISIBILITY_HIDDEN, 1, [Has visibility hidden])
633     else
634         AC_MSG_RESULT([no])
635     fi
636     rm -f conftest.c conftest.o
637 ])
638
639
640 # FPTOOLS_FLOAT_WORD_ORDER_BIGENDIAN
641 # ----------------------------------
642 # Little endian ARM on Linux with some ABIs has big endian word order
643 # in doubles. Define FLOAT_WORDS_BIGENDIAN if this is the case.
644 AC_DEFUN([FPTOOLS_FLOAT_WORD_ORDER_BIGENDIAN],
645   [AC_CACHE_CHECK([whether float word order is big endian], [fptools_cv_float_word_order_bigendian],
646     [AC_COMPILE_IFELSE(
647       [AC_LANG_PROGRAM(
648         [#include <endian.h>],
649         [#if defined(__FLOAT_WORD_ORDER) && __FLOAT_WORD_ORDER == BIG_ENDIAN
650              return 0;
651          #else
652              not float word order big endian
653          #endif]
654       )],
655       [fptools_cv_float_word_order_bigendian=yes],
656       [fptools_cv_float_word_order_bigendian=no])
657     ])
658   case $fptools_cv_float_word_order_bigendian in
659       yes)
660           AC_DEFINE([FLOAT_WORDS_BIGENDIAN], 1,
661           [Define to 1 if your processor stores words of floats with
662            the most significant byte first]) ;;
663   esac
664 ])
665
666
667 # FP_ARG_WITH_PATH_GNU_PROG_GENERAL
668 # --------------------
669 # Find the specified command on the path or allow a user to set it manually
670 # with a --with-<command> option.
671 #
672 # This is ignored on the mingw32 platform.
673 #
674 # $1 = the variable to set
675 # $2 = the with option name
676 # $3 = the command to look for
677 # $4 = prepend target to program name? if 'no', use the name unchanged
678 # $5 = optional? if 'no', then raise an error if the command isn't found
679 #
680 AC_DEFUN([FP_ARG_WITH_PATH_GNU_PROG_GENERAL],
681 [
682 AC_ARG_WITH($2,
683 [AC_HELP_STRING([--with-$2=ARG],
684         [Use ARG as the path to $2 [default=autodetect]])],
685 [
686     if test "$HostOS" = "mingw32"
687     then
688         AC_MSG_WARN([Request to use $withval will be ignored])
689     else
690         $1=$withval
691     fi
692
693     # Remember that we set this manually.  Used to override CC_STAGE0
694     # and friends later, if we are not cross-compiling.
695     With_$2=$withval
696 ],
697 [
698     if test "$HostOS" != "mingw32"
699     then
700         if test "$4" = "no" -o "$target_alias" = "" ; then
701             AC_PATH_PROG([$1], [$3])
702         else
703             AC_PATH_PROG([$1], [$target_alias-$3])
704         fi
705         if test "$5" = "no" -a -z "$$1"
706         then
707             AC_MSG_ERROR([cannot find $3 in your PATH])
708         fi
709     fi
710 ]
711 )
712 ]) # FP_ARG_WITH_PATH_GNU_PROG_GENERAL
713
714
715 # FP_ARG_WITH_PATH_GNU_PROG
716 # --------------------
717 # The usual case: prepend the target, and the program is not optional.
718 AC_DEFUN([FP_ARG_WITH_PATH_GNU_PROG],
719 [FP_ARG_WITH_PATH_GNU_PROG_GENERAL([$1], [$2], [$3], [yes], [no])])
720
721 # FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL
722 # --------------------
723 # Same as FP_ARG_WITH_PATH_GNU_PROG but no error will be thrown if the command
724 # isn't found.
725 AC_DEFUN([FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL],
726 [FP_ARG_WITH_PATH_GNU_PROG_GENERAL([$1], [$2], [$3], [yes], [yes])])
727
728 # FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL_NOTARGET
729 # --------------------
730 # Same as FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL but don't prepend the target name
731 # (used for LLVM).
732 AC_DEFUN([FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL_NOTARGET],
733 [FP_ARG_WITH_PATH_GNU_PROG_GENERAL([$1], [$2], [$3], [no], [yes])])
734
735
736 # FP_PROG_CONTEXT_DIFF
737 # --------------------
738 # Figure out how to do context diffs. Sets the output variable ContextDiffCmd.
739 #
740 # Note: NeXTStep thinks diff'ing a file against itself is "trouble".
741 AC_DEFUN([FP_PROG_CONTEXT_DIFF],
742 [AC_CACHE_CHECK([for a working context diff], [fp_cv_context_diff],
743 [echo foo > conftest1
744 echo foo > conftest2
745 fp_cv_context_diff=no
746 for fp_var in '-U 1' '-u1' '-C 1' '-c1'
747 do
748   if diff $fp_var conftest1 conftest2 > /dev/null 2>&1; then
749     fp_cv_context_diff="diff $fp_var"
750     break
751   fi
752 done])
753 if test x"$fp_cv_context_diff" = xno; then
754    AC_MSG_ERROR([cannot figure out how to do context diffs])
755 fi
756 AC_SUBST(ContextDiffCmd, [$fp_cv_context_diff])
757 ])# FP_PROG_CONTEXT_DIFF
758
759
760 # FP_COMPUTE_INT(EXPRESSION, VARIABLE, INCLUDES, IF-FAILS)
761 # --------------------------------------------------------
762 # Assign VARIABLE the value of the compile-time EXPRESSION using INCLUDES for
763 # compilation. Execute IF-FAILS when unable to determine the value. Works for
764 # cross-compilation, too.
765 #
766 # Implementation note: We are lazy and use an internal autoconf macro, but it
767 # is supported in autoconf versions 2.50 up to the actual 2.57, so there is
768 # little risk.
769 AC_DEFUN([FP_COMPUTE_INT],
770 [_AC_COMPUTE_INT([$1], [$2], [$3], [$4])[]dnl
771 ])# FP_COMPUTE_INT
772
773
774 # FP_CHECK_ALIGNMENT(TYPE, [IGNORED], [INCLUDES = DEFAULT-INCLUDES])
775 # ------------------------------------------------------------------
776 # A variation of AC_CHECK_SIZEOF for computing the alignment restrictions of a
777 # given type. Defines ALIGNMENT_TYPE.
778 AC_DEFUN([FP_CHECK_ALIGNMENT],
779 [AS_LITERAL_IF(m4_translit([[$1]], [*], [p]), [],
780                [AC_FATAL([$0: requires literal arguments])])[]dnl
781 AC_CHECK_TYPE([$1], [], [], [$3])[]dnl
782 m4_pushdef([fp_Cache], [AS_TR_SH([fp_cv_alignment_$1])])[]dnl
783 AC_CACHE_CHECK([alignment of $1], [fp_Cache],
784 [if test "$AS_TR_SH([ac_cv_type_$1])" = yes; then
785   FP_COMPUTE_INT([offsetof(struct { char c; $1 ty; },ty)],
786                  [fp_Cache],
787                  [AC_INCLUDES_DEFAULT([$3])],
788                  [AC_MSG_ERROR([cannot compute alignment ($1)
789 See `config.log' for more details.], [77])])
790 else
791   fp_Cache=0
792 fi])[]dnl
793 AC_DEFINE_UNQUOTED(AS_TR_CPP(alignment_$1), $fp_Cache, [The alignment of a `$1'.])[]dnl
794 m4_popdef([fp_Cache])[]dnl
795 ])# FP_CHECK_ALIGNMENT
796
797
798 # FP_LEADING_UNDERSCORE
799 # ---------------------
800 # Test for determining whether symbol names have a leading underscore. We assume
801 # that they _haven't_ if anything goes wrong. Sets the output variable
802 # LeadingUnderscore to YES or NO and defines LEADING_UNDERSCORE correspondingly.
803 #
804 # Some nlist implementations seem to try to be compatible by ignoring a leading
805 # underscore sometimes (eg. FreeBSD). We therefore have to work around this by
806 # checking for *no* leading underscore first. Sigh.  --SDM
807 #
808 # Similarly on OpenBSD, but this test doesn't help. -- dons
809 AC_DEFUN([FP_LEADING_UNDERSCORE],
810 [AC_CHECK_LIB([elf], [nlist], [LIBS="-lelf $LIBS"])
811 AC_CACHE_CHECK([leading underscore in symbol names], [fptools_cv_leading_underscore], [
812 # Hack!: nlist() under Digital UNIX insist on there being an _,
813 # but symbol table listings shows none. What is going on here?!?
814 case $HostPlatform in
815 *openbsd*) # x86 openbsd is ELF from 3.4 >, meaning no leading uscore
816   case $build in
817     i386-*2\.@<:@0-9@:>@ | i386-*3\.@<:@0-3@:>@ ) fptools_cv_leading_underscore=yes ;;
818     *) fptools_cv_leading_underscore=no ;;
819   esac ;;
820 alpha-dec-osf*) fptools_cv_leading_underscore=no;;
821 i386-unknown-mingw32) fptools_cv_leading_underscore=yes;;
822 x86_64-unknown-mingw32) fptools_cv_leading_underscore=no;;
823
824     # HACK: Apple doesn't seem to provide nlist in the 64-bit-libraries
825 x86_64-apple-darwin*) fptools_cv_leading_underscore=yes;;
826 *-apple-ios) fptools_cv_leading_underscore=yes;;
827
828 *) AC_RUN_IFELSE([AC_LANG_SOURCE([[#ifdef HAVE_NLIST_H
829 #include <nlist.h>
830 struct nlist xYzzY1[] = {{"xYzzY1", 0},{0}};
831 struct nlist xYzzY2[] = {{"_xYzzY2", 0},{0}};
832 #endif
833
834 int main(argc, argv)
835 int argc;
836 char **argv;
837 {
838 #ifdef HAVE_NLIST_H
839     if(nlist(argv[0], xYzzY1) == 0 && xYzzY1[0].n_value != 0)
840         exit(1);
841     if(nlist(argv[0], xYzzY2) == 0 && xYzzY2[0].n_value != 0)
842         exit(0);
843 #endif
844     exit(1);
845 }]])],[fptools_cv_leading_underscore=yes],[fptools_cv_leading_underscore=no],[fptools_cv_leading_underscore=no])
846 ;;
847 esac]);
848 AC_SUBST([LeadingUnderscore], [`echo $fptools_cv_leading_underscore | sed 'y/yesno/YESNO/'`])
849 if test x"$fptools_cv_leading_underscore" = xyes; then
850    AC_DEFINE([LEADING_UNDERSCORE], [1], [Define to 1 if C symbols have a leading underscore added by the compiler.])
851 fi])# FP_LEADING_UNDERSCORE
852
853
854 # FP_COMPARE_VERSIONS(VERSION1, TEST, VERSION2, [ACTION-IF-TRUE], [ACTION-IF-FALSE])
855 # ----------------------------------------------------------------------------------
856 # Compare dotted version numbers VERSION1 and VERSION2 lexicographically according
857 # to TEST (one of -eq, -ne, -lt, -le, -gt, or -ge).
858 AC_DEFUN([FP_COMPARE_VERSIONS],
859 [fp_version1=$1; fp_version2=$3
860 fp_save_IFS=$IFS; IFS='.'
861 while test x"$fp_version1" != x || test x"$fp_version2" != x
862 do
863
864   set dummy $fp_version1; shift
865   fp_num1=""
866   test $[@%:@] = 0 || { fp_num1="[$]1"; shift; }
867   test x"$fp_num1" = x && fp_num1="0"
868   fp_version1="[$]*"
869
870   set dummy $fp_version2; shift
871   fp_num2=""
872   test $[@%:@] = 0 || { fp_num2="[$]1"; shift; }
873   test x"$fp_num2" = x && fp_num2="0"
874   fp_version2="[$]*"
875
876   test "$fp_num1" = "$fp_num2" || break;
877 done
878 IFS=$fp_save_IFS
879 AS_IF([test "$fp_num1" $2 "$fp_num2"], [$4], [$5])[]dnl
880 ])# FP_COMPARE_VERSIONS
881
882
883 dnl
884 dnl Check for Happy and version.
885 dnl If there's no installed Happy, we look
886 dnl for a happy source tree and point the build system at that instead.
887 dnl If you increase the minimum version requirement, please also update:
888 dnl https://ghc.haskell.org/trac/ghc/wiki/Building/Preparation/Tools
889 dnl
890 AC_DEFUN([FPTOOLS_HAPPY],
891 [AC_PATH_PROG(HappyCmd,happy,)
892
893 AC_CACHE_CHECK([for version of happy], fptools_cv_happy_version,
894 changequote(, )dnl
895 [if test x"$HappyCmd" != x; then
896    fptools_cv_happy_version=`"$HappyCmd" -v |
897               grep 'Happy Version' | sed -e 's/Happy Version \([^ ]*\).*/\1/g'` ;
898 else
899    fptools_cv_happy_version="";
900 fi;
901 changequote([, ])dnl
902 ])
903 if test ! -f compiler/parser/Parser.hs || test ! -f compiler/cmm/CmmParse.hs
904 then
905     FP_COMPARE_VERSIONS([$fptools_cv_happy_version],[-lt],[1.19.4],
906       [AC_MSG_ERROR([Happy version 1.19.4 or later is required to compile GHC.])])[]
907 fi
908 HappyVersion=$fptools_cv_happy_version;
909 AC_SUBST(HappyVersion)
910 ])
911
912 dnl
913 dnl Check for Alex and version.
914 dnl If you increase the minimum version requirement, please also update:
915 dnl https://ghc.haskell.org/trac/ghc/wiki/Building/Preparation/Tools
916 dnl
917 AC_DEFUN([FPTOOLS_ALEX],
918 [
919 AC_PATH_PROG(AlexCmd,alex,)
920
921 AC_CACHE_CHECK([for version of alex], fptools_cv_alex_version,
922 changequote(, )dnl
923 [if test x"$AlexCmd" != x; then
924    fptools_cv_alex_version=`"$AlexCmd" -v |
925               grep 'Alex [Vv]ersion' | sed -e 's/Alex [Vv]ersion \([0-9\.]*\).*/\1/g'` ;
926 else
927    fptools_cv_alex_version="";
928 fi;
929 changequote([, ])dnl
930 ])
931 FP_COMPARE_VERSIONS([$fptools_cv_alex_version],[-ge],[3.0],
932   [Alex3=YES],[Alex3=NO])
933 if test ! -f compiler/cmm/CmmLex.hs || test ! -f compiler/parser/Lexer.hs
934 then
935     FP_COMPARE_VERSIONS([$fptools_cv_alex_version],[-lt],[3.1.0],
936       [AC_MSG_ERROR([Alex version 3.1.0 or later is required to compile GHC.])])[]
937 fi
938 AlexVersion=$fptools_cv_alex_version;
939 AC_SUBST(AlexVersion)
940 AC_SUBST(Alex3)
941 ])
942
943
944 # FP_PROG_LD_FLAG
945 # ---------------
946 # Sets the output variable $2 to $1 if ld supports the $1 flag.
947 # Otherwise the variable's value is empty.
948 AC_DEFUN([FP_PROG_LD_FLAG],
949 [
950 AC_CACHE_CHECK([whether ld understands $1], [fp_cv_$2],
951 [echo 'int foo() { return 0; }' > conftest.c
952 ${CC-cc} -c conftest.c
953 if ${LdCmd} -r $1 -o conftest2.o conftest.o > /dev/null 2>&1; then
954    fp_cv_$2=$1
955 else
956    fp_cv_$2=
957 fi
958 rm -rf conftest*])
959 $2=$fp_cv_$2
960 ])# FP_PROG_LD_FLAG
961
962
963 # FP_PROG_LD_BUILD_ID
964 # ------------
965
966 # Sets the output variable LdHasBuildId to YES if ld supports
967 # --build-id, or NO otherwise.
968 AC_DEFUN([FP_PROG_LD_BUILD_ID],
969 [
970 AC_CACHE_CHECK([whether ld understands --build-id], [fp_cv_ld_build_id],
971 [echo 'int foo() { return 0; }' > conftest.c
972 ${CC-cc} -c conftest.c
973 if ${LdCmd} -r --build-id=none -o conftest2.o conftest.o > /dev/null 2>&1; then
974    fp_cv_ld_build_id=yes
975 else
976    fp_cv_ld_build_id=no
977 fi
978 rm -rf conftest*])
979 if test "$fp_cv_ld_build_id" = yes; then
980   LdHasBuildId=YES
981 else
982   LdHasBuildId=NO
983 fi
984 AC_SUBST([LdHasBuildId])
985 ])# FP_PROG_LD_BUILD_ID
986
987
988 # FP_PROG_LD_IS_GNU
989 # -----------------
990 # Sets the output variable LdIsGNULd to YES or NO, depending on whether it is
991 # GNU ld or not.
992 AC_DEFUN([FP_PROG_LD_IS_GNU],
993 [
994 AC_CACHE_CHECK([whether ld is GNU ld], [fp_cv_gnu_ld],
995 [if ${LdCmd} --version 2> /dev/null | grep "GNU" > /dev/null 2>&1; then
996   fp_cv_gnu_ld=yes
997 else
998   fp_cv_gnu_ld=no
999 fi])
1000 AC_SUBST([LdIsGNULd], [`echo $fp_cv_gnu_ld | sed 'y/yesno/YESNO/'`])
1001 ])# FP_PROG_LD_IS_GNU
1002
1003
1004 # FP_PROG_LD_NO_COMPACT_UNWIND
1005 # ----------------------------
1006
1007 # Sets the output variable LdHasNoCompactUnwind to YES if ld supports
1008 # -no_compact_unwind, or NO otherwise.
1009 AC_DEFUN([FP_PROG_LD_NO_COMPACT_UNWIND],
1010 [
1011 AC_CACHE_CHECK([whether ld understands -no_compact_unwind], [fp_cv_ld_no_compact_unwind],
1012 [echo 'int foo() { return 0; }' > conftest.c
1013 ${CC-cc} -c conftest.c
1014 if ${LdCmd} -r -no_compact_unwind -o conftest2.o conftest.o > /dev/null 2>&1; then
1015    fp_cv_ld_no_compact_unwind=yes
1016 else
1017    fp_cv_ld_no_compact_unwind=no
1018 fi
1019 rm -rf conftest*])
1020 if test "$fp_cv_ld_no_compact_unwind" = yes; then
1021   LdHasNoCompactUnwind=YES
1022 else
1023   LdHasNoCompactUnwind=NO
1024 fi
1025 AC_SUBST([LdHasNoCompactUnwind])
1026 ])# FP_PROG_LD_NO_COMPACT_UNWIND
1027
1028
1029 # FP_PROG_LD_FILELIST
1030 # -------------------
1031
1032 # Sets the output variable LdHasFilelist to YES if ld supports
1033 # -filelist, or NO otherwise.
1034 AC_DEFUN([FP_PROG_LD_FILELIST],
1035 [
1036 AC_CACHE_CHECK([whether ld understands -filelist], [fp_cv_ld_has_filelist],
1037 [
1038     echo 'int foo() { return 0; }' > conftest1.c
1039     echo 'int bar() { return 0; }' > conftest2.c
1040     ${CC-cc} -c conftest1.c
1041     ${CC-cc} -c conftest2.c
1042     echo conftest1.o  > conftest.o-files
1043     echo conftest2.o >> conftest.o-files
1044     if ${LdCmd} -r -filelist conftest.o-files -o conftest.o > /dev/null 2>&1
1045     then
1046         fp_cv_ld_has_filelist=yes
1047     else
1048         fp_cv_ld_has_filelist=no
1049     fi
1050     rm -rf conftest*
1051 ])
1052 if test "$fp_cv_ld_has_filelist" = yes; then
1053     LdHasFilelist=YES
1054 else
1055     LdHasFilelist=NO
1056 fi
1057 AC_SUBST([LdHasFilelist])
1058 ])# FP_PROG_LD_FILELIST
1059
1060
1061 # FP_PROG_AR
1062 # ----------
1063 # Sets fp_prog_ar to a path to ar. Exits if no ar can be found
1064 AC_DEFUN([FP_PROG_AR],
1065 [AC_PATH_PROG([fp_prog_ar], [ar])
1066 if test -z "$fp_prog_ar"; then
1067   AC_MSG_ERROR([cannot find ar in your PATH, no idea how to make a library])
1068 fi
1069 ])# FP_PROG_AR
1070
1071
1072 # FP_PROG_AR_IS_GNU
1073 # -----------------
1074 # Sets fp_prog_ar_is_gnu to yes or no, depending on whether it is GNU ar or not.
1075 AC_DEFUN([FP_PROG_AR_IS_GNU],
1076 [AC_REQUIRE([FP_PROG_AR])
1077 AC_CACHE_CHECK([whether $fp_prog_ar is GNU ar], [fp_cv_prog_ar_is_gnu],
1078 [if "$fp_prog_ar" --version 2> /dev/null | grep "GNU" > /dev/null 2>&1; then
1079   fp_cv_prog_ar_is_gnu=yes
1080 else
1081   fp_cv_prog_ar_is_gnu=no
1082 fi])
1083 fp_prog_ar_is_gnu=$fp_cv_prog_ar_is_gnu
1084 AC_SUBST([ArIsGNUAr], [`echo $fp_prog_ar_is_gnu | tr 'a-z' 'A-Z'`])
1085 ])# FP_PROG_AR_IS_GNU
1086
1087
1088 # FP_PROG_AR_SUPPORTS_ATFILE
1089 # -----------------
1090 # Sets fp_prog_ar_supports_atfile to yes or no, depending on whether
1091 # or not it supports the @file syntax
1092 AC_DEFUN([FP_PROG_AR_SUPPORTS_ATFILE],
1093 [AC_REQUIRE([FP_PROG_AR])
1094  AC_REQUIRE([FP_PROG_AR_ARGS])
1095 AC_CACHE_CHECK([whether $fp_prog_ar supports @file], [fp_cv_prog_ar_supports_atfile],
1096 [
1097 rm -f conftest*
1098 touch conftest.file
1099 echo conftest.file  > conftest.atfile
1100 echo conftest.file >> conftest.atfile
1101 "$fp_prog_ar" $fp_prog_ar_args conftest.a @conftest.atfile > /dev/null 2>&1
1102 fp_prog_ar_supports_atfile_tmp=`"$fp_prog_ar" t conftest.a 2> /dev/null | grep -c conftest.file`
1103 rm -f conftest*
1104 if test "$fp_prog_ar_supports_atfile_tmp" -eq 2
1105 then
1106   fp_cv_prog_ar_supports_atfile=yes
1107 else
1108   fp_cv_prog_ar_supports_atfile=no
1109 fi])
1110 fp_prog_ar_supports_atfile=$fp_cv_prog_ar_supports_atfile
1111 AC_SUBST([ArSupportsAtFile], [`echo $fp_prog_ar_supports_atfile | tr 'a-z' 'A-Z'`])
1112 ])# FP_PROG_AR_SUPPORTS_ATFILE
1113
1114 # FP_PROG_AR_ARGS
1115 # ---------------
1116 # Sets fp_prog_ar_args to the arguments for ar and the output variable ArCmd
1117 # to an invocation of ar including these arguments.
1118 AC_DEFUN([FP_PROG_AR_ARGS],
1119 [AC_REQUIRE([FP_PROG_AR_IS_GNU])
1120 AC_CACHE_CHECK([for ar arguments], [fp_cv_prog_ar_args],
1121 [
1122 # GNU ar needs special treatment: it appears to have problems with
1123 # object files with the same name if you use the 's' modifier, but
1124 # simple 'ar q' works fine, and doesn't need a separate ranlib.
1125 if test $fp_prog_ar_is_gnu = yes; then
1126   fp_cv_prog_ar_args="q"
1127 else
1128   touch conftest.dummy
1129   for fp_var in clqsZ clqs cqs clq cq ; do
1130      rm -f conftest.a
1131      if "$fp_prog_ar" $fp_var conftest.a conftest.dummy > /dev/null 2> /dev/null; then
1132         fp_cv_prog_ar_args=$fp_var
1133         break
1134      fi
1135   done
1136   rm -f conftest*
1137   if test -z "$fp_cv_prog_ar_args"; then
1138     AC_MSG_ERROR([cannot figure out how to use your $fp_prog_ar])
1139   fi
1140 fi])
1141 fp_prog_ar_args=$fp_cv_prog_ar_args
1142 AC_SUBST([ArCmd], ["$fp_prog_ar"])
1143 AC_SUBST([ArArgs], ["$fp_prog_ar_args"])
1144
1145 ])# FP_PROG_AR_ARGS
1146
1147
1148 # FP_PROG_AR_NEEDS_RANLIB
1149 # -----------------------
1150 # Sets the output variable RANLIB_CMD to "ranlib" if it is needed and
1151 # found, to "true" otherwise. Sets REAL_RANLIB_CMD to the ranlib program,
1152 # even if we don't need ranlib (libffi might still need it).
1153 AC_DEFUN([FP_PROG_AR_NEEDS_RANLIB],[
1154     AC_REQUIRE([FP_PROG_AR_IS_GNU])
1155     AC_REQUIRE([FP_PROG_AR_ARGS])
1156     AC_REQUIRE([AC_PROG_CC])
1157
1158     AC_PROG_RANLIB
1159
1160     if test $fp_prog_ar_is_gnu = yes
1161     then
1162         fp_cv_prog_ar_needs_ranlib=no
1163     elif test "$TargetOS_CPP" = "darwin"
1164     then
1165         # It's quite tedious to check for Apple's crazy timestamps in
1166         # .a files, so we hardcode it.
1167         fp_cv_prog_ar_needs_ranlib=yes
1168     else
1169         case $fp_prog_ar_args in
1170         *s*)
1171             fp_cv_prog_ar_needs_ranlib=no;;
1172         *)
1173             fp_cv_prog_ar_needs_ranlib=yes;;
1174         esac
1175     fi
1176
1177     # workaround for AC_PROG_RANLIB which sets RANLIB to `:' when
1178     # ranlib is missing on the target OS. The problem is that
1179     # ghc-cabal cannot execute `:' which is a shell built-in but can
1180     # execute `true' which is usually simple program supported by the
1181     # OS.
1182     # Fixes #8795
1183     if test "$RANLIB" = ":"
1184     then
1185         RANLIB="true"
1186     fi
1187     REAL_RANLIB_CMD="$RANLIB"
1188     if test $fp_cv_prog_ar_needs_ranlib = yes
1189     then
1190         RANLIB_CMD="$RANLIB"
1191     else
1192         RANLIB_CMD="true"
1193     fi
1194     AC_SUBST([REAL_RANLIB_CMD])
1195     AC_SUBST([RANLIB_CMD])
1196 ])# FP_PROG_AR_NEEDS_RANLIB
1197
1198
1199 # FP_GCC_VERSION
1200 # -----------
1201 # Extra testing of the result AC_PROG_CC, testing the gcc version no. Sets the
1202 # output variable GccVersion.
1203 AC_DEFUN([FP_GCC_VERSION],
1204 [AC_REQUIRE([AC_PROG_CC])
1205 if test -z "$CC"
1206 then
1207   AC_MSG_ERROR([gcc is required])
1208 fi
1209 GccLT34=NO
1210 GccLT46=NO
1211 AC_CACHE_CHECK([version of gcc], [fp_cv_gcc_version],
1212 [
1213     fp_cv_gcc_version="`$CC -v 2>&1 | grep 'version ' | sed -e 's/.*version [[^0-9]]*\([[0-9.]]*\).*/\1/g'`"
1214     FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-lt], [3.0],
1215                         [AC_MSG_ERROR([Need at least gcc version 3.0 (3.4+ recommended)])])
1216     # See #2770: gcc 2.95 doesn't work any more, apparently.  There probably
1217     # isn't a very good reason for that, but for now just make configure
1218     # fail.
1219     FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-lt], [3.4], GccLT34=YES)
1220     FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-lt], [4.6], GccLT46=YES)
1221 ])
1222 AC_SUBST([GccVersion], [$fp_cv_gcc_version])
1223 AC_SUBST(GccLT34)
1224 AC_SUBST(GccLT46)
1225 ])# FP_GCC_VERSION
1226
1227 dnl Check to see if the C compiler is clang or llvm-gcc
1228 dnl
1229 GccIsClang=NO
1230 AC_DEFUN([FP_CC_LLVM_BACKEND],
1231 [AC_REQUIRE([AC_PROG_CC])
1232 AC_MSG_CHECKING([whether C compiler is clang])
1233 $CC -x c /dev/null -dM -E > conftest.txt 2>&1
1234 if grep "__clang__" conftest.txt >/dev/null 2>&1; then
1235   AC_SUBST([CC_CLANG_BACKEND], [1])
1236   AC_SUBST([CC_LLVM_BACKEND], [1])
1237   GccIsClang=YES
1238   AC_MSG_RESULT([yes])
1239 else
1240   AC_MSG_RESULT([no])
1241   AC_MSG_CHECKING([whether C compiler has an LLVM back end])
1242   if grep "__llvm__" conftest.txt >/dev/null 2>&1; then
1243     AC_SUBST([CC_CLANG_BACKEND], [0])
1244     AC_SUBST([CC_LLVM_BACKEND], [1])
1245     AC_MSG_RESULT([yes])
1246   else
1247     AC_SUBST([CC_CLANG_BACKEND], [0])
1248     AC_SUBST([CC_LLVM_BACKEND], [0])
1249     AC_MSG_RESULT([no])
1250   fi
1251 fi
1252 AC_SUBST(GccIsClang)
1253
1254 rm -f conftest.txt
1255 ])
1256
1257 dnl Small feature test for perl version. Assumes PerlCmd
1258 dnl contains path to perl binary.
1259 dnl
1260 dnl (Perl versions prior to v5.6 does not contain the string "v5";
1261 dnl instead they display version strings such as "version 5.005".)
1262 dnl
1263 AC_DEFUN([FPTOOLS_CHECK_PERL_VERSION],
1264 [$PerlCmd -v >conftest.out 2>&1
1265    if grep "v5" conftest.out >/dev/null 2>&1; then
1266       :
1267    else
1268       AC_MSG_ERROR([your version of perl probably won't work, try upgrading it.])
1269    fi
1270 rm -fr conftest*
1271 ])
1272
1273
1274 # FP_CHECK_PROG(VARIABLE, PROG-TO-CHECK-FOR,
1275 #               [VALUE-IF-NOT-FOUND], [PATH], [REJECT])
1276 # -----------------------------------------------------
1277 # HACK: A small wrapper around AC_CHECK_PROG, setting VARIABLE to the full path
1278 # of PROG-TO-CHECK-FOR when found.
1279 AC_DEFUN([FP_CHECK_PROG],
1280 [AC_CHECK_PROG([$1], [$2], [$as_dir/$ac_word$ac_exec_ext], [$3], [$4], [$5])][]dnl
1281 )# FP_CHECK_PROC
1282
1283
1284 # FP_PROG_FIND
1285 # ------------
1286 # Find a non-WinDoze version of the "find" utility.
1287 AC_DEFUN([FP_PROG_FIND],
1288 [AC_PATH_PROGS([fp_prog_find], [gfind find], find)
1289 echo foo > conftest.txt
1290 $fp_prog_find conftest.txt -print > conftest.out 2>&1
1291 if grep '^conftest.txt$' conftest.out > /dev/null 2>&1 ; then
1292   # OK, looks like a real "find".
1293   FindCmd="$fp_prog_find"
1294 else
1295   # Found a poor WinDoze version of "find", ignore it.
1296   AC_MSG_WARN([$fp_prog_find looks like a non-*nix find, ignoring it])
1297   FP_CHECK_PROG([FindCmd], [find], [], [], [$fp_prog_find])
1298 fi
1299 rm -f conftest.txt conftest.out
1300 AC_SUBST([FindCmd])[]dnl
1301 ])# FP_PROG_FIND
1302
1303
1304 # FP_PROG_SORT
1305 # ------------
1306 # Find a Unix-like sort
1307 AC_DEFUN([FP_PROG_SORT],
1308 [AC_PATH_PROG([fp_prog_sort], [sort])
1309 echo conwip > conftest.txt
1310 $fp_prog_sort -f conftest.txt > conftest.out 2>&1
1311 if grep 'conwip' conftest.out > /dev/null 2>&1 ; then
1312   # The goods
1313   SortCmd="$fp_prog_sort"
1314 else
1315   # Summink else..pick next one.
1316   AC_MSG_WARN([$fp_prog_sort looks like a non-*nix sort, ignoring it])
1317   FP_CHECK_PROG([SortCmd], [sort], [], [], [$fp_prog_sort])
1318 fi
1319 rm -f conftest.txt conftest.out
1320 AC_SUBST([SortCmd])[]dnl
1321 ])# FP_PROG_SORT
1322
1323
1324 dnl
1325 dnl FPTOOLS_NOCACHE_CHECK prints a message, then sets the
1326 dnl values of the second argument to the result of running
1327 dnl the commands given by the third. It does not cache its
1328 dnl result, so it is suitable for checks which should be
1329 dnl run every time.
1330 dnl
1331 AC_DEFUN([FPTOOLS_NOCACHE_CHECK],
1332 [AC_MSG_CHECKING([$1])
1333  $3
1334  AC_MSG_RESULT([$][$2])
1335 ])
1336
1337 dnl
1338 dnl FPTOOLS_GHC_VERSION(version)
1339 dnl FPTOOLS_GHC_VERSION(major, minor [, patchlevel])
1340 dnl FPTOOLS_GHC_VERSION(version, major, minor, patchlevel)
1341 dnl
1342 dnl Test for version of installed ghc.  Uses $GHC.
1343 dnl [original version pinched from c2hs]
1344 dnl
1345 AC_DEFUN([FPTOOLS_GHC_VERSION],
1346 [FPTOOLS_NOCACHE_CHECK([version of ghc], [fptools_version_of_ghc],
1347 ["${WithGhc-ghc}" --version > conftestghc 2>&1
1348   cat conftestghc >&AS_MESSAGE_LOG_FD
1349 #Useless Use Of cat award...
1350   fptools_version_of_ghc=`cat conftestghc | sed -n -e 's/, patchlevel *\([[0-9]]\)/.\1/;s/.* version \([[0-9]][[0-9.]]*\).*/\1/p'`
1351   rm -fr conftest*
1352   if test "[$]fptools_version_of_ghc" = ""
1353   then
1354     fptools_version_of_ghc='unknown'
1355   fi
1356 fptools_version_of_ghc[_major]=`echo [$]fptools_version_of_ghc | sed -e 's/^\([[0-9]]\).*/\1/'`
1357 fptools_version_of_ghc[_minor]=`echo [$]fptools_version_of_ghc | sed -e 's/^[[0-9]]\.\([[0-9]]*\).*/\1/'`
1358 fptools_version_of_ghc[_pl]=`echo [$]fptools_version_of_ghc | sed -n -e 's/^[[0-9]]\.[[0-9]]*\.\([[0-9]]*\)/\1/p'`
1359 #
1360 if test "[$]fptools_version_of_ghc[_pl]" = ""
1361 then
1362   fptools_version_of_ghc[_all]="[$]fptools_version_of_ghc[_major].[$]fptools_version_of_ghc[_minor]"
1363   fptools_version_of_ghc[_pl]="0"
1364 else
1365   fptools_version_of_ghc[_all]="[$]fptools_version_of_ghc[_major].[$]fptools_version_of_ghc[_minor].[$]fptools_version_of_ghc[_pl]"
1366 fi
1367 #
1368 ifelse($#, [1], [dnl
1369 [$1]="[$]fptools_version_of_ghc[_all]"
1370 ], $#, [2], [dnl
1371 [$1]="[$]fptools_version_of_ghc[_major]"
1372 [$2]="[$]fptools_version_of_ghc[_minor]"
1373 ], $#, [3], [dnl
1374 [$1]="[$]fptools_version_of_ghc[_major]"
1375 [$2]="[$]fptools_version_of_ghc[_minor]"
1376 [$3]="[$]fptools_version_of_ghc[_pl]"
1377 ], $#, [4], [dnl
1378 [$1]="[$]fptools_version_of_ghc[_all]"
1379 [$2]="[$]fptools_version_of_ghc[_major]"
1380 [$3]="[$]fptools_version_of_ghc[_minor]"
1381 [$4]="[$]fptools_version_of_ghc[_pl]"
1382 ])
1383 ])
1384 ])dnl
1385
1386
1387 # FP_CHECK_FUNC(FUNCTION, PROLOGUE, BODY, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1388 # ---------------------------------------------------------------------------------
1389 # A variant of AC_CHECK_FUNCS, limited to a single FUNCTION, but with the
1390 # additional flexibility of specifying the PROLOGUE and BODY.
1391 AC_DEFUN([FP_CHECK_FUNC],
1392 [AS_VAR_PUSHDEF([fp_func], [fp_cv_func_$1])dnl
1393 AC_CACHE_CHECK([for $1], fp_func,
1394 [AC_LINK_IFELSE([AC_LANG_PROGRAM([$2], [$3])],
1395                 [AS_VAR_SET(fp_func, yes)],
1396                 [AS_VAR_SET(fp_func, no)])])
1397 AS_IF([test AS_VAR_GET(fp_func) = yes],
1398       [AC_DEFINE(AS_TR_CPP(HAVE_$1), [1],
1399                 [Define to 1 if you have the `]$1[' function.]) $4],
1400       [$5])dnl
1401 AS_VAR_POPDEF([fp_func])dnl
1402 ])# FP_CHECK_FUNC
1403
1404 # FP_PROG_GHC_PKG
1405 # ----------------
1406 # Try to find a ghc-pkg matching the ghc mentioned in the environment variable
1407 # WithGhc. Sets the output variable GhcPkgCmd.
1408 AC_DEFUN([FP_PROG_GHC_PKG],
1409 [AC_CACHE_CHECK([for ghc-pkg matching $WithGhc], fp_cv_matching_ghc_pkg,
1410 [
1411 # If we are told to use ghc-stage2, then we're using an in-tree
1412 # compiler. In this case, we just want ghc-pkg, not ghc-pkg-stage2,
1413 # so we sed off -stage[0-9]$. However, if we are told to use
1414 # ghc-6.12.1 then we want to use ghc-pkg-6.12.1, so we keep any
1415 # other suffix.
1416 fp_ghc_pkg_guess=`echo "$WithGhc" | sed -e 's/-stage@<:@0-9@:>@$//' -e 's,ghc\(@<:@^/\\@:>@*\)$,ghc-pkg\1,'`
1417 if "$fp_ghc_pkg_guess" list > /dev/null 2>&1; then
1418   fp_cv_matching_ghc_pkg=$fp_ghc_pkg_guess
1419 else
1420   AC_MSG_ERROR([Cannot find matching ghc-pkg])
1421 fi])
1422 GhcPkgCmd=$fp_cv_matching_ghc_pkg
1423 AC_SUBST([GhcPkgCmd])
1424 ])# FP_PROG_GHC_PKG
1425
1426
1427 # FP_GCC_EXTRA_FLAGS
1428 # ------------------
1429 # Determine which extra flags we need to pass gcc when we invoke it
1430 # to compile .hc code.
1431 #
1432 # -fwrapv is needed for gcc to emit well-behaved code in the presence of
1433 # integer wrap around. (Trac #952)
1434 #
1435 AC_DEFUN([FP_GCC_EXTRA_FLAGS],
1436 [AC_REQUIRE([FP_GCC_VERSION])
1437 AC_CACHE_CHECK([for extra options to pass gcc when compiling via C], [fp_cv_gcc_extra_opts],
1438 [fp_cv_gcc_extra_opts=
1439  FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-ge], [3.4],
1440   [fp_cv_gcc_extra_opts="$fp_cv_gcc_extra_opts -fwrapv"],
1441   [])
1442  FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-ge], [4.0],
1443   [fp_cv_gcc_extra_opts="$fp_cv_gcc_extra_opts -fno-builtin"],
1444   [])
1445 ])
1446 AC_SUBST([GccExtraViaCOpts],$fp_cv_gcc_extra_opts)
1447 ])
1448
1449
1450 # FP_SETUP_PROJECT_VERSION
1451 # ---------------------
1452 AC_DEFUN([FP_SETUP_PROJECT_VERSION],
1453 [
1454 if test "$RELEASE" = "NO"; then
1455     AC_MSG_CHECKING([for GHC version date])
1456     if test -f VERSION_DATE; then
1457         PACKAGE_VERSION=${PACKAGE_VERSION}.`cat VERSION_DATE`
1458         AC_MSG_RESULT(given $PACKAGE_VERSION)
1459     elif test -d .git; then
1460         changequote(, )dnl
1461         ver_date=`git log -n 1 --date=short --pretty=format:%ci | cut -d ' ' -f 1 | tr -d -`
1462         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
1463         changequote([, ])dnl
1464                 AC_MSG_ERROR([failed to detect version date: check that git is in your path])
1465         fi
1466         PACKAGE_VERSION=${PACKAGE_VERSION}.$ver_date
1467         AC_MSG_RESULT(inferred $PACKAGE_VERSION)
1468     elif test -f VERSION; then
1469         PACKAGE_VERSION=`cat VERSION`
1470         AC_MSG_RESULT(given $PACKAGE_VERSION)
1471     else
1472         AC_MSG_WARN([cannot determine snapshot version: no .git directory and no VERSION file])
1473         dnl We'd really rather this case didn't happen, but it might
1474         dnl do (in particular, people using lndir trees may find that
1475         dnl the build system can't find any other date). If it does
1476         dnl happen, then we use the current date.
1477         dnl This way we get some idea about how recent a build is.
1478         dnl It also means that packages built for 2 different builds
1479         dnl will probably use different version numbers, so things are
1480         dnl less likely to go wrong.
1481         PACKAGE_VERSION=${PACKAGE_VERSION}.`date +%Y%m%d`
1482     fi
1483 fi
1484
1485     AC_MSG_CHECKING([for GHC Git commit id])
1486     if test -d .git; then
1487         git_commit_id=`git rev-parse HEAD`
1488         if test -n "$git_commit_id" 2>&1 >/dev/null; then true; else
1489             AC_MSG_ERROR([failed to detect revision: check that git is in your path])
1490         fi
1491         PACKAGE_GIT_COMMIT_ID=$git_commit_id
1492         AC_MSG_RESULT(inferred $PACKAGE_GIT_COMMIT_ID)
1493     elif test -f GIT_COMMIT_ID; then
1494         PACKAGE_GIT_COMMIT_ID=`cat GIT_COMMIT_ID`
1495         AC_MSG_RESULT(given $PACKAGE_GIT_COMMIT_ID)
1496     else
1497         AC_MSG_WARN([cannot determine snapshot revision: no .git directory and no 'GIT_COMMIT_ID' file])
1498         PACKAGE_GIT_COMMIT_ID="0000000000000000000000000000000000000000"
1499     fi
1500
1501
1502 # Some renamings
1503 AC_SUBST([ProjectName], [$PACKAGE_NAME])
1504 AC_SUBST([ProjectVersion], [$PACKAGE_VERSION])
1505 AC_SUBST([ProjectGitCommitId], [$PACKAGE_GIT_COMMIT_ID])
1506
1507 # Split PACKAGE_VERSION into (possibly empty) parts
1508 VERSION_MAJOR=`echo $PACKAGE_VERSION | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\1'/`
1509 VERSION_TMP=`echo $PACKAGE_VERSION | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\3'/`
1510 VERSION_MINOR=`echo $VERSION_TMP | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\1'/`
1511 ProjectPatchLevel=`echo $VERSION_TMP | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\3'/`
1512
1513 # Calculate project version as an integer, using 2 digits for minor version
1514 case $VERSION_MINOR in
1515   ?) ProjectVersionInt=${VERSION_MAJOR}0${VERSION_MINOR} ;;
1516   ??) ProjectVersionInt=${VERSION_MAJOR}${VERSION_MINOR} ;;
1517   *) AC_MSG_ERROR([bad minor version in $PACKAGE_VERSION]) ;;
1518 esac
1519 AC_SUBST([ProjectVersionInt])
1520
1521 # The project patchlevel is zero unless stated otherwise
1522 test -z "$ProjectPatchLevel" && ProjectPatchLevel=0
1523
1524 # Save split version of ProjectPatchLevel
1525 ProjectPatchLevel1=`echo $ProjectPatchLevel | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\1/'`
1526 ProjectPatchLevel2=`echo $ProjectPatchLevel | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\3/'`
1527
1528 AC_SUBST([ProjectPatchLevel1])
1529 AC_SUBST([ProjectPatchLevel2])
1530
1531 # Remove dots from the patch level; this allows us to have versions like 6.4.1.20050508
1532 ProjectPatchLevel=`echo $ProjectPatchLevel | sed 's/\.//'`
1533
1534 AC_SUBST([ProjectPatchLevel])
1535 ])# FP_SETUP_PROJECT_VERSION
1536
1537
1538 # Check for a working timer_create().  We need a pretty detailed check
1539 # here, because there exist partially-working implementations of
1540 # timer_create() in certain versions of Linux (see bug #1933).
1541 #
1542 AC_DEFUN([FP_CHECK_TIMER_CREATE],[
1543 AC_CHECK_FUNC([timer_create],[HAVE_timer_create=yes],[HAVE_timer_create=no])
1544
1545 if test "$HAVE_timer_create" = "yes"
1546 then
1547   if test "$cross_compiling" = "yes"
1548   then
1549     # We can't test timer_create when we're cross-compiling, so we
1550     # optimistiaclly assume that it actually works properly.
1551     AC_DEFINE([USE_TIMER_CREATE], 1,  [Define to 1 if we can use timer_create(CLOCK_REALTIME,...)])
1552   else
1553   AC_CACHE_CHECK([for a working timer_create(CLOCK_REALTIME)],
1554     [fptools_cv_timer_create_works],
1555     [AC_TRY_RUN([
1556 #include <stdio.h>
1557 #ifdef HAVE_STDLIB_H
1558 #include <stdlib.h>
1559 #endif
1560 #ifdef HAVE_TIME_H
1561 #include <time.h>
1562 #endif
1563 #ifdef HAVE_SIGNAL_H
1564 #include <signal.h>
1565 #endif
1566 #ifdef HAVE_UNISTD_H
1567 #include <unistd.h>
1568 #endif
1569
1570 static volatile int tock = 0;
1571 static void handler(int i)
1572 {
1573    tock = 1;
1574 }
1575
1576 static void timeout(int i)
1577 {
1578   // timer_settime() has been known to hang, so just in case
1579   // we install a 1-second timeout (see #2257)
1580   exit(99);
1581 }
1582
1583 int main(int argc, char *argv[])
1584 {
1585
1586     struct sigevent ev;
1587     timer_t timer;
1588     struct itimerspec it;
1589     struct sigaction action;
1590     int m,n,count = 0;
1591
1592     ev.sigev_notify = SIGEV_SIGNAL;
1593     ev.sigev_signo  = SIGVTALRM;
1594
1595     action.sa_handler = handler;
1596     action.sa_flags = 0;
1597     sigemptyset(&action.sa_mask);
1598     if (sigaction(SIGVTALRM, &action, NULL) == -1) {
1599         fprintf(stderr,"SIGVTALRM problem\n");
1600         exit(3);
1601     }
1602
1603     action.sa_handler = timeout;
1604     action.sa_flags = 0;
1605     sigemptyset(&action.sa_mask);
1606     if (sigaction(SIGALRM, &action, NULL) == -1) {
1607       fprintf(stderr,"SIGALRM problem\n");
1608       exit(3);
1609     }
1610     alarm(1);
1611
1612     if (timer_create(CLOCK_REALTIME, &ev, &timer) != 0) {
1613         fprintf(stderr,"No CLOCK_REALTIME timer\n");
1614         exit(2);
1615     }
1616
1617     tock = 0;
1618
1619     it.it_value.tv_sec = 0;
1620     it.it_value.tv_nsec = 1000000; // 1ms
1621     it.it_interval = it.it_value;
1622     if (timer_settime(timer, 0, &it, NULL) != 0) {
1623         fprintf(stderr,"settime problem\n");
1624         exit(4);
1625     }
1626
1627     // some environments have coarse scheduler/timer granularity of ~10ms and worse
1628     usleep(100000); // 100ms
1629
1630     if (!tock) {
1631         fprintf(stderr,"no CLOCK_REALTIME signal\n");
1632         exit(5);
1633     }
1634
1635     timer_delete(timer);
1636
1637     exit(0);
1638 }
1639      ],
1640      [fptools_cv_timer_create_works=yes],
1641      [fptools_cv_timer_create_works=no])
1642   ])
1643 case $fptools_cv_timer_create_works in
1644     yes) AC_DEFINE([USE_TIMER_CREATE], 1,
1645                    [Define to 1 if we can use timer_create(CLOCK_REALTIME,...)]);;
1646 esac
1647   fi
1648 fi
1649 ])
1650
1651 # FP_ICONV
1652 # -------------
1653 AC_DEFUN([FP_ICONV],
1654 [
1655   dnl--------------------------------------------------------------------
1656   dnl * Deal with arguments telling us iconv is somewhere odd
1657   dnl--------------------------------------------------------------------
1658
1659   dnl Note: ICONV_LIB_DIRS and ICONV_INCLUDE_DIRS are not predefined
1660   dnl to the empty string to allow them to be overridden from the
1661   dnl environment.
1662
1663   AC_ARG_WITH([iconv-includes],
1664     [AC_HELP_STRING([--with-iconv-includes],
1665       [directory containing iconv.h])],
1666       [ICONV_INCLUDE_DIRS=$withval])
1667
1668   AC_ARG_WITH([iconv-libraries],
1669     [AC_HELP_STRING([--with-iconv-libraries],
1670       [directory containing iconv library])],
1671       [ICONV_LIB_DIRS=$withval])
1672
1673   AC_SUBST(ICONV_INCLUDE_DIRS)
1674   AC_SUBST(ICONV_LIB_DIRS)
1675 ])# FP_ICONV
1676
1677 # FP_GMP
1678 # -------------
1679 AC_DEFUN([FP_GMP],
1680 [
1681   dnl--------------------------------------------------------------------
1682   dnl * Deal with arguments telling us gmp is somewhere odd
1683   dnl--------------------------------------------------------------------
1684
1685   AC_ARG_WITH([gmp-includes],
1686     [AC_HELP_STRING([--with-gmp-includes],
1687       [directory containing gmp.h])],
1688       [GMP_INCLUDE_DIRS=$withval])
1689
1690   AC_ARG_WITH([gmp-libraries],
1691     [AC_HELP_STRING([--with-gmp-libraries],
1692       [directory containing gmp library])],
1693       [GMP_LIB_DIRS=$withval])
1694
1695   AC_SUBST(GMP_INCLUDE_DIRS)
1696   AC_SUBST(GMP_LIB_DIRS)
1697 ])# FP_GMP
1698
1699 # FP_CURSES
1700 # -------------
1701 AC_DEFUN([FP_CURSES],
1702 [
1703   dnl--------------------------------------------------------------------
1704   dnl * Deal with arguments telling us curses is somewhere odd
1705   dnl--------------------------------------------------------------------
1706
1707   AC_ARG_WITH([curses-includes],
1708     [AC_HELP_STRING([--with-curses-includes],
1709       [directory containing curses headers])],
1710       [CURSES_INCLUDE_DIRS=$withval])
1711
1712   AC_ARG_WITH([curses-libraries],
1713     [AC_HELP_STRING([--with-curses-libraries],
1714       [directory containing curses libraries])],
1715       [CURSES_LIB_DIRS=$withval])
1716
1717   AC_SUBST(CURSES_INCLUDE_DIRS)
1718   AC_SUBST(CURSES_LIB_DIRS)
1719 ])# FP_CURSES
1720
1721 # --------------------------------------------------------------
1722 # Calculate absolute path to build tree
1723 # --------------------------------------------------------------
1724
1725 AC_DEFUN([FP_INTREE_GHC_PWD],[
1726 AC_MSG_NOTICE(Building in-tree ghc-pwd)
1727     dnl This would be
1728     dnl     make -C utils/ghc-pwd clean && make -C utils/ghc-pwd
1729     dnl except we don't want to have to know what make is called. Sigh.
1730     rm -rf utils/ghc-pwd/dist-boot
1731     mkdir  utils/ghc-pwd/dist-boot
1732     dnl If special linker flags are needed to build things, then allow
1733     dnl the user to pass them in via LDFLAGS.
1734     changequote(, )dnl
1735     GHC_LDFLAGS=`perl -e 'foreach (@ARGV) { print "-optl$_ " }' -- $LDFLAGS`
1736     changequote([, ])dnl
1737     if ! "$WithGhc" $GHC_LDFLAGS -v0 -no-user-$GHC_PACKAGE_DB_FLAG -hidir utils/ghc-pwd/dist-boot -odir utils/ghc-pwd/dist-boot -stubdir utils/ghc-pwd/dist-boot --make utils/ghc-pwd/Main.hs -o utils/ghc-pwd/dist-boot/ghc-pwd
1738     then
1739         AC_MSG_ERROR([Building ghc-pwd failed])
1740     fi
1741
1742     GHC_PWD=utils/ghc-pwd/dist-boot/ghc-pwd
1743 ])
1744
1745 AC_DEFUN([FP_BINDIST_GHC_PWD],[
1746     GHC_PWD=utils/ghc-pwd/dist-install/build/tmp/ghc-pwd-bindist
1747 ])
1748
1749 AC_DEFUN([FP_FIND_ROOT],[
1750 AC_MSG_CHECKING(for path to top of build tree)
1751     hardtop=`$GHC_PWD`
1752
1753     dnl Remove common automounter nonsense
1754     hardtop=`echo $hardtop | sed 's|^/tmp_mnt.*\(/local/.*\)$|\1|' | sed 's|^/tmp_mnt/|/|'`
1755
1756     if ! test -d "$hardtop"; then
1757         AC_MSG_ERROR([cannot determine current directory])
1758     fi
1759
1760     dnl We don't support building in directories with spaces.
1761     case "$hardtop" in
1762     *' '*)
1763         AC_MSG_ERROR([
1764         The build system does not support building in a directory
1765         containing space characters.
1766         Suggestion: move the build tree somewhere else.])
1767         ;;
1768     esac
1769
1770     AC_SUBST(hardtop)
1771
1772     AC_MSG_RESULT($hardtop)
1773 ])
1774
1775 # GHC_CONVERT_CPU(cpu, target_var)
1776 # --------------------------------
1777 # converts cpu from gnu to ghc naming, and assigns the result to $target_var
1778 AC_DEFUN([GHC_CONVERT_CPU],[
1779 case "$1" in
1780   aarch64*)
1781     $2="aarch64"
1782     ;;
1783   alpha*)
1784     $2="alpha"
1785     ;;
1786   arm*)
1787     $2="arm"
1788     ;;
1789   hppa1.1*)
1790     $2="hppa1_1"
1791     ;;
1792   hppa*)
1793     $2="hppa"
1794     ;;
1795   i386|i486|i586|i686)
1796     $2="i386"
1797     ;;
1798   ia64)
1799     $2="ia64"
1800     ;;
1801   m68k*)
1802     $2="m68k"
1803     ;;
1804   mipseb*)
1805     $2="mipseb"
1806     ;;
1807   mipsel*)
1808     $2="mipsel"
1809     ;;
1810   mips*)
1811     $2="mips"
1812     ;;
1813   powerpc64le*)
1814     $2="powerpc64le"
1815     ;;
1816   powerpc64*)
1817     $2="powerpc64"
1818     ;;
1819   powerpc*)
1820     $2="powerpc"
1821     ;;
1822   rs6000)
1823     $2="rs6000"
1824     ;;
1825   s390x*)
1826     $2="s390x"
1827     ;;
1828   s390*)
1829     $2="s390"
1830     ;;
1831   sh4)
1832     $2="sh4"
1833     ;;
1834   sparc64*)
1835     $2="sparc64"
1836     ;;
1837   sparc*)
1838     $2="sparc"
1839     ;;
1840   vax)
1841     $2="vax"
1842     ;;
1843   x86_64|amd64)
1844     $2="x86_64"
1845     ;;
1846   *)
1847     echo "Unknown CPU $1"
1848     exit 1
1849     ;;
1850   esac
1851 ])
1852
1853 # GHC_CONVERT_VENDOR(vendor, target_var)
1854 # --------------------------------
1855 # converts vendor from gnu to ghc naming, and assigns the result to $target_var
1856 AC_DEFUN([GHC_CONVERT_VENDOR],[
1857   case "$1" in
1858   pc|gentoo|w64) # like i686-pc-linux-gnu, i686-gentoo-freebsd8, x86_64-w64-mingw32
1859     $2="unknown"
1860     ;;
1861   softfloat) # like armv5tel-softfloat-linux-gnueabi
1862     $2="unknown"
1863     ;;
1864   hardfloat) # like armv7a-hardfloat-linux-gnueabi
1865     $2="unknown"
1866     ;;
1867   *)
1868     #pass thru by default
1869     $2="$1"
1870     ;;
1871   esac
1872 ])
1873
1874 # GHC_CONVERT_OS(os, converted_cpu, target_var)
1875 # --------------------------------
1876 # converts os from gnu to ghc naming, and assigns the result to $target_var
1877 AC_DEFUN([GHC_CONVERT_OS],[
1878 case "$1-$2" in
1879   darwin10-arm|darwin11-i386|darwin14-aarch64)
1880     $3="ios"
1881     ;;
1882   *)
1883     case "$1" in
1884       linux-android*)
1885         $3="linux-android"
1886         ;;
1887       linux-*|linux)
1888         $3="linux"
1889         ;;
1890       # As far as I'm aware, none of these have relevant variants
1891       freebsd|netbsd|openbsd|dragonfly|osf1|osf3|hpux|linuxaout|kfreebsdgnu|freebsd2|solaris2|mingw32|darwin|gnu|nextstep2|nextstep3|sunos4|ultrix|irix|haiku)
1892         $3="$1"
1893         ;;
1894       aix*) # e.g. powerpc-ibm-aix7.1.3.0
1895         $3="aix"
1896         ;;
1897       freebsd*) # like i686-gentoo-freebsd7
1898                 #      i686-gentoo-freebsd8
1899                 #      i686-gentoo-freebsd8.2
1900         $3="freebsd"
1901         ;;
1902       nto-qnx*)
1903         $3="nto-qnx"
1904         ;;
1905       *)
1906         echo "Unknown OS $1"
1907         exit 1
1908         ;;
1909       esac
1910       ;;
1911   esac
1912 ])
1913
1914 # BOOTSTRAPPING_GHC_INFO_FIELD
1915 # --------------------------------
1916 # Set the variable $1 to the value of the ghc --info field $2.
1917 AC_DEFUN([BOOTSTRAPPING_GHC_INFO_FIELD],[
1918 $1=`"$WithGhc" --info | grep "^ ,(\"$2\"," | sed -e 's/.*","//' -e 's/")$//'`
1919 tmp=${$1#\$topdir/}
1920 if test "${$1}" != "$tmp"
1921 then
1922     topdir=`"$WithGhc" --print-libdir | sed 's#\\\\#/#g'`
1923     $1="$topdir/$tmp"
1924 fi
1925 AC_SUBST($1)
1926 ])
1927
1928 # LIBRARY_VERSION(lib, [dir])
1929 # --------------------------------
1930 # Gets the version number of a library.
1931 # If $1 is ghc-prim, then we define LIBRARY_ghc_prim_VERSION as 1.2.3
1932 # $2 points to the directory under libraries/
1933 AC_DEFUN([LIBRARY_VERSION],[
1934 dir=m4_default([$2],[$1])
1935 LIBRARY_[]translit([$1], [-], [_])[]_VERSION=`grep -i "^version:" libraries/${dir}/$1.cabal | sed "s/.* //"`
1936 AC_SUBST(LIBRARY_[]translit([$1], [-], [_])[]_VERSION)
1937 ])
1938
1939 # XCODE_VERSION()
1940 # --------------------------------
1941 # Gets the version number of XCode, if on a Mac
1942 AC_DEFUN([XCODE_VERSION],[
1943     if test "$TargetOS_CPP" = "darwin"
1944     then
1945         AC_MSG_CHECKING(XCode version)
1946         XCodeVersion=`xcodebuild -version | grep Xcode | sed "s/Xcode //"`
1947         # Old XCode versions don't actually give the XCode version
1948         if test "$XCodeVersion" = ""
1949         then
1950             AC_MSG_RESULT(not found (too old?))
1951             XCodeVersion1=0
1952             XCodeVersion2=0
1953         else
1954             AC_MSG_RESULT($XCodeVersion)
1955             XCodeVersion1=`echo "$XCodeVersion" | sed 's/\..*//'`
1956             changequote(, )dnl
1957             XCodeVersion2=`echo "$XCodeVersion" | sed 's/[^.]*\.\([^.]*\).*/\1/'`
1958             changequote([, ])dnl
1959             AC_MSG_NOTICE(XCode version component 1: $XCodeVersion1)
1960             AC_MSG_NOTICE(XCode version component 2: $XCodeVersion2)
1961         fi
1962     fi
1963 ])
1964
1965 # FIND_LLVM_PROG()
1966 # --------------------------------
1967 # Find where the llvm tools are. We have a special function to handle when they
1968 # are installed with a version suffix (e.g., llc-3.1).
1969 #
1970 # $1 = the variable to set
1971 # $2 = the with option name
1972 # $3 = the command to look for
1973 # $4 = the version of the command to look for
1974 #
1975 AC_DEFUN([FIND_LLVM_PROG],[
1976     # Test for program with version name.
1977     FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL_NOTARGET([$1], [$2], [$3-$4])
1978     if test -z "$$1"; then
1979         # Test for program without version name.
1980         FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL_NOTARGET([$1], [$2], [$3])
1981         if test -n "$$1"; then
1982             AC_MSG_CHECKING([$$1 is version $4])
1983             if test `$$1 --version | grep -c "version $4"` -gt 0 ; then
1984                 AC_MSG_RESULT(yes)
1985             else
1986                 AC_MSG_RESULT(no)
1987                 $1=""
1988             fi
1989         fi
1990     fi
1991 ])
1992
1993 # FIND_LD
1994 # Find the version of `ld` to use. This is used in both in the top level
1995 # configure.ac and in distrib/configure.ac.in.
1996 #
1997 # $1 = the variable to set
1998 #
1999 AC_DEFUN([FIND_LD],[
2000     FP_ARG_WITH_PATH_GNU_PROG([LD], [ld], [ld])
2001     case $target in
2002         arm*linux*       | \
2003         aarch64*linux*   )
2004             # Arm and Aarch64 requires use of the binutils ld.gold linker.
2005             # This case should catch at least arm-unknown-linux-gnueabihf,
2006             # arm-linux-androideabi, arm64-unknown-linux and
2007             # aarch64-linux-android
2008             FP_ARG_WITH_PATH_GNU_PROG([LD_GOLD], [ld.gold], [ld.gold])
2009             $1="$LD_GOLD"
2010             ;;
2011         *)
2012             $1="$LD"
2013             ;;
2014     esac
2015 ])
2016
2017 # FIND_GHC_BOOTSTRAP_PROG()
2018 # --------------------------------
2019 # Parse the bootstrap GHC's compier settings file for the location of things
2020 # like the `llc` and `opt` commands.
2021 #
2022 # $1 = the variable to set
2023 # $2 = The bootstrap compiler.
2024 # $3 = The string to grep for to find the correct line.
2025 #
2026 AC_DEFUN([FIND_GHC_BOOTSTRAP_PROG],[
2027     BootstrapTmpCmd=`grep $3 $($2 --print-libdir)/settings 2>/dev/null | sed 's/.*", "//;s/".*//'`
2028     if test -n "$BootstrapTmpCmd" && test `basename $BootstrapTmpCmd` = $BootstrapTmpCmd ; then
2029         AC_PATH_PROG([$1], [$BootstrapTmpCmd], "")
2030     else
2031         $1=$BootstrapTmpCmd
2032     fi
2033 ])
2034
2035
2036 # FIND_GCC()
2037 # --------------------------------
2038 # Finds where gcc is
2039 #
2040 # $1 = the variable to set
2041 # $2 = the with option name
2042 # $3 = the command to look for
2043 AC_DEFUN([FIND_GCC],[
2044     if test "$TargetOS_CPP" = "darwin" &&
2045        test "$XCodeVersion1" -eq 4 &&
2046        test "$XCodeVersion2" -lt 2
2047     then
2048         # In Xcode 4.1, 'gcc-4.2' is the gcc legacy backend (rather
2049         # than the LLVM backend). We prefer the legacy gcc, but in
2050         # Xcode 4.2 'gcc-4.2' was removed.
2051         FP_ARG_WITH_PATH_GNU_PROG([$1], [gcc-4.2], [gcc-4.2])
2052     elif test "$windows" = YES
2053     then
2054         $1="$CC"
2055     else
2056         FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL([$1], [$2], [$3])
2057         # From Xcode 5 on/, OS X command line tools do not include gcc
2058         # anymore. Use clang.
2059         if test -z "$$1"
2060         then
2061             FP_ARG_WITH_PATH_GNU_PROG_OPTIONAL([$1], [clang], [clang])
2062         fi
2063         if test -z "$$1"
2064         then
2065             AC_MSG_ERROR([cannot find $3 nor clang in your PATH])
2066         fi
2067     fi
2068     AC_SUBST($1)
2069 ])
2070
2071 AC_DEFUN([MAYBE_OVERRIDE_STAGE0],[
2072   if test ! -z "$With_$1" -a "$CrossCompiling" != "YES"; then
2073       AC_MSG_NOTICE([Not cross-compiling, so --with-$1 also sets $2])
2074       $2=$With_$1
2075   fi
2076 ])
2077
2078
2079 # FP_CPP_CMD_WITH_ARGS()
2080 # ----------------------
2081 # sets CPP command and its arguments
2082 #
2083 # $1 = the variable to set to CPP command
2084 # $2 = the varibale to set to CPP command arguments
2085
2086 AC_DEFUN([FP_CPP_CMD_WITH_ARGS],[
2087 dnl ** what cpp to use?
2088 dnl --------------------------------------------------------------
2089 AC_ARG_WITH(hs-cpp,
2090 [AC_HELP_STRING([--with-hs-cpp=ARG],
2091       [Path to the (C) preprocessor for Haskell files [default=autodetect]])],
2092 [
2093     if test "$HostOS" = "mingw32"
2094     then
2095         AC_MSG_WARN([Request to use $withval will be ignored])
2096     else
2097         HS_CPP_CMD=$withval
2098     fi
2099 ],
2100 [
2101
2102     # We can't use $CPP here, since HS_CPP_CMD is expected to be a single
2103     # command (no flags), and AC_PROG_CPP defines CPP as "/usr/bin/gcc -E".
2104     HS_CPP_CMD=$WhatGccIsCalled
2105
2106     SOLARIS_GCC_CPP_BROKEN=NO
2107     SOLARIS_FOUND_GOOD_CPP=NO
2108     case $host in
2109         i386-*-solaris2)
2110         GCC_MAJOR_MINOR=`$WhatGccIsCalled --version|grep "gcc (GCC)"|cut -d ' ' -f 3-3|cut -d '.' -f 1-2`
2111         if test "$GCC_MAJOR_MINOR" != "3.4"; then
2112           # this is not 3.4.x release so with broken CPP
2113           SOLARIS_GCC_CPP_BROKEN=YES
2114         fi
2115         ;;
2116     esac
2117
2118     if test "$SOLARIS_GCC_CPP_BROKEN" = "YES"; then
2119       # let's try to find if GNU C 3.4.x is installed
2120       if test -x /usr/sfw/bin/gcc; then
2121         # something executable is in expected path so let's
2122         # see if it's really GNU C
2123         NEW_GCC_MAJOR_MINOR=`/usr/sfw/bin/gcc --version|grep "gcc (GCC)"|cut -d ' ' -f 3-3|cut -d '.' -f 1-2`
2124         if test "$NEW_GCC_MAJOR_MINOR" = "3.4"; then
2125           # this is GNU C 3.4.x which provides non-broken CPP on Solaris
2126           # let's use it as CPP then.
2127           HS_CPP_CMD=/usr/sfw/bin/gcc
2128           SOLARIS_FOUND_GOOD_CPP=YES
2129         fi
2130       fi
2131       if test "$SOLARIS_FOUND_GOOD_CPP" = "NO"; then
2132         AC_MSG_WARN([Your GNU C provides broken CPP and you do not have GNU C 3.4.x installed.])
2133         AC_MSG_WARN([Please install GNU C 3.4.x to solve this issue. It will be used as CPP only.])
2134       fi
2135     fi
2136 ]
2137 )
2138
2139
2140
2141 dnl ** what cpp flags to use?
2142 dnl -----------------------------------------------------------
2143 AC_ARG_WITH(hs-cpp-flags,
2144   [AC_HELP_STRING([--with-hs-cpp-flags=ARG],
2145       [Flags to the (C) preprocessor for Haskell files [default=autodetect]])],
2146   [
2147       if test "$HostOS" = "mingw32"
2148       then
2149           AC_MSG_WARN([Request to use $withval will be ignored])
2150       else
2151           HS_CPP_ARGS=$withval
2152       fi
2153   ],
2154 [
2155   $HS_CPP_CMD -x c /dev/null -dM -E > conftest.txt 2>&1
2156   if grep "__clang__" conftest.txt >/dev/null 2>&1; then
2157     HS_CPP_ARGS="-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs"
2158   else
2159       $HS_CPP_CMD  -v > conftest.txt 2>&1
2160       if  grep "gcc" conftest.txt >/dev/null 2>&1; then
2161           HS_CPP_ARGS="-E -undef -traditional"
2162         else
2163           $HS_CPP_CMD  --version > conftest.txt 2>&1
2164           if grep "cpphs" conftest.txt >/dev/null 2>&1; then
2165             HS_CPP_ARGS="--cpp -traditional"
2166           else
2167             AC_MSG_WARN([configure can't recognize your CPP program, you may need to set --with-hs-cpp-flags=FLAGS explicitly])
2168             HS_CPP_ARGS=""
2169           fi
2170       fi
2171   fi
2172   ]
2173 )
2174
2175 $1=$HS_CPP_CMD
2176 $2=$HS_CPP_ARGS
2177
2178 ])
2179
2180 # FP_BFD_SUPPORT()
2181 # ----------------------
2182 # whether to use libbfd for debugging RTS
2183 AC_DEFUN([FP_BFD_SUPPORT], [
2184     AC_ARG_ENABLE(bfd-debug,
2185         [AC_HELP_STRING([--enable-bfd-debug],
2186               [Enable symbol resolution for -debug rts ('+RTS -Di') via binutils' libbfd [default=no]])],
2187         [
2188             # don't pollute general LIBS environment
2189             save_LIBS="$LIBS"
2190             AC_CHECK_HEADERS([bfd.h])
2191             dnl ** check whether this machine has BFD and libiberty installed (used for debugging)
2192             dnl    the order of these tests matters: bfd needs libiberty
2193             AC_CHECK_LIB(iberty, xmalloc)
2194             dnl 'bfd_init' is a rare non-macro in libbfd
2195             AC_CHECK_LIB(bfd,    bfd_init)
2196
2197             AC_TRY_LINK([#include <bfd.h>],
2198                         [
2199                                 /* mimic our rts/Printer.c */
2200                                 bfd* abfd;
2201                                 const char * name;
2202                                 char **matching;
2203
2204                                 name = "some.executable";
2205                                 bfd_init();
2206                                 abfd = bfd_openr(name, "default");
2207                                 bfd_check_format_matches (abfd, bfd_object, &matching);
2208                                 {
2209                                     long storage_needed;
2210                                     storage_needed = bfd_get_symtab_upper_bound (abfd);
2211                                 }
2212                                 {
2213                                     asymbol **symbol_table;
2214                                     long number_of_symbols;
2215                                     symbol_info info;
2216
2217                                     number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
2218                                     bfd_get_symbol_info(abfd,symbol_table[0],&info);
2219                                 }
2220                         ],
2221                         [],dnl bfd seems to work
2222                         [AC_MSG_ERROR([can't use 'bfd' library])])
2223             LIBS="$save_LIBS"
2224         ]
2225     )
2226 ])
2227
2228 # LocalWords:  fi