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