m4trace:m4/ax_compare_version.m4:85: -1- AC_DEFUN([AX_COMPARE_VERSION], [
  AC_REQUIRE([AC_PROG_AWK])

  # Used to indicate true or false condition
  ax_compare_version=false

  # Convert the two version strings to be compared into a format that
  # allows a simple string comparison.  The end result is that a version
  # string of the form 1.12.5-r617 will be converted to the form
  # 0001001200050617.  In other words, each number is zero padded to four
  # digits, and non digits are removed.
  AS_VAR_PUSHDEF([A],[ax_compare_version_A])
  A=`echo "$1" | sed -e 's/\([[0-9]]*\)/Z\1Z/g' \
                     -e 's/Z\([[0-9]]\)Z/Z0\1Z/g' \
                     -e 's/Z\([[0-9]][[0-9]]\)Z/Z0\1Z/g' \
                     -e 's/Z\([[0-9]][[0-9]][[0-9]]\)Z/Z0\1Z/g' \
                     -e 's/[[^0-9]]//g'`

  AS_VAR_PUSHDEF([B],[ax_compare_version_B])
  B=`echo "$3" | sed -e 's/\([[0-9]]*\)/Z\1Z/g' \
                     -e 's/Z\([[0-9]]\)Z/Z0\1Z/g' \
                     -e 's/Z\([[0-9]][[0-9]]\)Z/Z0\1Z/g' \
                     -e 's/Z\([[0-9]][[0-9]][[0-9]]\)Z/Z0\1Z/g' \
                     -e 's/[[^0-9]]//g'`

  dnl # In the case of le, ge, lt, and gt, the strings are sorted as necessary
  dnl # then the first line is used to determine if the condition is true.
  dnl # The sed right after the echo is to remove any indented white space.
  m4_case(m4_tolower($2),
  [lt],[
    ax_compare_version=`echo "x$A
x$B" | sed 's/^ *//' | sort -r | sed "s/x${A}/false/;s/x${B}/true/;1q"`
  ],
  [gt],[
    ax_compare_version=`echo "x$A
x$B" | sed 's/^ *//' | sort | sed "s/x${A}/false/;s/x${B}/true/;1q"`
  ],
  [le],[
    ax_compare_version=`echo "x$A
x$B" | sed 's/^ *//' | sort | sed "s/x${A}/true/;s/x${B}/false/;1q"`
  ],
  [ge],[
    ax_compare_version=`echo "x$A
x$B" | sed 's/^ *//' | sort -r | sed "s/x${A}/true/;s/x${B}/false/;1q"`
  ],[
    dnl Split the operator from the subversion count if present.
    m4_bmatch(m4_substr($2,2),
    [0],[
      # A count of zero means use the length of the shorter version.
      # Determine the number of characters in A and B.
      ax_compare_version_len_A=`echo "$A" | $AWK '{print(length)}'`
      ax_compare_version_len_B=`echo "$B" | $AWK '{print(length)}'`

      # Set A to no more than B's length and B to no more than A's length.
      A=`echo "$A" | sed "s/\(.\{$ax_compare_version_len_B\}\).*/\1/"`
      B=`echo "$B" | sed "s/\(.\{$ax_compare_version_len_A\}\).*/\1/"`
    ],
    [[0-9]+],[
      # A count greater than zero means use only that many subversions
      A=`echo "$A" | sed "s/\(\([[0-9]]\{4\}\)\{m4_substr($2,2)\}\).*/\1/"`
      B=`echo "$B" | sed "s/\(\([[0-9]]\{4\}\)\{m4_substr($2,2)\}\).*/\1/"`
    ],
    [.+],[
      AC_WARNING(
        [invalid OP numeric parameter: $2])
    ],[])

    # Pad zeros at end of numbers to make same length.
    ax_compare_version_tmp_A="$A`echo $B | sed 's/./0/g'`"
    B="$B`echo $A | sed 's/./0/g'`"
    A="$ax_compare_version_tmp_A"

    # Check for equality or inequality as necessary.
    m4_case(m4_tolower(m4_substr($2,0,2)),
    [eq],[
      test "x$A" = "x$B" && ax_compare_version=true
    ],
    [ne],[
      test "x$A" != "x$B" && ax_compare_version=true
    ],[
      AC_WARNING([invalid OP parameter: $2])
    ])
  ])

  AS_VAR_POPDEF([A])dnl
  AS_VAR_POPDEF([B])dnl

  dnl # Execute ACTION-IF-TRUE / ACTION-IF-FALSE.
  if test "$ax_compare_version" = "true" ; then
    m4_ifvaln([$4],[$4],[:])dnl
    m4_ifvaln([$5],[else $5])dnl
  fi
])
m4trace:m4/bootstrapping_ghc_info_field.m4:4: -1- AC_DEFUN([BOOTSTRAPPING_GHC_INFO_FIELD], [
$1=`"$WithGhc" --info | grep "^ ,(\"$2\"," | sed -e 's/.*","//' -e 's/")$//'`
tmp=${$1#\$topdir/}
if test "${$1}" != "$tmp"
then
    topdir=`"$WithGhc" --print-libdir | sed 's#\\\\#/#g'`
    $1="$topdir/$tmp"
fi
AC_SUBST($1)
])
m4trace:m4/check_for_gold_t22266.m4:11: -1- AC_DEFUN([CHECK_FOR_GOLD_T22266], [
    AC_MSG_CHECKING([for ld.gold object merging bug (binutils 22266)])
    if ! $1 --version | grep -q "GNU gold" 2>/dev/null; then
        # Not gold
        result=0
    elif test "$cross_compiling" = "yes"; then
        AC_MSG_RESULT([cross-compiling, assuming LD can merge objects correctly.])
        result=0
    else
        FPTOOLS_WRITE_FILE([conftest.a.c], [
          __attribute__((section(".data.a")))
          static int int_from_a_1 = 0x11223344;

          __attribute__((section(".data.rel.ro.a")))
          int *p_int_from_a_2 = &int_from_a_1;

          const char *hello (void);

          const char *
          hello (void)
          {
            return "XXXHello, world!" + 3;
          }
        ])

        FPTOOLS_WRITE_FILE([conftest.main.c], [
          #include <stdlib.h>
          #include <string.h>

          extern int *p_int_from_a_2;
          extern const char *hello (void);

          int main (void) {
            if (*p_int_from_a_2 != 0x11223344)
              abort ();
            if (strcmp(hello(), "Hello, world!") != 0)
              abort ();
            return 0;
          }
        ])

        FPTOOLS_WRITE_FILE([conftest.t], [
          SECTIONS
          {
              .text : {
                  *(.text*)
              }
              .rodata :
              {
                  *(.rodata .rodata.* .gnu.linkonce.r.*)
              }
              .data.rel.ro : {
                  *(.data.rel.ro*)
              }
              .data : {
                  *(.data*)
              }
              .bss : {
                  *(.bss*)
              }
          }
        ])

        $CC -c -o conftest.a.o conftest.a.c || AC_MSG_ERROR([Failed to compile test])
        $MergeObjsCmd $MergeObjsArgs -T conftest.t conftest.a.o -o conftest.ar.o || AC_MSG_ERROR([Failed to merge test object])

        $CC -c -o conftest.main.o conftest.main.c || AC_MSG_ERROR([Failed to compile test driver])
        $CC conftest.ar.o conftest.main.o -o conftest || AC_MSG_ERROR([Failed to link test driver])

        if ./conftest; then
            AC_MSG_RESULT([not affected])
            result=0
        else
            AC_MSG_RESULT([affected])
            result=1
        fi
        rm -f conftest.a.o conftest.a.c  conttest.ar.o conftest.main.c conftest.main.o conftest
    fi
])
m4trace:m4/check_ld_copy_bug.m4:9: -1- AC_DEFUN([CHECK_LD_COPY_BUG], [
    case $1 in
      arm*linux*)
        AC_CHECK_TARGET_TOOL([READELF], [readelf])
        AC_CHECK_TARGET_TOOL([AS], [as])
        AC_MSG_CHECKING([for ld bug 16177])
        cat >actest.s <<-EOF
          .globl _start
          .p2align 4
        _start:
          bkpt

        .data
          .globl data_object
        object_reference:
          .long data_object
          .size object_reference, 4
EOF

        cat >aclib.s <<-EOF
          .data
          .globl data_object
          .type data_object, %object
          .size data_object, 4
        data_object:
            .long 123
EOF

        $AS -o aclib.o aclib.s
        $LD -shared -o aclib.so aclib.o

        $AS -o actest.o actest.s
        $LD -o actest actest.o aclib.so

        if $READELF -r actest | grep R_ARM_COPY > /dev/null; then
            AC_MSG_RESULT([affected])
            AC_MSG_ERROR(
              [Your linker is affected by binutils #16177, which
               critically breaks linkage of GHC objects. Please either upgrade
               binutils or supply a different linker with the LD environment
               variable.])
        else
            AC_MSG_RESULT([unaffected])
        fi

        rm -f aclib.s aclib.o aclib.so actest.s actest.o actest
        ;;
      *)
        ;;
    esac
])
m4trace:m4/find_ld.m4:10: -1- AC_DEFUN([FIND_LD], [
    AC_ARG_ENABLE(ld-override,
      [AS_HELP_STRING([--disable-ld-override],
        [Prevent GHC from overriding the default linker used by gcc. If ld-override is enabled GHC will try to tell gcc to use whichever linker is selected by the LD environment variable. [default=override enabled]])],
      [],
      [enable_ld_override=yes])

    find_ld() {
        # Make sure the user didn't specify LD manually.
        if test "z$LD" != "z"; then
            AC_CHECK_TARGET_TOOL([LD], [ld])
            return
        fi

        # Manually iterate over possible names since we want to ensure that, e.g.,
        # if ld.lld is installed but gcc doesn't support -fuse-ld=lld, that we
        # then still try ld.gold and -fuse-ld=gold.
        for possible_ld in ld.lld ld.gold ld; do
            TmpLd="" # In case the user set LD
            AC_CHECK_TARGET_TOOL([TmpLd], [$possible_ld])
            if test "x$TmpLd" = "x"; then continue; fi

            out=`$TmpLd --version`
            case $out in
              "GNU ld"*)
                   FP_CC_LINKER_FLAG_TRY(bfd, $2) ;;
              "GNU gold"*)
                   FP_CC_LINKER_FLAG_TRY(gold, $2)
                   if test "$cross_compiling" = "yes"; then
                       AC_MSG_NOTICE([Using ld.gold and assuming that it is not affected by binutils issue 22266]);
                       AC_MSG_NOTICE([Using ld.gold and assuming that it is not affected by binutils issue 23856]);
                   else
                       FP_BINUTILS_T23856()
                   fi
                   ;;
              "LLD"*)
                   FP_CC_LINKER_FLAG_TRY(lld, $2) ;;
              *" LLD "*)
                   FP_CC_LINKER_FLAG_TRY(lld, $2) ;;
              *) AC_MSG_NOTICE([unknown linker version $out]) ;;
            esac
            if test "z$$2" = "z"; then
                AC_MSG_NOTICE([unable to convince '$CC' to use linker '$TmpLd'])
                # a terrible hack to prevent autoconf from caching the previous
                # AC_CHECK_TARGET_TOOL result since next time we'll be looking
                # for another ld variant.
                $as_unset ac_cv_prog_ac_ct_TmpLd
            else
                LD="$TmpLd"
                return
            fi
        done

        # Fallback
        AC_CHECK_TARGET_TOOL([LD], [ld])
    }

    if test "$ghc_host_os" = "darwin" ; then
        dnl N.B. Don't even try to find a more efficient linker on Darwin where
        dnl broken setups (e.g. unholy mixtures of Homebrew and the native
        dnl toolchain) are far too easy to come across.
        dnl
        dnl See #21712.
        AC_CHECK_TARGET_TOOL([LD], [ld])
    elif test "x$enable_ld_override" = "xyes"; then
        find_ld
    else
        AC_CHECK_TARGET_TOOL([LD], [ld])
    fi

    CHECK_LD_COPY_BUG([$1])
])
m4trace:m4/find_llvm_prog.m4:12: -1- AC_DEFUN([FIND_LLVM_PROG], [
    # Test for program with and without version name.
    PROG_VERSION_CANDIDATES=$(for llvmVersion in `seq $4 -1 $3`; do echo "$2-$llvmVersion $2-$llvmVersion.0"; done)
    AC_CHECK_TOOLS([$1], [$PROG_VERSION_CANDIDATES $2], [])
    AS_IF([test x"$$1" != x],[
        PROG_VERSION=`$$1 --version | awk '/.*version [[0-9\.]]+/{for(i=1;i<=NF;i++){ if(\$i ~ /^[[0-9\.]]+$/){print \$i}}}'`
        AS_IF([test x"$PROG_VERSION" == x],
          [AC_MSG_RESULT(no)
           $1=""
           AC_MSG_NOTICE([We only support llvm $3 to $4 (no version found).])],
          [AC_MSG_CHECKING([$$1 version ($PROG_VERSION) is between $3 and $4])
           AX_COMPARE_VERSION([$PROG_VERSION], [lt], [$3],
            [AC_MSG_RESULT(no)
             $1=""
             AC_MSG_NOTICE([We only support llvm $3 to $4 (found $PROG_VERSION).])],
            [AX_COMPARE_VERSION([$PROG_VERSION], [ge], [$4],
             [AC_MSG_RESULT(no)
              $1=""
              AC_MSG_NOTICE([We only support llvm $3 to $4 (found $PROG_VERSION).])],
             [AC_MSG_RESULT(yes)])])])])
])
m4trace:m4/find_merge_objects.m4:6: -1- AC_DEFUN([FIND_MERGE_OBJECTS], [
    AC_REQUIRE([FIND_LD])

    if test -z "$MergeObjsCmd"; then
        MergeObjsCmd="$LD"
    fi
    if test -z "$MergeObjsArgs"; then
        MergeObjsArgs="-r"
    fi

    CHECK_FOR_GOLD_T22266($MergeObjsCmd)
    if test "$result" = "1"; then
        AC_MSG_NOTICE([$MergeObjsCmd is broken due to binutils 22266, looking for another linker...])
        MergeObjsCmd=""
        AC_CHECK_TARGET_TOOL([MergeObjsCmd], [ld])
        CHECK_FOR_GOLD_T22266($MergeObjsCmd)
        if test "$result" = "1"; then
            AC_MSG_ERROR([Linker is affected by binutils 22266 but couldn't find another unaffected linker. Please set the MergeObjsCmd variable to a functional linker.])
        fi
    fi

    AC_SUBST([MergeObjsCmd])
    AC_SUBST([MergeObjsArgs])
])
m4trace:m4/find_python.m4:5: -1- AC_DEFUN([FIND_PYTHON], [
    dnl Prefer the mingw64 distribution on Windows due to #17483.
    AC_PATH_PROG([PYTHON], [python3], [], [/mingw64/bin $PATH])
    PythonCmd="$PYTHON"
    AC_SUBST([PythonCmd])
])
m4trace:m4/fp_bfd_support.m4:4: -1- AC_DEFUN([FP_BFD_SUPPORT], [
    AC_SUBST([CabalHaveLibbfd], [False])
    AC_ARG_ENABLE(bfd-debug,
        [AS_HELP_STRING([--enable-bfd-debug],
              [Enable symbol resolution for -debug rts ('+RTS -Di') via binutils' libbfd [default=no]])],
        [
            # don't pollute general LIBS environment
            save_LIBS="$LIBS"
            AC_CHECK_HEADERS([bfd.h])
            dnl ** check whether this machine has BFD and libiberty installed (used for debugging)
            dnl    the order of these tests matters: bfd needs libiberty
            AC_CHECK_LIB(iberty, xmalloc)
            dnl 'bfd_init' is a rare non-macro in libbfd
            AC_CHECK_LIB(bfd,    bfd_init)

            AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <bfd.h>]],
                        [[
                                /* mimic our rts/Printer.c */
                                bfd* abfd;
                                const char * name;
                                char **matching;

                                name = "some.executable";
                                bfd_init();
                                abfd = bfd_openr(name, "default");
                                bfd_check_format_matches (abfd, bfd_object, &matching);
                                {
                                    long storage_needed;
                                    storage_needed = bfd_get_symtab_upper_bound (abfd);
                                }
                                {
                                    asymbol **symbol_table;
                                    long number_of_symbols;
                                    symbol_info info;

                                    number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
                                    bfd_get_symbol_info(abfd,symbol_table[0],&info);
                                }
                        ]])],
                        [AC_SUBST([CabalHaveLibbfd], [True])],dnl bfd seems to work
                        [AC_MSG_ERROR([can't use 'bfd' library])])
            LIBS="$save_LIBS"
        ]
    )
])
m4trace:m4/fp_binutils_T23856.m4:8: -1- AC_DEFUN([FP_BINUTILS_T23856], [
  AC_REQUIRE([FP_GCC_SUPPORTS_NO_PIE])
  if test "$CONF_GCC_SUPPORTS_NO_PIE" = "YES"; then
      AC_MSG_CHECKING([whether ld.gold exhibits weak relocation bug (binutils 23856)])
      echo 'int main() { return 0; }' > conftest.c
      $CC -fuse-ld=gold -no-pie conftest.c -o conftest || AC_MSG_ERROR([Failed to compile test])
      if ./conftest; then
        AC_MSG_RESULT([not affected])
      else
        AC_MSG_RESULT([affected])
        AC_MSG_ERROR([The ld.gold linker is affected by binutils bug 23856; please specify a non-broken linker by passing LD=/path/to/ld to ./configure])
      fi
  fi
])
m4trace:m4/fp_cc_linker_flag_try.m4:9: -1- AC_DEFUN([FP_CC_LINKER_FLAG_TRY], [
    AC_MSG_CHECKING([whether C compiler supports -fuse-ld=$1])
    echo 'int main(void) {return 0;}' > conftest.c
    if $CC -o conftest.o -fuse-ld=$1 conftest.c > /dev/null 2>&1
    then
        $2="-fuse-ld=$1"
        AC_MSG_RESULT([yes])
    else
        AC_MSG_RESULT([no])
    fi
    rm -f conftest.c conftest.o
])
m4trace:m4/fp_cc_llvm_backend.m4:3: -1- AC_DEFUN([FP_CC_LLVM_BACKEND], [AC_REQUIRE([AC_PROG_CC])
   AC_MSG_CHECKING([whether C compiler has an LLVM back end])
   $CC -x c /dev/null -dM -E > conftest.txt 2>&1
   if grep "__llvm__" conftest.txt >/dev/null 2>&1; then
     AC_DEFINE([CC_LLVM_BACKEND], [1], [Define (to 1) if C compiler has an LLVM back end])
     CcLlvmBackend=YES
     AC_MSG_RESULT([yes])
   else
     CcLlvmBackend=NO
     AC_MSG_RESULT([no])
   fi
   AC_SUBST(CcLlvmBackend)

   rm -f conftest.txt
])
m4trace:m4/fp_cc_supports__atomics.m4:4: -1- AC_DEFUN([FP_CC_SUPPORTS__ATOMICS], [
    AC_REQUIRE([AC_PROG_CC])
    AC_MSG_CHECKING([whether C compiler supports __atomic_ builtins])
    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[int x, y;]], [[__atomic_load(&x, &y, __ATOMIC_SEQ_CST); return y]])],
    [
        AC_MSG_RESULT(yes)

        need_latomic=0
        AC_MSG_CHECKING(whether -latomic is needed for sub-word-sized atomic operations)
        AC_LINK_IFELSE([AC_LANG_PROGRAM([[unsigned char a;]], [[__atomic_fetch_or(&a, 1, __ATOMIC_RELAXED);]])],
        [
            AC_MSG_RESULT(no)
        ],
        [
            _save_LIBS="$LIBS"
            LIBS="-latomic"
            AC_LINK_IFELSE([AC_LANG_PROGRAM([[unsigned char a;]], [[__atomic_fetch_or(&a, 1, __ATOMIC_RELAXED);]])],
            [
                AC_MSG_RESULT(yes)
                need_latomic=1
            ],
            [
                AC_MSG_RESULT(failed)
                AC_MSG_ERROR([sub-word-sized atomic operations are not available.])
            ])
            LIBS="$_save_LIBS"
        ])
        AC_MSG_CHECKING(whether -latomic is needed for 64-bit atomic operations)
        AC_LINK_IFELSE([AC_LANG_PROGRAM(
            [[
            #include <inttypes.h>
            uint64_t a;
            ]], [[__atomic_fetch_or(&a, 1, __ATOMIC_RELAXED);]])],
        [
            AC_MSG_RESULT(no)
        ],
        [
            _save_LIBS="$LIBS"
            LIBS="-latomic"
            AC_LINK_IFELSE([AC_LANG_PROGRAM(
                [[
                #include <inttypes.h>
                uint64_t a;
                ]], [[__atomic_fetch_or(&a, 1, __ATOMIC_RELAXED);]])],
            [
                AC_MSG_RESULT(yes)
                need_latomic=1
            ],
            [
                AC_MSG_RESULT(failed)
                AC_MSG_ERROR([64-bit atomic operations are not available.])
            ])
            LIBS="$_save_LIBS"
        ])
    ],
    [
        AC_MSG_RESULT(no)
        AC_MSG_ERROR([C compiler needs to support __atomic primitives.])
    ])
    AC_DEFINE([HAVE_C11_ATOMICS], [1], [Does C compiler support __atomic primitives?])
    if test "$need_latomic" = 1; then
        AC_SUBST([CabalNeedLibatomic],[True])
    else
        AC_SUBST([CabalNeedLibatomic],[False])
    fi
    AC_DEFINE_UNQUOTED([NEED_ATOMIC_LIB], [$need_latomic],
        [Define to 1 if we need -latomic.])
])
m4trace:m4/fp_cc_supports_target.m4:9: -1- AC_DEFUN([FP_CC_SUPPORTS_TARGET], [
   AC_REQUIRE([AC_PROG_CC])
   AC_REQUIRE([FPTOOLS_SET_PLATFORM_VARS])
   AC_MSG_CHECKING([whether $1 CC supports --target])
   echo 'int main() { return 0; }' > conftest.c
   if $CC --target=$LlvmTarget -Werror conftest.c > /dev/null 2>&1 ; then
       CONF_CC_SUPPORTS_TARGET=YES
       AC_MSG_RESULT([yes])
   else
       CONF_CC_SUPPORTS_TARGET=NO
       AC_MSG_RESULT([no])
   fi
   rm -f conftest.c conftest

   if test $CONF_CC_SUPPORTS_TARGET = YES ; then
       CONF_CC_OPTS_STAGE1="--target=$LlvmTarget $CONF_CC_OPTS_STAGE1"
       CONF_CC_OPTS_STAGE2="--target=$LlvmTarget $CONF_CC_OPTS_STAGE2"
       CONF_CXX_OPTS_STAGE1="--target=$LlvmTarget $CONF_CXX_OPTS_STAGE1"
       CONF_CXX_OPTS_STAGE2="--target=$LlvmTarget $CONF_CXX_OPTS_STAGE2"
       CONF_GCC_LINKER_OPTS_STAGE1="--target=$LlvmTarget $CONF_GCC_LINKER_OPTS_STAGE1"
       CONF_GCC_LINKER_OPTS_STAGE2="--target=$LlvmTarget $CONF_GCC_LINKER_OPTS_STAGE2"
   fi
])
m4trace:m4/fp_check_alignment.m4:5: -1- AC_DEFUN([FP_CHECK_ALIGNMENT], [AS_LITERAL_IF(m4_translit([[$1]], [*], [p]), [],
               [AC_FATAL([$0: requires literal arguments])])[]dnl
AC_CHECK_TYPE([$1], [], [], [$3])[]dnl
m4_pushdef([fp_Cache], [AS_TR_SH([fp_cv_alignment_$1])])[]dnl
AC_CACHE_CHECK([alignment of $1], [fp_Cache],
[if test "$AS_TR_SH([ac_cv_type_$1])" = yes; then
  FP_COMPUTE_INT([offsetof(struct { char c; $1 ty; },ty)],
                 [fp_Cache],
                 [AC_INCLUDES_DEFAULT([$3])],
                 [AC_MSG_ERROR([cannot compute alignment ($1)
See `config.log' for more details.], [77])])
else
  fp_Cache=0
fi])[]dnl
AC_DEFINE_UNQUOTED(AS_TR_CPP(alignment_$1), $fp_Cache, [The alignment of a `$1'.])[]dnl
m4_popdef([fp_Cache])[]dnl
])
m4trace:m4/fp_check_environ.m4:3: -1- AC_DEFUN([FP_CHECK_ENVIRON], [
  dnl--------------------------------------------------------------------
  dnl * Check whether the libc headers provide a declaration for the
  dnl environ symbol. If not then we will provide one in RtsSymbols.c. 
  dnl See #20512, #20577, #20861.
  dnl--------------------------------------------------------------------
  AC_CHECK_DECLS([environ], [], [], [
    #include <unistd.h>
  ])
])
m4trace:m4/fp_check_func.m4:5: -1- AC_DEFUN([FP_CHECK_FUNC], [AS_VAR_PUSHDEF([fp_func], [fp_cv_func_$1])dnl
AC_CACHE_CHECK([for $1], fp_func,
[AC_LINK_IFELSE([AC_LANG_PROGRAM([$2], [$3])],
                [AS_VAR_SET(fp_func, yes)],
                [AS_VAR_SET(fp_func, no)])])
AS_IF([test AS_VAR_GET(fp_func) = yes],
      [AC_DEFINE(AS_TR_CPP(HAVE_$1), [1],
                [Define to 1 if you have the `]$1[' function.]) $4],
      [$5])dnl
AS_VAR_POPDEF([fp_func])dnl
])
m4trace:m4/fp_check_prog.m4:6: -1- AC_DEFUN([FP_CHECK_PROG], [AC_CHECK_PROG([$1], [$2], [$as_dir/$ac_word$ac_exec_ext], [$3], [$4], [$5])])
m4trace:m4/fp_check_pthreads.m4:4: -1- AC_DEFUN([FP_CHECK_PTHREADS], [
  dnl Some platforms (e.g. Android's Bionic) have pthreads support available
  dnl without linking against libpthread. Check whether -lpthread is necessary
  dnl to use pthreads.
  dnl
  dnl Note that it is important that this happens before we AC_CHECK_LIB(thread)
  AC_MSG_CHECKING(whether -lpthread is needed for pthreads)
  AC_CHECK_FUNC(pthread_create,
      [
          AC_MSG_RESULT(no)
          AC_SUBST([CabalNeedLibpthread],[False])
          need_lpthread=0
      ],
      [
          AC_CHECK_LIB(pthread, pthread_create,
              [
                  AC_MSG_RESULT(yes)
                  AC_SUBST([CabalNeedLibpthread],[True])
                  need_lpthread=1
              ],
              [
                  AC_SUBST([CabalNeedLibpthread],[False])
                  AC_MSG_RESULT([no pthreads support found.])
                  need_lpthread=0
              ])
      ])
  AC_DEFINE_UNQUOTED([NEED_PTHREAD_LIB], [$need_lpthread],
      [Define 1 if we need to link code using pthreads with -lpthread])

  dnl Setting thread names
  dnl ~~~~~~~~~~~~~~~~~~~~
  dnl The portability situation here is complicated:
  dnl
  dnl * FreeBSD supports pthread_set_name_np in <pthread_np.h>
  dnl   and (if not _POSIX_SOURCE) pthread_setname_np() in <pthread.h>
  dnl   because of the conditional visibility, we prefer the former.
  dnl * glibc supports pthread_setname_np
  dnl * Darwin supports pthread_setname_np but does not take a
  dnl   pthread_t argument.
  dnl
  AC_CHECK_HEADERS([pthread_np.h])

  dnl ** pthread_setname_np is a recent addition to glibc, and OS X has
  dnl    a different single-argument version.
  AC_CHECK_LIB(pthread, pthread_setname_np)

  AC_MSG_CHECKING([for pthread_setname_np (Darwin)])
  AC_LINK_IFELSE([
    AC_LANG_PROGRAM(
      [[
      #include <pthread.h>
      ]],
      [[pthread_setname_np("name");]]
    )],
    [
      AC_MSG_RESULT(yes)
      AC_DEFINE([HAVE_PTHREAD_SETNAME_NP_DARWIN], [1],
        [Define to 1 if you have the Darwin version of pthread_setname_np])
    ],
    AC_MSG_RESULT(no)
  )

  dnl glibc
  AC_MSG_CHECKING([for pthread_setname_np (glibc)])
  AC_LINK_IFELSE([
    AC_LANG_PROGRAM(
      [[
      #define _GNU_SOURCE
      #include <pthread.h>
      ]],
      [[pthread_setname_np(pthread_self(), "name");]]
    )],
    [
      AC_MSG_RESULT(yes)
      AC_DEFINE([HAVE_PTHREAD_SETNAME_NP], [1],
        [Define to 1 if you have the glibc version of pthread_setname_np])
    ],
    AC_MSG_RESULT(no)
  )

  dnl FreeBSD
  AC_MSG_CHECKING([for pthread_set_name_np])
  AC_LINK_IFELSE([
    AC_LANG_PROGRAM(
      [[
      #include <pthread_np.h>
      ]],
      [[pthread_set_name_np(pthread_self(), "name");]]
    )],
    [
      AC_MSG_RESULT(yes)
      AC_DEFINE([HAVE_PTHREAD_SET_NAME_NP], [1],
        [Define to 1 if you have pthread_set_name_np])
    ],
    AC_MSG_RESULT(no)
  )

  AC_CHECK_FUNCS_ONCE([pthread_condattr_setclock])
])
m4trace:m4/fp_check_sizeof_and_alignment.m4:4: -1- AC_DEFUN([FP_CHECK_SIZEOF_AND_ALIGNMENT], [AC_CHECK_SIZEOF([$1])
FP_CHECK_ALIGNMENT([$1])
])
m4trace:m4/fp_check_timer_create.m4:5: -1- AC_DEFUN([FP_CHECK_TIMER_CREATE], [
AC_CHECK_FUNC([timer_create],[HAVE_timer_create=yes],[HAVE_timer_create=no])

if test "$HAVE_timer_create" = "yes"
then
  if test "$cross_compiling" = "yes"
  then
    # We can't test timer_create when we're cross-compiling, so we
    # optimistiaclly assume that it actually works properly.
    AC_DEFINE([USE_TIMER_CREATE], 1,  [Define to 1 if we can use timer_create(CLOCK_REALTIME,...)])
  else
  AC_CACHE_CHECK([for a working timer_create(CLOCK_REALTIME)],
    [fptools_cv_timer_create_works],
    [AC_TRY_RUN([
#include <stdio.h>
#if defined(HAVE_STDLIB_H)
#include <stdlib.h>
#endif
#if defined(HAVE_TIME_H)
#include <time.h>
#endif
#if defined(HAVE_SIGNAL_H)
#include <signal.h>
#endif
#if defined(HAVE_UNISTD_H)
#include <unistd.h>
#endif

static volatile int tock = 0;
static void handler(int i)
{
   tock = 1;
}

static void timeout(int i)
{
  // timer_settime() has been known to hang, so just in case
  // we install a 1-second timeout (see #2257)
  exit(99);
}

int main(int argc, char *argv[])
{

    struct sigevent ev;
    timer_t timer;
    struct itimerspec it;
    struct sigaction action;
    int m,n,count = 0;

    ev.sigev_notify = SIGEV_SIGNAL;
    ev.sigev_signo  = SIGVTALRM;

    action.sa_handler = handler;
    action.sa_flags = 0;
    sigemptyset(&action.sa_mask);
    if (sigaction(SIGVTALRM, &action, NULL) == -1) {
        fprintf(stderr,"SIGVTALRM problem\n");
        exit(3);
    }

    action.sa_handler = timeout;
    action.sa_flags = 0;
    sigemptyset(&action.sa_mask);
    if (sigaction(SIGALRM, &action, NULL) == -1) {
      fprintf(stderr,"SIGALRM problem\n");
      exit(3);
    }
    alarm(1);

    if (timer_create(CLOCK_REALTIME, &ev, &timer) != 0) {
        fprintf(stderr,"No CLOCK_REALTIME timer\n");
        exit(2);
    }

    tock = 0;

    it.it_value.tv_sec = 0;
    it.it_value.tv_nsec = 1000000; // 1ms
    it.it_interval = it.it_value;
    if (timer_settime(timer, 0, &it, NULL) != 0) {
        fprintf(stderr,"settime problem\n");
        exit(4);
    }

    // some environments have coarse scheduler/timer granularity of ~10ms and worse
    usleep(100000); // 100ms

    if (!tock) {
        fprintf(stderr,"no CLOCK_REALTIME signal\n");
        exit(5);
    }

    timer_delete(timer);

    exit(0);
}
     ],
     [fptools_cv_timer_create_works=yes],
     [fptools_cv_timer_create_works=no])
  ])
case $fptools_cv_timer_create_works in
    yes) AC_DEFINE([USE_TIMER_CREATE], 1,
                   [Define to 1 if we can use timer_create(CLOCK_REALTIME,...)]);;
esac
  fi
fi
])
m4trace:m4/fp_compare_versions.m4:5: -1- AC_DEFUN([FP_COMPARE_VERSIONS], [fp_version1=$1; fp_version2=$3
fp_save_IFS=$IFS; IFS='.'
while test x"$fp_version1" != x || test x"$fp_version2" != x
do

  set dummy $fp_version1; shift
  fp_num1=""
  test $[@%:@] = 0 || { fp_num1="[$]1"; shift; }
  test x"$fp_num1" = x && fp_num1="0"
  fp_version1="[$]*"

  set dummy $fp_version2; shift
  fp_num2=""
  test $[@%:@] = 0 || { fp_num2="[$]1"; shift; }
  test x"$fp_num2" = x && fp_num2="0"
  fp_version2="[$]*"

  test "$fp_num1" = "$fp_num2" || break;
done
IFS=$fp_save_IFS
AS_IF([test "$fp_num1" $2 "$fp_num2"], [$4], [$5])[]dnl
])
m4trace:m4/fp_compute_int.m4:10: -1- AC_DEFUN([FP_COMPUTE_INT], [AC_COMPUTE_INT([$2], [$1], [$3], [$4])[]dnl
])
m4trace:m4/fp_copy_shellvar.m4:2: -1- AC_DEFUN([FP_COPY_SHELLVAR], [if test -n "${$1+set}"; then $2="$$1"; else unset $2; fi ])
m4trace:m4/fp_cpp_cmd_with_args.m4:8: -1- AC_DEFUN([FP_CPP_CMD_WITH_ARGS], [
dnl ** what cpp to use?
dnl --------------------------------------------------------------
AC_ARG_WITH(hs-cpp,
[AS_HELP_STRING([--with-hs-cpp=ARG],
      [Path to the (C) preprocessor for Haskell files [default=autodetect]])],
[
    if test "$HostOS" = "mingw32"
    then
        AC_MSG_WARN([Request to use $withval will be ignored])
    else
        HS_CPP_CMD=$withval
    fi
],
[

    # We can't use $CPP here, since HS_CPP_CMD is expected to be a single
    # command (no flags), and AC_PROG_CPP defines CPP as "/usr/bin/gcc -E".
    HS_CPP_CMD=$CC

    SOLARIS_GCC_CPP_BROKEN=NO
    SOLARIS_FOUND_GOOD_CPP=NO
    case $host in
        i386-*-solaris2)
        GCC_MAJOR_MINOR=`$CC --version|grep "gcc (GCC)"|cut -d ' ' -f 3-3|cut -d '.' -f 1-2`
        if test "$GCC_MAJOR_MINOR" != "3.4"; then
          # this is not 3.4.x release so with broken CPP
          SOLARIS_GCC_CPP_BROKEN=YES
        fi
        ;;
    esac

    if test "$SOLARIS_GCC_CPP_BROKEN" = "YES"; then
      # let's try to find if GNU C 3.4.x is installed
      if test -x /usr/sfw/bin/gcc; then
        # something executable is in expected path so let's
        # see if it's really GNU C
        NEW_GCC_MAJOR_MINOR=`/usr/sfw/bin/gcc --version|grep "gcc (GCC)"|cut -d ' ' -f 3-3|cut -d '.' -f 1-2`
        if test "$NEW_GCC_MAJOR_MINOR" = "3.4"; then
          # this is GNU C 3.4.x which provides non-broken CPP on Solaris
          # let's use it as CPP then.
          HS_CPP_CMD=/usr/sfw/bin/gcc
          SOLARIS_FOUND_GOOD_CPP=YES
        fi
      fi
      if test "$SOLARIS_FOUND_GOOD_CPP" = "NO"; then
        AC_MSG_WARN([Your GNU C provides broken CPP and you do not have GNU C 3.4.x installed.])
        AC_MSG_WARN([Please install GNU C 3.4.x to solve this issue. It will be used as CPP only.])
      fi
    fi
]
)

dnl ** what cpp flags to use?
dnl -----------------------------------------------------------
AC_ARG_WITH(hs-cpp-flags,
  [AS_HELP_STRING([--with-hs-cpp-flags=ARG],
      [Flags to the (C) preprocessor for Haskell files [default=autodetect]])],
  [
      if test "$HostOS" = "mingw32"
      then
          AC_MSG_WARN([Request to use $withval will be ignored])
      else
          HS_CPP_ARGS=$withval
      fi
  ],
[
  $HS_CPP_CMD -x c /dev/null -dM -E > conftest.txt 2>&1
  if grep "__clang__" conftest.txt >/dev/null 2>&1; then
    HS_CPP_ARGS="-E -undef -traditional -Wno-invalid-pp-token -Wno-unicode -Wno-trigraphs"
  else
      $HS_CPP_CMD  -v > conftest.txt 2>&1
      if  grep "gcc" conftest.txt >/dev/null 2>&1; then
          HS_CPP_ARGS="-E -undef -traditional"
        else
          $HS_CPP_CMD  --version > conftest.txt 2>&1
          if grep "cpphs" conftest.txt >/dev/null 2>&1; then
            HS_CPP_ARGS="--cpp -traditional"
          else
            AC_MSG_WARN([configure can't recognize your CPP program, you may need to set --with-hs-cpp-flags=FLAGS explicitly])
            HS_CPP_ARGS=""
          fi
      fi
  fi
  ]
)

$1=$HS_CPP_CMD
$2=$HS_CPP_ARGS

])
m4trace:m4/fp_curses.m4:3: -1- AC_DEFUN([FP_CURSES], [
  dnl--------------------------------------------------------------------
  dnl * Deal with arguments telling us curses is somewhere odd
  dnl--------------------------------------------------------------------

  AC_ARG_WITH([curses-includes],
    [AS_HELP_STRING([--with-curses-includes],
      [directory containing curses headers])],
      [CURSES_INCLUDE_DIRS=$withval])

  AC_ARG_WITH([curses-libraries],
    [AS_HELP_STRING([--with-curses-libraries],
      [directory containing curses libraries])],
      [CURSES_LIB_DIRS=$withval])

  AC_SUBST(CURSES_INCLUDE_DIRS)
  AC_SUBST(CURSES_LIB_DIRS)
])
m4trace:m4/fp_default_choice_override_check.m4:17: -1- AC_DEFUN([FP_DEFAULT_CHOICE_OVERRIDE_CHECK], [AC_ARG_ENABLE(
        [$1],
        [AS_HELP_STRING(
            [--enable-$1],
            [$5])],
        [AS_IF(
           [test x"$enableval" = x"m4_default([$8],yes)"],
           [AS_CASE(
               [x"$$4Default"],
               [x"m4_default([$6],YES)"],
                 [AC_MSG_NOTICE([user chose $2 matching default for platform])],
               [x"m4_default([$7],NO)"],
                 [AC_MSG_ERROR([user chose $2 overriding only supported option for platform])],
               [AC_MSG_ERROR([invalid default])])
            $4=m4_default([$6],YES)],
           [AS_CASE(
               [x"$$4Default"],
               [x"m4_default([$6],YES)"],
                 [AC_MSG_NOTICE([user chose $3 overriding for platform])],
               [x"m4_default([$7],NO)"],
                 [AC_MSG_NOTICE([user chose $3 matching default for platform])],
               [AC_MSG_ERROR([invalid default])])
            $4=m4_default([$7],NO)])],
        [$4="$$4Default"])])
m4trace:m4/fp_find_libdw.m4:4: -1- AC_DEFUN([FP_FIND_LIBDW], [
  AC_ARG_WITH([libdw-libraries],
    [AS_HELP_STRING([--with-libdw-libraries=ARG],
      [Find libraries for libdw in ARG [default=system default]])
    ],
    [
      LibdwLibDir="$withval"
      LIBDW_LDFLAGS="-L$withval"
    ])

  AC_SUBST(LibdwLibDir)

  AC_ARG_WITH([libdw-includes],
    [AS_HELP_STRING([--with-libdw-includes=ARG],
      [Find includes for libdw in ARG [default=system default]])
    ],
    [
      LibdwIncludeDir="$withval"
      LIBDW_CFLAGS="-I$withval"
    ])

  AC_SUBST(LibdwIncludeDir)

  UseLibdw=NO
  USE_LIBDW=0
  AC_ARG_ENABLE(dwarf-unwind,
      [AS_HELP_STRING([--enable-dwarf-unwind],
          [Enable DWARF unwinding support in the runtime system via elfutils' libdw [default=no]])])
  if test "$enable_dwarf_unwind" = "yes" ; then
    CFLAGS2="$CFLAGS"
    CFLAGS="$LIBDW_CFLAGS $CFLAGS"
    LDFLAGS2="$LDFLAGS"
    LDFLAGS="$LIBDW_LDFLAGS $LDFLAGS"

    AC_CHECK_LIB(dw, dwfl_attach_state,
        [AC_CHECK_HEADERS([elfutils/libdw.h], [break], [])
         UseLibdw=YES],
        [AC_MSG_ERROR([Cannot find system libdw (required by --enable-dwarf-unwind)])])

    CFLAGS="$CFLAGS2"
    LDFLAGS="$LDFLAGS2"
  fi

  AC_SUBST(UseLibdw)
  if test $UseLibdw = "YES" ; then
    USE_LIBDW=1
    AC_SUBST([CabalHaveLibdw],[True])
  else
    AC_SUBST([CabalHaveLibdw],[False])
  fi
  AC_DEFINE_UNQUOTED([USE_LIBDW], [$USE_LIBDW], [Set to 1 to use libdw])
])
m4trace:m4/fp_find_libnuma.m4:1: -1- AC_DEFUN([FP_FIND_LIBNUMA], [
  dnl ** Have libnuma?
  dnl --------------------------------------------------------------
  AC_ARG_WITH([libnuma-libraries],
    [AS_HELP_STRING([--with-libnuma-libraries=ARG],
      [Find libraries for libnuma in ARG [default=system default]])
    ],
    [
      LibNumaLibDir="$withval"
      LIBNUMA_LDFLAGS="-L$withval"
    ])

  AC_SUBST(LibNumaLibDir)

  AC_ARG_WITH([libnuma-includes],
    [AS_HELP_STRING([--with-libnuma-includes=ARG],
      [Find includes for libnuma in ARG [default=system default]])
    ],
    [
      LibNumaIncludeDir="$withval"
      LIBNUMA_CFLAGS="-I$withval"
    ])

  AC_SUBST(LibNumaIncludeDir)

  HaveLibNuma=0
  AC_ARG_ENABLE(numa,
      [AS_HELP_STRING([--enable-numa],
          [Enable NUMA memory policy and thread affinity support in the
           runtime system via numactl's libnuma [default=auto]])])

  if test "$enable_numa" != "no" ; then
    CFLAGS2="$CFLAGS"
    CFLAGS="$LIBNUMA_CFLAGS $CFLAGS"
    LDFLAGS2="$LDFLAGS"
    LDFLAGS="$LIBNUMA_LDFLAGS $LDFLAGS"

    AC_CHECK_HEADERS([numa.h numaif.h])

    if test "$ac_cv_header_numa_h$ac_cv_header_numaif_h" = "yesyes" ; then
      AC_CHECK_LIB(numa, numa_available,HaveLibNuma=1)
    fi
    if test "$enable_numa:$HaveLibNuma" = "yes:0" ; then
        AC_MSG_ERROR([Cannot find system libnuma (required by --enable-numa)])
    fi

    CFLAGS="$CFLAGS2"
    LDFLAGS="$LDFLAGS2"
  fi

  AC_DEFINE_UNQUOTED([HAVE_LIBNUMA], [$HaveLibNuma], [Define to 1 if you have libnuma])
  if test $HaveLibNuma = "1" ; then
    AC_SUBST([UseLibNuma],[YES])
    AC_SUBST([CabalHaveLibNuma],[True])
  else
    AC_SUBST([UseLibNuma],[NO])
    AC_SUBST([CabalHaveLibNuma],[False])
  fi
])
m4trace:m4/fp_find_nm.m4:4: -1- AC_DEFUN([FP_FIND_NM], [
    if test "$HostOS" != "mingw32"; then
        AC_CHECK_TARGET_TOOL([NM], [nm])
        if test "$NM" = ":"; then
            AC_MSG_ERROR([cannot find nm in your PATH])
        fi
    fi
    NmCmd="$NM"
    AC_SUBST([NmCmd])

    if test "$TargetOS_CPP" = "darwin"
    then
        AC_MSG_CHECKING(whether nm program is broken)
        # Some versions of Xcode ship a broken version of `nm`. Detect and work
        # around this issue. See : https://gitlab.haskell.org/ghc/ghc/issues/11744
        nmver=$(${NM} --version | grep version | sed 's/ //g')
        case "$nmver" in
            LLVMversion7.3.0|LLVMversion7.3.1)
                AC_MSG_RESULT(yes)
                echo "The detected nm program is broken."
                echo
                echo "See: https://gitlab.haskell.org/ghc/ghc/issues/11744"
                echo
                echo "Try re-running configure with:"
                echo
                echo '   NM=$(xcrun --find nm-classic) ./configure'
                echo
                exit 1
                ;;
            *)
                AC_MSG_RESULT(no)
                ;;
            esac
    fi
])
m4trace:m4/fp_find_root.m4:5: -1- AC_DEFUN([FP_FIND_ROOT], [
AC_MSG_CHECKING(for path to top of build tree)
    if test "$windows" = YES
    then
      dnl Make sure this is a c:/foo/bar (mixed) style path. Some parts of
      dnl the build system might depend on it (such as the sed expression
      dnl `"s|$(TOP)/||i"` in addCFileDeps in rules/build-dependencies.mk).
      hardtop=$(cygpath -m "$(pwd)")
    else
      hardtop=$(pwd)
    fi

    dnl Remove common automounter nonsense
    hardtop=`echo $hardtop | sed 's|^/tmp_mnt.*\(/local/.*\)$|\1|' | sed 's|^/tmp_mnt/|/|'`

    if ! test -d "$hardtop"; then
        AC_MSG_ERROR([cannot determine current directory])
    fi

    dnl We don't support building in directories with spaces.
    case "$hardtop" in
    *' '*)
        AC_MSG_ERROR([
        The build system does not support building in a directory
        containing space characters.
        Suggestion: move the build tree somewhere else.])
        ;;
    esac

    AC_SUBST(hardtop)

    AC_MSG_RESULT($hardtop)
])
m4trace:m4/fp_gcc_extra_flags.m4:9: -1- AC_DEFUN([FP_GCC_EXTRA_FLAGS], [AC_REQUIRE([FP_GCC_VERSION])
AC_CACHE_CHECK([for extra options to pass gcc when compiling via C], [fp_cv_gcc_extra_opts],
[
 if test "$Unregisterised" = "YES"; then
   # These used to be conditioned on gcc version but we no longer support
   # GCC versions which lack support for these flags
   fp_cv_gcc_extra_opts="-fwrapv -fno-builtin"
 fi
])
AC_SUBST([GccExtraViaCOpts],$fp_cv_gcc_extra_opts)
])
m4trace:m4/fp_gcc_supports_no_pie.m4:5: -1- AC_DEFUN([FP_GCC_SUPPORTS_NO_PIE], [
   AC_REQUIRE([AC_PROG_CC])
   AC_MSG_CHECKING([whether GCC supports -no-pie])
   echo 'int main() { return 0; }' > conftest.c
   # Some GCC versions only warn when passed an unrecognized flag.
   if $CC -no-pie -Werror -x c /dev/null -dM -E > conftest.txt 2>&1 && ! grep -i unrecognized conftest.txt > /dev/null 2>&1; then
       CONF_GCC_SUPPORTS_NO_PIE=YES
       AC_MSG_RESULT([yes])
   else
       CONF_GCC_SUPPORTS_NO_PIE=NO
       AC_MSG_RESULT([no])
   fi
   rm -f conftest.c conftest.o conftest
])
m4trace:m4/fp_gcc_version.m4:5: -1- AC_DEFUN([FP_GCC_VERSION], [
  AC_REQUIRE([AC_PROG_CC])
  if test -z "$CC"; then
    AC_MSG_ERROR([C compiler is required])
  fi

  if $CC --version | grep -q gcc; then
    AC_CACHE_CHECK([version of gcc], [fp_cv_gcc_version],
    [
        # Be sure only to look at the first occurrence of the "version " string;
        # Some Apple compilers emit multiple messages containing this string.
        AC_MSG_CHECKING([version of gcc])
        fp_cv_gcc_version="`$CC -v 2>&1 | sed -n -e '1,/version /s/.*version [[^0-9]]*\([[0-9.]]*\).*/\1/p'`"
        AC_MSG_RESULT([$fp_cv_gcc_version])
        # 4.7 is needed for __atomic_ builtins.
        FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-lt], [4.7],
                            [AC_MSG_ERROR([Need at least gcc version 4.7 (newer recommended)])])
    ])
    AC_SUBST([GccVersion], [$fp_cv_gcc_version])
  else
    AC_MSG_NOTICE([\$CC is not gcc; assuming it's a reasonably new C compiler])
  fi
])
m4trace:m4/fp_gmp.m4:3: -1- AC_DEFUN([FP_GMP], [
  dnl--------------------------------------------------------------------
  dnl * Deal with arguments telling us gmp is somewhere odd
  dnl--------------------------------------------------------------------

  AC_ARG_WITH([gmp-includes],
    [AS_HELP_STRING([--with-gmp-includes],
      [directory containing gmp.h])],
      [GMP_INCLUDE_DIRS=$withval])

  AC_ARG_WITH([gmp-libraries],
    [AS_HELP_STRING([--with-gmp-libraries],
      [directory containing gmp library])],
      [GMP_LIB_DIRS=$withval])

  AC_ARG_WITH([intree-gmp],
    [AS_HELP_STRING([--with-intree-gmp],
      [force using the in-tree GMP])],
      [GMP_FORCE_INTREE=YES],
      [GMP_FORCE_INTREE=NO])

  AC_ARG_WITH([gmp-framework-preferred],
    [AS_HELP_STRING([--with-gmp-framework-preferred],
      [on OSX, prefer the GMP framework to the gmp lib])],
      [GMP_PREFER_FRAMEWORK=YES],
      [GMP_PREFER_FRAMEWORK=NO])

  AC_SUBST(GMP_INCLUDE_DIRS)
  AC_SUBST(GMP_LIB_DIRS)
  AC_SUBST(GMP_FORCE_INTREE)
  AC_SUBST(GMP_PREFER_FRAMEWORK)
])
m4trace:m4/fp_iconv.m4:3: -1- AC_DEFUN([FP_ICONV], [
  dnl--------------------------------------------------------------------
  dnl * Deal with arguments telling us iconv is somewhere odd
  dnl--------------------------------------------------------------------

  dnl Note: ICONV_LIB_DIRS and ICONV_INCLUDE_DIRS are not predefined
  dnl to the empty string to allow them to be overridden from the
  dnl environment.

  AC_ARG_WITH([iconv-includes],
    [AS_HELP_STRING([--with-iconv-includes],
      [directory containing iconv.h])],
      [ICONV_INCLUDE_DIRS=$withval])

  AC_ARG_WITH([iconv-libraries],
    [AS_HELP_STRING([--with-iconv-libraries],
      [directory containing iconv library])],
      [ICONV_LIB_DIRS=$withval])

  AC_SUBST(ICONV_INCLUDE_DIRS)
  AC_SUBST(ICONV_LIB_DIRS)
])
m4trace:m4/fp_leading_underscore.m4:13: -1- AC_DEFUN([FP_LEADING_UNDERSCORE], [AC_CHECK_LIB([elf], [nlist], [LIBS="-lelf $LIBS"])
AC_CACHE_CHECK([leading underscore in symbol names], [fptools_cv_leading_underscore], [
# Hack!: nlist() under Digital UNIX insist on there being an _,
# but symbol table listings shows none. What is going on here?!?
case $TargetPlatform in
    # Apples mach-o platforms use leading underscores
    *-apple-*) fptools_cv_leading_underscore=yes;;
    *linux-android*) fptools_cv_leading_underscore=no;;
    *openbsd*) # x86 openbsd is ELF from 3.4 >, meaning no leading uscore
      case $build in
        i386-*2\.@<:@0-9@:>@ | i386-*3\.@<:@0-3@:>@ ) fptools_cv_leading_underscore=yes ;;
        *) fptools_cv_leading_underscore=no ;;
      esac ;;
    i386-unknown-mingw32) fptools_cv_leading_underscore=yes;;
    x86_64-unknown-mingw32) fptools_cv_leading_underscore=no;;
    *) AC_RUN_IFELSE([AC_LANG_SOURCE([[#if defined(HAVE_NLIST_H)
#include <nlist.h>
struct nlist xYzzY1[] = {{"xYzzY1", 0},{0}};
struct nlist xYzzY2[] = {{"_xYzzY2", 0},{0}};
#endif

int main(argc, argv)
int argc;
char **argv;
{
#if defined(HAVE_NLIST_H)
    if(nlist(argv[0], xYzzY1) == 0 && xYzzY1[0].n_value != 0)
        exit(1);
    if(nlist(argv[0], xYzzY2) == 0 && xYzzY2[0].n_value != 0)
        exit(0);
#endif
    exit(1);
}]])],[fptools_cv_leading_underscore=yes],[fptools_cv_leading_underscore=no],[fptools_cv_leading_underscore=no])
;;
esac]);
AC_SUBST([LeadingUnderscore], [`echo $fptools_cv_leading_underscore | sed 'y/yesno/YESNO/'`])
if test x"$fptools_cv_leading_underscore" = xyes; then
   AC_SUBST([CabalLeadingUnderscore],[True])
   AC_DEFINE([LEADING_UNDERSCORE], [1], [Define to 1 if C symbols have a leading underscore added by the compiler.])
else
   AC_SUBST([CabalLeadingUnderscore],[False])
fi
])
m4trace:m4/fp_prog_ar.m4:7: -1- AC_DEFUN([FP_PROG_AR], [AC_SUBST(fp_prog_ar,$AR)
if test -z "$fp_prog_ar"; then
  if test "$HostOS" = "mingw32"
  then
    AC_PATH_PROG([fp_prog_ar], [ar])
    if test -n "$fp_prog_ar"; then
      fp_prog_ar=$(cygpath -m $fp_prog_ar)
    fi
  else
    AC_CHECK_TARGET_TOOL([fp_prog_ar], [ar])
  fi
fi
if test -z "$fp_prog_ar"; then
  AC_MSG_ERROR([cannot find ar in your PATH, no idea how to make a library])
fi
])
m4trace:m4/fp_prog_ar_args.m4:5: -1- AC_DEFUN([FP_PROG_AR_ARGS], [AC_REQUIRE([FP_PROG_AR_IS_GNU])
AC_CACHE_CHECK([for ar arguments], [fp_cv_prog_ar_args],
[
# GNU ar needs special treatment: it appears to have problems with
# object files with the same name if you use the 's' modifier, but
# simple 'ar q' works fine, and doesn't need a separate ranlib.
if test $fp_prog_ar_is_gnu = yes; then
  fp_cv_prog_ar_args="q"
else
  touch conftest.dummy
  for fp_var in qclsZ qcls qcs qcl qc ; do
     rm -f conftest.a
     if "$fp_prog_ar" $fp_var conftest.a conftest.dummy > /dev/null 2> /dev/null ; then
       # Also check that a result was created; it seems some llvm-ar versions
       # exit with code zero even if they fail to parse the command line.
       if test -f conftest.a ; then
         fp_cv_prog_ar_args=$fp_var
         break
       fi
     fi
  done
  rm -f conftest*
  if test -z "$fp_cv_prog_ar_args"; then
    AC_MSG_ERROR([cannot figure out how to use your $fp_prog_ar])
  fi
fi])
fp_prog_ar_args=$fp_cv_prog_ar_args
AC_SUBST([ArCmd], ["$fp_prog_ar"])
AC_SUBST([ArArgs], ["$fp_prog_ar_args"])

])
m4trace:m4/fp_prog_ar_is_gnu.m4:4: -1- AC_DEFUN([FP_PROG_AR_IS_GNU], [AC_REQUIRE([FP_PROG_AR])
AC_CACHE_CHECK([whether $fp_prog_ar is GNU ar], [fp_cv_prog_ar_is_gnu],
[if "$fp_prog_ar" --version 2> /dev/null | grep "GNU" > /dev/null 2>&1; then
  fp_cv_prog_ar_is_gnu=yes
else
  fp_cv_prog_ar_is_gnu=no
fi])
fp_prog_ar_is_gnu=$fp_cv_prog_ar_is_gnu
AC_SUBST([ArIsGNUAr], [`echo $fp_prog_ar_is_gnu | tr 'a-z' 'A-Z'`])
])
m4trace:m4/fp_prog_ar_needs_ranlib.m4:6: -1- AC_DEFUN([FP_PROG_AR_NEEDS_RANLIB], [
    AC_REQUIRE([FP_PROG_AR_IS_GNU])
    AC_REQUIRE([FP_PROG_AR_ARGS])
    AC_REQUIRE([AC_PROG_CC])

    AC_PROG_RANLIB

    if test $fp_prog_ar_is_gnu = yes
    then
        fp_cv_prog_ar_needs_ranlib=no
    elif test "$TargetVendor_CPP" = "apple"
    then
        # It's quite tedious to check for Apple's crazy timestamps in
        # .a files, so we hardcode it.
        fp_cv_prog_ar_needs_ranlib=yes
    else
        case $fp_prog_ar_args in
        *s*)
            fp_cv_prog_ar_needs_ranlib=no;;
        *)
            fp_cv_prog_ar_needs_ranlib=yes;;
        esac
    fi

    # workaround for AC_PROG_RANLIB which sets RANLIB to `:' when
    # ranlib is missing on the target OS. The problem is that
    # ghc-cabal cannot execute `:' which is a shell built-in but can
    # execute `true' which is usually simple program supported by the
    # OS.
    # Fixes #8795
    if test "$RANLIB" = ":"
    then
        RANLIB="true"
    fi
    REAL_RANLIB_CMD="$RANLIB"
    if test $fp_cv_prog_ar_needs_ranlib = yes
    then
        RANLIB_CMD="$RANLIB"
    else
        RANLIB_CMD="true"
    fi
    AC_SUBST([REAL_RANLIB_CMD])
    AC_SUBST([RANLIB_CMD])
])
m4trace:m4/fp_prog_ar_supports_atfile.m4:5: -1- AC_DEFUN([FP_PROG_AR_SUPPORTS_ATFILE], [AC_REQUIRE([FP_PROG_AR])
 AC_REQUIRE([FP_PROG_AR_ARGS])
AC_CACHE_CHECK([whether $fp_prog_ar supports @file], [fp_cv_prog_ar_supports_atfile],
[
rm -f conftest*
touch conftest.file
echo conftest.file  > conftest.atfile
echo conftest.file >> conftest.atfile
"$fp_prog_ar" $fp_prog_ar_args conftest.a @conftest.atfile > /dev/null 2>&1
fp_prog_ar_supports_atfile_tmp=`"$fp_prog_ar" t conftest.a 2> /dev/null | grep -c conftest.file`
rm -f conftest*
if test "$fp_prog_ar_supports_atfile_tmp" -eq 2
then
  fp_cv_prog_ar_supports_atfile=yes
else
  fp_cv_prog_ar_supports_atfile=no
fi])
fp_prog_ar_supports_atfile=$fp_cv_prog_ar_supports_atfile
AC_SUBST([ArSupportsAtFile], [`echo $fp_prog_ar_supports_atfile | tr 'a-z' 'A-Z'`])
])
m4trace:m4/fp_prog_context_diff.m4:6: -1- AC_DEFUN([FP_PROG_CONTEXT_DIFF], [AC_CACHE_CHECK([for a working context diff], [fp_cv_context_diff],
[echo foo > conftest1
echo foo > conftest2
fp_cv_context_diff=no
for fp_var in '-U 1' '-u1' '-C 1' '-c1'
do
  if diff $fp_var conftest1 conftest2 > /dev/null 2>&1; then
    fp_cv_context_diff="diff $fp_var"
    break
  fi
done])
if test x"$fp_cv_context_diff" = xno; then
   AC_MSG_ERROR([cannot figure out how to do context diffs])
fi
AC_SUBST(ContextDiffCmd, [$fp_cv_context_diff])
])
m4trace:m4/fp_prog_find.m4:4: -1- AC_DEFUN([FP_PROG_FIND], [AC_PATH_PROGS([fp_prog_find], [gfind find], find)
echo foo > conftest.txt
$fp_prog_find conftest.txt -print > conftest.out 2>&1
if grep '^conftest.txt$' conftest.out > /dev/null 2>&1 ; then
  # OK, looks like a real "find".
  FindCmd="$fp_prog_find"
else
  # Found a poor WinDoze version of "find", ignore it.
  AC_MSG_WARN([$fp_prog_find looks like a non-*nix find, ignoring it])
  FP_CHECK_PROG([FindCmd], [find], [], [], [$fp_prog_find])
fi
rm -f conftest.txt conftest.out
AC_SUBST([FindCmd])[]dnl
])
m4trace:m4/fp_prog_ghc_pkg.m4:5: -1- AC_DEFUN([FP_PROG_GHC_PKG], [AC_CACHE_CHECK([for ghc-pkg matching $WithGhc], fp_cv_matching_ghc_pkg,
[
# If we are told to use ghc-stage2, then we're using an in-tree
# compiler. In this case, we just want ghc-pkg, not ghc-pkg-stage2,
# so we sed off -stage[0-9]$. However, if we are told to use
# ghc-6.12.1 then we want to use ghc-pkg-6.12.1, so we keep any
# other suffix.
fp_ghc_pkg_guess=`echo "$WithGhc" | sed -e 's/-stage@<:@0-9@:>@$//' -e 's,ghc\(@<:@^/\\@:>@*\)$,ghc-pkg\1,'`
if "$fp_ghc_pkg_guess" list > /dev/null 2>&1; then
  fp_cv_matching_ghc_pkg=$fp_ghc_pkg_guess
else
  AC_MSG_ERROR([Cannot find matching ghc-pkg])
fi])
GhcPkgCmd=$fp_cv_matching_ghc_pkg
AC_SUBST([GhcPkgCmd])
])
m4trace:m4/fp_prog_ld_build_id.m4:5: -1- AC_DEFUN([FP_PROG_LD_BUILD_ID], [
AC_CACHE_CHECK([whether ld understands --build-id], [fp_cv_ld_build_id],
[echo 'int foo() { return 0; }' > conftest.c
${CC-cc} -c conftest.c
if ${LdCmd} -r --build-id=none -o conftest2.o conftest.o > /dev/null 2>&1; then
   fp_cv_ld_build_id=yes
else
   fp_cv_ld_build_id=no
fi
rm -rf conftest*])
if test "$fp_cv_ld_build_id" = yes; then
  LdHasBuildId=YES
else
  LdHasBuildId=NO
fi
AC_SUBST([LdHasBuildId])
])
m4trace:m4/fp_prog_ld_filelist.m4:5: -1- AC_DEFUN([FP_PROG_LD_FILELIST], [
AC_CACHE_CHECK([whether ld understands -filelist], [fp_cv_ld_has_filelist],
[
    echo 'int foo() { return 0; }' > conftest1.c
    echo 'int bar() { return 0; }' > conftest2.c
    ${CC-cc} -c conftest1.c
    ${CC-cc} -c conftest2.c
    echo conftest1.o  > conftest.o-files
    echo conftest2.o >> conftest.o-files
    if ${LdCmd} -r -filelist conftest.o-files -o conftest.o > /dev/null 2>&1
    then
        fp_cv_ld_has_filelist=yes
    else
        fp_cv_ld_has_filelist=no
    fi
    rm -rf conftest*
])
if test "$fp_cv_ld_has_filelist" = yes; then
    LdHasFilelist=YES
else
    LdHasFilelist=NO
fi
AC_SUBST([LdHasFilelist])
])
m4trace:m4/fp_prog_ld_is_gnu.m4:5: -1- AC_DEFUN([FP_PROG_LD_IS_GNU], [
AC_CACHE_CHECK([whether ld is GNU ld], [fp_cv_gnu_ld],
[[if ${LdCmd} --version 2> /dev/null | grep "GNU" > /dev/null 2>&1; then
  fp_cv_gnu_ld=YES
else
  fp_cv_gnu_ld=NO
fi]])
AC_SUBST([LdIsGNULd],["$fp_cv_gnu_ld"])
])
m4trace:m4/fp_prog_ld_no_compact_unwind.m4:5: -1- AC_DEFUN([FP_PROG_LD_NO_COMPACT_UNWIND], [
AC_CACHE_CHECK([whether ld understands -no_compact_unwind], [fp_cv_ld_no_compact_unwind],
[echo 'int foo() { return 0; }' > conftest.c
${CC-cc} -c conftest.c
if ${LdCmd} -r -no_compact_unwind -o conftest2.o conftest.o > /dev/null 2>&1; then
   fp_cv_ld_no_compact_unwind=yes
else
   fp_cv_ld_no_compact_unwind=no
fi
rm -rf conftest*])
if test "$fp_cv_ld_no_compact_unwind" = yes; then
  LdHasNoCompactUnwind=YES
else
  LdHasNoCompactUnwind=NO
fi
AC_SUBST([LdHasNoCompactUnwind])
])
m4trace:m4/fp_prog_sh.m4:4: -1- AC_DEFUN([FP_PROG_SH], [
 AC_REQUIRE([FPTOOLS_SET_PLATFORM_VARS]) dnl for $windows
 AC_ARG_VAR(SH,[Use as the full path to a Bourne shell. [default=autodetect]])
 AC_PATH_PROGS([SH], [sh bash])
 if test "$windows" = "YES"; then
   dnl use mixed (-m) mode to get C:/mingw64/... with forward slashes.
   dnl     windows (-w) mode will give us C:\... and mess with escaping.
   SH=`cygpath -m "$SH"`
 fi
 AC_SUBST([SH])[]dnl
])
m4trace:m4/fp_prog_sort.m4:4: -1- AC_DEFUN([FP_PROG_SORT], [AC_PATH_PROG([fp_prog_sort], [sort])
echo conwip > conftest.txt
$fp_prog_sort -f conftest.txt > conftest.out 2>&1
if grep 'conwip' conftest.out > /dev/null 2>&1 ; then
  # The goods
  SortCmd="$fp_prog_sort"
else
  # Summink else..pick next one.
  AC_MSG_WARN([$fp_prog_sort looks like a non-*nix sort, ignoring it])
  FP_CHECK_PROG([SortCmd], [sort], [], [], [$fp_prog_sort])
fi
rm -f conftest.txt conftest.out
AC_SUBST([SortCmd])[]dnl
])
m4trace:m4/fp_set_cflags_c99.m4:7: -1- AC_DEFUN([FP_SET_CFLAGS_C99], [
    dnl save current state of AC_PROG_CC_C99
    FP_COPY_SHELLVAR([CC],[fp_save_CC])
    FP_COPY_SHELLVAR([CFLAGS],[fp_save_CFLAGS])
    FP_COPY_SHELLVAR([CPPFLAGS],[fp_save_CPPFLAGS])
    FP_COPY_SHELLVAR([ac_cv_prog_cc_c99],[fp_save_cc_c99])
    dnl set local state
    CC="$$1"
    CFLAGS="$$2"
    CPPFLAGS="$$3"
    unset ac_cv_prog_cc_c99
    dnl perform detection
    AC_PROG_CC_C99
    fp_cc_c99="$ac_cv_prog_cc_c99"
    case "x$ac_cv_prog_cc_c99" in
      x)   ;; # noop
      xno) AC_MSG_ERROR([C99-compatible compiler needed]) ;;
      *)   $2="$$2 $ac_cv_prog_cc_c99"
           $3="$$3 $ac_cv_prog_cc_c99"
           ;;
    esac
    dnl restore saved state
    FP_COPY_SHELLVAR([fp_save_CC],[CC])
    FP_COPY_SHELLVAR([fp_save_CFLAGS],[CFLAGS])
    FP_COPY_SHELLVAR([fp_save_CPPFLAGS],[CPPFLAGS])
    FP_COPY_SHELLVAR([fp_save_cc_c99],[ac_cv_prog_cc_c99])
    dnl cleanup
    unset fp_save_CC
    unset fp_save_CFLAGS
    unset fp_save_cc_c99
])
m4trace:m4/fp_settings.m4:5: -1- AC_DEFUN([FP_SETTINGS], [
    if test "$windows" = YES -a "$EnableDistroToolchain" = "NO"
    then
        mingw_bin_prefix='$$tooldir/mingw/bin/'
        SettingsCCompilerCommand="${mingw_bin_prefix}gcc.exe"
        SettingsHaskellCPPCommand="${mingw_bin_prefix}gcc.exe"
        SettingsHaskellCPPFlags="$HaskellCPPArgs"
        SettingsLdCommand="${mingw_bin_prefix}ld.exe"
        # Overrides FIND_MERGE_OBJECTS in order to avoid hard-coding linker
        # path on Windows (#18550).
        SettingsMergeObjectsCommand="${SettingsLdCommand}"
        SettingsMergeObjectsFlags="-r --oformat=pe-bigobj-x86-64"
        SettingsArCommand="${mingw_bin_prefix}ar.exe"
        SettingsRanlibCommand="${mingw_bin_prefix}ranlib.exe"
        SettingsDllWrapCommand="${mingw_bin_prefix}dllwrap.exe"
        SettingsWindresCommand="${mingw_bin_prefix}windres.exe"
        SettingsTouchCommand='$$topdir/bin/touchy.exe'
    elif test "$EnableDistroToolchain" = "YES"
    then
        SettingsCCompilerCommand="$(basename $CC)"
        SettingsCCompilerFlags="$CONF_CC_OPTS_STAGE2"
        SettingsCxxCompilerFlags="$CONF_CXX_OPTS_STAGE2"
        SettingsHaskellCPPCommand="$(basename $HaskellCPPCmd)"
        SettingsHaskellCPPFlags="$HaskellCPPArgs"
        SettingsLdCommand="$(basename $LdCmd)"
        SettingsMergeObjectsCommand="$(basename $MergeObjsCmd)"
        SettingsMergeObjectsFlags="$MergeObjsArgs"
        SettingsArCommand="$(basename $ArCmd)"
        SettingsDllWrapCommand="$(basename $DllWrapCmd)"
        SettingsWindresCommand="$(basename $WindresCmd)"
        SettingsTouchCommand='$$topdir/bin/touchy.exe'
    else
        SettingsCCompilerCommand="$CC"
        SettingsHaskellCPPCommand="$HaskellCPPCmd"
        SettingsHaskellCPPFlags="$HaskellCPPArgs"
        SettingsLdCommand="$LdCmd"
        SettingsMergeObjectsCommand="$MergeObjsCmd"
        SettingsMergeObjectsFlags="$MergeObjsArgs"
        SettingsArCommand="$ArCmd"
        SettingsRanlibCommand="$RanlibCmd"
        if test -z "$DllWrapCmd"
        then
            SettingsDllWrapCommand="/bin/false"
        else
            SettingsDllWrapCommand="$DllWrapCmd"
        fi
        if test -z "$WindresCmd"
        then
            SettingsWindresCommand="/bin/false"
        else
            SettingsWindresCommand="$WindresCmd"
        fi
       SettingsTouchCommand='touch'
    fi
    if test -z "$LibtoolCmd"
    then
      SettingsLibtoolCommand="libtool"
    else
      SettingsLibtoolCommand="$LibtoolCmd"
    fi
    if test -z "$ClangCmd"
    then
        SettingsClangCommand="clang"
    else
        SettingsClangCommand="$ClangCmd"
    fi
    if test -z "$LlcCmd"
    then
      SettingsLlcCommand="llc"
    else
      SettingsLlcCommand="$LlcCmd"
    fi
    if test -z "$OptCmd"
    then
      SettingsOptCommand="opt"
    else
      SettingsOptCommand="$OptCmd"
    fi
    if test -z "$OtoolCmd"
    then
      SettingsOtoolCommand="otool"
    else
      SettingsOtoolCommand="$OtoolCmd"
    fi
    if test -z "$InstallNameToolCmd"
    then
      SettingsInstallNameToolCommand="install_name_tool"
    else
      SettingsInstallNameToolCommand="$InstallNameToolCmd"
    fi
    SettingsCCompilerFlags="$CONF_CC_OPTS_STAGE2"
    SettingsCxxCompilerFlags="$CONF_CXX_OPTS_STAGE2"
    SettingsCCompilerLinkFlags="$CONF_GCC_LINKER_OPTS_STAGE2"
    SettingsCCompilerSupportsNoPie="$CONF_GCC_SUPPORTS_NO_PIE"
    SettingsLdFlags="$CONF_LD_LINKER_OPTS_STAGE2"
    SettingsUseDistroMINGW="$EnableDistroToolchain"
    AC_SUBST(SettingsCCompilerCommand)
    AC_SUBST(SettingsHaskellCPPCommand)
    AC_SUBST(SettingsHaskellCPPFlags)
    AC_SUBST(SettingsCCompilerFlags)
    AC_SUBST(SettingsCxxCompilerFlags)
    AC_SUBST(SettingsCCompilerLinkFlags)
    AC_SUBST(SettingsCCompilerSupportsNoPie)
    AC_SUBST(SettingsLdCommand)
    AC_SUBST(SettingsLdFlags)
    AC_SUBST(SettingsMergeObjectsCommand)
    AC_SUBST(SettingsMergeObjectsFlags)
    AC_SUBST(SettingsArCommand)
    AC_SUBST(SettingsRanlibCommand)
    AC_SUBST(SettingsOtoolCommand)
    AC_SUBST(SettingsInstallNameToolCommand)
    AC_SUBST(SettingsDllWrapCommand)
    AC_SUBST(SettingsWindresCommand)
    AC_SUBST(SettingsLibtoolCommand)
    AC_SUBST(SettingsTouchCommand)
    AC_SUBST(SettingsClangCommand)
    AC_SUBST(SettingsLlcCommand)
    AC_SUBST(SettingsOptCommand)
    AC_SUBST(SettingsUseDistroMINGW)
])
m4trace:m4/fp_setup_project_version.m4:3: -1- AC_DEFUN([FP_SETUP_PROJECT_VERSION], [
    if test "$RELEASE" = "NO"; then
        AC_MSG_CHECKING([for GHC version date])
        if test -f VERSION_DATE; then
            PACKAGE_VERSION=${PACKAGE_VERSION}.`cat VERSION_DATE`
            AC_MSG_RESULT(given $PACKAGE_VERSION)
        elif test -e .git; then
            changequote(, )dnl
            ver_posixtime=`git log -1 --pretty=format:%ct`
            ver_date=`perl -MPOSIX -e "print strftime('%Y%m%d', gmtime($ver_posixtime));"`
            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
            changequote([, ])dnl
                    AC_MSG_ERROR([failed to detect version date: check that git and perl are in your path])
            fi
            PACKAGE_VERSION=${PACKAGE_VERSION}.$ver_date
            AC_MSG_RESULT(inferred $PACKAGE_VERSION)
        elif test -f VERSION; then
            PACKAGE_VERSION=`cat VERSION`
            AC_MSG_RESULT(given $PACKAGE_VERSION)
        else
            AC_MSG_WARN([cannot determine snapshot version: no .git directory and no VERSION file])
            dnl We'd really rather this case didn't happen, but it might
            dnl do (in particular, people using lndir trees may find that
            dnl the build system can't find any other date). If it does
            dnl happen, then we use the current date.
            dnl This way we get some idea about how recent a build is.
            dnl It also means that packages built for 2 different builds
            dnl will probably use different version numbers, so things are
            dnl less likely to go wrong.
            PACKAGE_VERSION=${PACKAGE_VERSION}.`date +%Y%m%d`
        fi
    fi

    AC_MSG_CHECKING([for GHC Git commit id])
    if test -e .git; then
        git_commit_id=`git rev-parse HEAD`
        if test -n "$git_commit_id" 2>&1 >/dev/null; then true; else
            AC_MSG_ERROR([failed to detect revision: check that git is in your path])
        fi
        PACKAGE_GIT_COMMIT_ID=$git_commit_id
        AC_MSG_RESULT(inferred $PACKAGE_GIT_COMMIT_ID)
    elif test -f GIT_COMMIT_ID; then
        PACKAGE_GIT_COMMIT_ID=`cat GIT_COMMIT_ID`
        AC_MSG_RESULT(given $PACKAGE_GIT_COMMIT_ID)
    else
        AC_MSG_WARN([cannot determine snapshot revision: no .git directory and no 'GIT_COMMIT_ID' file])
        PACKAGE_GIT_COMMIT_ID="0000000000000000000000000000000000000000"
    fi


    # Some renamings
    AC_SUBST([ProjectName], [$PACKAGE_NAME])
    AC_SUBST([ProjectVersion], [$PACKAGE_VERSION])
    AC_SUBST([ProjectGitCommitId], [$PACKAGE_GIT_COMMIT_ID])

    # Split PACKAGE_VERSION into (possibly empty) parts
    VERSION_MAJOR=`echo $PACKAGE_VERSION | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\1'/`
    VERSION_TMP=`echo $PACKAGE_VERSION | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\3'/`
    VERSION_MINOR=`echo $VERSION_TMP | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\1'/`
    ProjectPatchLevel=`echo $VERSION_TMP | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\3'/`

    # Calculate project version as an integer, using 2 digits for minor version
    case $VERSION_MINOR in
      ?) ProjectVersionInt=${VERSION_MAJOR}0${VERSION_MINOR} ;;
      ??) ProjectVersionInt=${VERSION_MAJOR}${VERSION_MINOR} ;;
      *) AC_MSG_ERROR([bad minor version in $PACKAGE_VERSION]) ;;
    esac
    AC_SUBST([ProjectVersionInt])

    # The project patchlevel is zero unless stated otherwise
    test -z "$ProjectPatchLevel" && ProjectPatchLevel=0

    # Save split version of ProjectPatchLevel
    ProjectPatchLevel1=`echo $ProjectPatchLevel | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\1/'`
    ProjectPatchLevel2=`echo $ProjectPatchLevel | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\3/'`

    AC_SUBST([ProjectPatchLevel1])
    AC_SUBST([ProjectPatchLevel2])

    # Remove dots from the patch level; this allows us to have versions like 6.4.1.20050508
    ProjectPatchLevel=`echo $ProjectPatchLevel | sed 's/\.//'`

    AC_SUBST([ProjectPatchLevel])

    # The version of the GHC package changes every day, since the
    # patchlevel is the current date.  We don't want to force
    # recompilation of the entire compiler when this happens, so for
    # GHC HEAD we omit the patchlevel from the package version number.
    #
    # The ProjectPatchLevel1 > 20000000 iff GHC HEAD. If it's for a stable
    # release like 7.10.1 or for a release candidate such as 7.10.1.20141224
    # then we don't omit the patchlevel components.

    ProjectVersionMunged="$ProjectVersion"
    if test "$ProjectPatchLevel1" -gt 20000000; then
      ProjectVersionMunged="${VERSION_MAJOR}.${VERSION_MINOR}"
    fi
    AC_SUBST([ProjectVersionMunged])
])
m4trace:m4/fp_visibility_hidden.m4:4: -1- AC_DEFUN([FP_VISIBILITY_HIDDEN], [
    AC_MSG_CHECKING([whether __attribute__((visibility("hidden"))) is supported])
    echo '__attribute__((visibility("hidden"))) void foo(void) {}' > conftest.c
    if $CC -Wall -Werror -c conftest.c > /dev/null 2>&1
    then
        AC_MSG_RESULT([yes])
        AC_DEFINE(HAS_VISIBILITY_HIDDEN, 1, [Has visibility hidden])
    else
        AC_MSG_RESULT([no])
    fi
    rm -f conftest.c conftest.o
])
m4trace:m4/fptools_alex.m4:11: -1- AC_DEFUN([FPTOOLS_ALEX], [AC_PATH_PROG(ALEX,[alex],)
AC_SUBST(AlexCmd,$ALEX)
AC_CACHE_CHECK([for version of alex], fptools_cv_alex_version,
changequote(, )dnl
[if test x"$AlexCmd" != x; then
   fptools_cv_alex_version=`"$AlexCmd" -v |
              grep 'Alex [Vv]ersion' | sed -e 's/Alex [Vv]ersion \([0-9\.]*\).*/\1/g'` ;
else
   fptools_cv_alex_version="";
fi;
changequote([, ])dnl
])
if test ! -f compiler/GHC/Parser/Lexer.hs || test ! -f compiler/GHC/Cmm/Lexer.hs
then
    FP_COMPARE_VERSIONS([$fptools_cv_alex_version],[-lt],[3.2.6],
      [AC_MSG_ERROR([Alex >= 3.2.6 && < 4 is required to compile GHC.])])[]
    FP_COMPARE_VERSIONS([$fptools_cv_alex_version],[-ge],[4.0.0],
      [AC_MSG_ERROR([Alex >= 3.2.6 && < 4 is required to compile GHC.])])[]
fi
AlexVersion=$fptools_cv_alex_version;
AC_SUBST(AlexVersion)
])
m4trace:m4/fptools_float_word_order_bigendian.m4:5: -1- AC_DEFUN([FPTOOLS_FLOAT_WORD_ORDER_BIGENDIAN], [AC_CACHE_CHECK([whether float word order is big endian], [fptools_cv_float_word_order_bigendian],
    [AC_COMPILE_IFELSE(
      [AC_LANG_PROGRAM(
        [#include <endian.h>],
        [#if defined(__FLOAT_WORD_ORDER) && __FLOAT_WORD_ORDER == BIG_ENDIAN
             return 0;
         #else
             not float word order big endian
         #endif]
      )],
      [fptools_cv_float_word_order_bigendian=yes],
      [fptools_cv_float_word_order_bigendian=no])
    ])
  case $fptools_cv_float_word_order_bigendian in
      yes)
          AC_DEFINE([FLOAT_WORDS_BIGENDIAN], 1,
          [Define to 1 if your processor stores words of floats with
           the most significant byte first]) ;;
  esac
])
m4trace:m4/fptools_ghc_version.m4:9: -1- AC_DEFUN([FPTOOLS_GHC_VERSION], [FPTOOLS_NOCACHE_CHECK([version of ghc], [fptools_version_of_ghc],
["${WithGhc-ghc}" --version > conftestghc 2>&1
  cat conftestghc >&AS_MESSAGE_LOG_FD
#Useless Use Of cat award...
  fptools_version_of_ghc=`cat conftestghc | sed -n -e 's/, patchlevel *\([[0-9]]\)/.\1/;s/.* version \([[0-9]][[0-9.]]*\).*/\1/p'`
  rm -fr conftest*
  if test "[$]fptools_version_of_ghc" = ""
  then
    fptools_version_of_ghc='unknown'
  fi
fptools_version_of_ghc[_major]=`echo [$]fptools_version_of_ghc | sed -e 's/^\([[0-9]]\).*/\1/'`
fptools_version_of_ghc[_minor]=`echo [$]fptools_version_of_ghc | sed -e 's/^[[0-9]]\.\([[0-9]]*\).*/\1/'`
fptools_version_of_ghc[_pl]=`echo [$]fptools_version_of_ghc | sed -n -e 's/^[[0-9]]\.[[0-9]]*\.\([[0-9]]*\)/\1/p'`
#
if test "[$]fptools_version_of_ghc[_pl]" = ""
then
  fptools_version_of_ghc[_all]="[$]fptools_version_of_ghc[_major].[$]fptools_version_of_ghc[_minor]"
  fptools_version_of_ghc[_pl]="0"
else
  fptools_version_of_ghc[_all]="[$]fptools_version_of_ghc[_major].[$]fptools_version_of_ghc[_minor].[$]fptools_version_of_ghc[_pl]"
fi
#
ifelse($#, [1], [dnl
[$1]="[$]fptools_version_of_ghc[_all]"
], $#, [2], [dnl
[$1]="[$]fptools_version_of_ghc[_major]"
[$2]="[$]fptools_version_of_ghc[_minor]"
], $#, [3], [dnl
[$1]="[$]fptools_version_of_ghc[_major]"
[$2]="[$]fptools_version_of_ghc[_minor]"
[$3]="[$]fptools_version_of_ghc[_pl]"
], $#, [4], [dnl
[$1]="[$]fptools_version_of_ghc[_all]"
[$2]="[$]fptools_version_of_ghc[_major]"
[$3]="[$]fptools_version_of_ghc[_minor]"
[$4]="[$]fptools_version_of_ghc[_pl]"
])
])
])
m4trace:m4/fptools_happy.m4:11: -1- AC_DEFUN([FPTOOLS_HAPPY], [AC_PATH_PROG(HAPPY,[happy],)
AC_SUBST(HappyCmd,$HAPPY)
AC_CACHE_CHECK([for version of happy], fptools_cv_happy_version,
changequote(, )dnl
[
if test x"$HappyCmd" != x; then
   fptools_cv_happy_version=`"$HappyCmd" -v |
              grep 'Happy Version' | sed -e 's/Happy Version \([^ ]*\).*/\1/g'` ;
else
   fptools_cv_happy_version="";
fi;
changequote([, ])dnl
])
if test ! -f compiler/GHC/Parser.hs || test ! -f compiler/GHC/Cmm/Parser.hs
then
    FP_COMPARE_VERSIONS([$fptools_cv_happy_version],[-lt],[1.20.0],
      [AC_MSG_ERROR([Happy version 1.20 or later is required to compile GHC.])])[]
    FP_COMPARE_VERSIONS([$fptools_cv_happy_version],[-ge],[1.21.0],
      [AC_MSG_ERROR([Happy version 1.20 or earlier is required to compile GHC.])])[]
fi
HappyVersion=$fptools_cv_happy_version;
AC_SUBST(HappyVersion)
])
m4trace:m4/fptools_nocache_check.m4:7: -1- AC_DEFUN([FPTOOLS_NOCACHE_CHECK], [AC_MSG_CHECKING([$1])
 $3
 AC_MSG_RESULT([$][$2])
])
m4trace:m4/fptools_set_c_ld_flags.m4:9: -1- AC_DEFUN([FPTOOLS_SET_C_LD_FLAGS], [
    AC_REQUIRE([FP_PROG_LD_IS_GNU])
    AC_MSG_CHECKING([Setting up $2, $3, $4 and $5])
    case $$1 in
    i386-*)
        # Workaround for #7799
        $2="$$2 -U__i686"
        ;;
    esac

    case $$1 in
    i386-unknown-mingw32)
        $2="$$2 -march=i686"
        ;;
    i386-portbld-freebsd*)
        $2="$$2 -march=i686"
        ;;
    x86_64-unknown-solaris2)
        # Solaris is a multi-lib platform, providing both 32- and 64-bit
        # user-land. It appears to default to 32-bit builds but we of course want to
        # compile for 64-bits on x86-64.
        #
        # On OpenSolaris uses gnu ld whereas SmartOS appears to use the Solaris
        # implementation, which rather uses the -64 flag.
        $2="$$2 -m64"
        $3="$$3 -m64"
        $5="$$5 -m64"
        if test "$fp_cv_gnu_ld" = "yes"; then
            $4="$$4 -m64"
        else
            $4="$$4 -64"
        fi
        ;;
    alpha-*)
        # For now, to suppress the gcc warning "call-clobbered
        # register used for global register variable", we simply
        # disable all warnings altogether using the -w flag. Oh well.
        $2="$$2 -w -mieee -D_REENTRANT"
        $3="$$3 -w -mieee -D_REENTRANT"
        $5="$$5 -w -mieee -D_REENTRANT"
        ;;
    hppa*)
        # ___HPUX_SOURCE, not _HPUX_SOURCE, is #defined if -ansi!
        # (very nice, but too bad the HP /usr/include files don't agree.)
        $2="$$2 -D_HPUX_SOURCE"
        $3="$$3 -D_HPUX_SOURCE"
        $5="$$5 -D_HPUX_SOURCE"
        ;;

    arm*freebsd*)
        # On arm/freebsd, tell gcc to generate Arm
        # instructions (ie not Thumb).
        $2="$$2 -marm"
        $3="$$3 -Wl,-z,noexecstack"
        $4="$$4 -z noexecstack"
        ;;
    arm*linux*)
        # On arm/linux and arm/android, tell gcc to generate Arm
        # instructions (ie not Thumb).
        $2="$$2 -marm"
        $3="$$3 -Wl,-z,noexecstack"
        $4="$$4 -z noexecstack"
        ;;

    aarch64*freebsd*)
        $3="$$3 -Wl,-z,noexecstack"
        $4="$$4 -z noexecstack"
        ;;
    aarch64*linux*)
        $3="$$3 -Wl,-z,noexecstack"
        $4="$$4 -z noexecstack"
        ;;

    powerpc-ibm-aix*)
        # We need `-D_THREAD_SAFE` to unlock the thread-local `errno`.
        $2="$$2 -D_THREAD_SAFE"
        $3="$$3 -D_THREAD_SAFE -Wl,-bnotextro"
        $4="$$4 -bnotextro"
        $5="$$5 -D_THREAD_SAFE"
        ;;

    x86_64-*-openbsd*)
        # We need -z wxneeded at least to link ghc-stage2 to workaround
        # W^X issue in GHCi on OpenBSD current (as of Aug 2016)
        $3="$$3 -Wl,-z,wxneeded"
        $4="$$4 -z wxneeded"
        ;;

    esac

    AC_MSG_RESULT([done])
])
m4trace:m4/fptools_set_haskell_platform_vars.m4:4: -1- AC_DEFUN([FPTOOLS_SET_HASKELL_PLATFORM_VARS], [
    checkArch() {
        case [$]1 in
        i386)
            test -z "[$]2" || eval "[$]2=ArchX86"
            ;;
        x86_64|amd64)
            test -z "[$]2" || eval "[$]2=ArchX86_64"
            ;;
        powerpc)
            test -z "[$]2" || eval "[$]2=ArchPPC"
            ;;
        powerpc64)
            test -z "[$]2" || eval "[$]2=\"ArchPPC_64 ELF_V1\""
            ;;
        powerpc64le)
            test -z "[$]2" || eval "[$]2=\"ArchPPC_64 ELF_V2\""
            ;;
        s390x)
            test -z "[$]2" || eval "[$]2=ArchS390X"
            ;;
        sparc)
            test -z "[$]2" || eval "[$]2=ArchSPARC"
            ;;
        sparc64)
            test -z "[$]2" || eval "[$]2=ArchSPARC64"
            ;;
        arm)
            GET_ARM_ISA()
            test -z "[$]2" || eval "[$]2=\"ArchARM \$ARM_ISA \$ARM_ISA_EXT \$ARM_ABI\""
            ;;
        aarch64)
            test -z "[$]2" || eval "[$]2=ArchAArch64"
            ;;
        alpha)
            test -z "[$]2" || eval "[$]2=ArchAlpha"
            ;;
        mips|mipseb)
            test -z "[$]2" || eval "[$]2=ArchMipseb"
            ;;
        mipsel)
            test -z "[$]2" || eval "[$]2=ArchMipsel"
            ;;
        riscv64)
            test -z "[$]2" || eval "[$]2=ArchRISCV64"
            ;;
        hppa|hppa1_1|ia64|m68k|nios2|riscv32|rs6000|s390|sh4|vax)
            test -z "[$]2" || eval "[$]2=ArchUnknown"
            ;;
        *)
            echo "Unknown arch [$]1"
            exit 1
            ;;
        esac
    }

    checkVendor() {
        case [$]1 in
        dec|none|unknown|hp|apple|next|sun|sgi|ibm|montavista|portbld|alpine)
            ;;
        *)
            AC_MSG_WARN([Unknown vendor [$]1])
            ;;
        esac
    }

    checkOS() {
        case [$]1 in
        linux|linux-android)
            test -z "[$]2" || eval "[$]2=OSLinux"
            ;;
        darwin|ios|watchos|tvos)
            test -z "[$]2" || eval "[$]2=OSDarwin"
            ;;
        solaris2)
            test -z "[$]2" || eval "[$]2=OSSolaris2"
            ;;
        mingw32)
            test -z "[$]2" || eval "[$]2=OSMinGW32"
            ;;
        freebsd)
            test -z "[$]2" || eval "[$]2=OSFreeBSD"
            ;;
        dragonfly)
            test -z "[$]2" || eval "[$]2=OSDragonFly"
            ;;
        kfreebsdgnu)
            test -z "[$]2" || eval "[$]2=OSKFreeBSD"
            ;;
        openbsd)
            test -z "[$]2" || eval "[$]2=OSOpenBSD"
            ;;
        netbsd)
            test -z "[$]2" || eval "[$]2=OSNetBSD"
            ;;
        haiku)
            test -z "[$]2" || eval "[$]2=OSHaiku"
            ;;
        nto-qnx)
            test -z "[$]2" || eval "[$]2=OSQNXNTO"
            ;;
        dragonfly|hpux|linuxaout|freebsd2|nextstep2|nextstep3|sunos4|ultrix)
            test -z "[$]2" || eval "[$]2=OSUnknown"
            ;;
        aix)
            test -z "[$]2" || eval "[$]2=OSAIX"
            ;;
        gnu)
            test -z "[$]2" || eval "[$]2=OSHurd"
            ;;
        *)
            echo "Unknown OS '[$]1'"
            exit 1
            ;;
        esac
    }

    dnl Note [autoconf assembler checks and -flto]
    dnl ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    dnl
    dnl Autoconf's AC_COMPILE_IFELSE macro is fragile in the case of checks
    dnl which require that the assembler is run. Specifically, GCC does not run
    dnl the assembler if invoked with `-c -flto`; it merely dumps its internal
    dnl AST to the object file, to be compiled and assembled during the final
    dnl link.
    dnl
    dnl This can cause configure checks like that for the
    dnl .subsections_via_symbols directive to pass unexpected (see #16440),
    dnl leading the build system to incorrectly conclude that the directive is
    dnl supported.
    dnl
    dnl For this reason, it is important that configure checks that rely on the
    dnl assembler failing use AC_LINK_IFELSE rather than AC_COMPILE_IFELSE,
    dnl ensuring that the assembler sees the check.
    dnl

    dnl ** check for Apple-style dead-stripping support
    dnl    (.subsections-via-symbols assembler directive)

    AC_MSG_CHECKING(for .subsections_via_symbols)
    dnl See Note [autoconf assembler checks and -flto]
    AC_LINK_IFELSE(
        [AC_LANG_PROGRAM([], [__asm__ (".subsections_via_symbols");])],
        [AC_MSG_RESULT(yes)
         if test x"$TargetArch" = xaarch64; then
            dnl subsections via symbols is busted on arm64
            TargetHasSubsectionsViaSymbols=NO
         else
            TargetHasSubsectionsViaSymbols=YES
            AC_DEFINE([HAVE_SUBSECTIONS_VIA_SYMBOLS],[1],
                   [Define to 1 if Apple-style dead-stripping is supported.])
         fi
        ],
        [TargetHasSubsectionsViaSymbols=NO
         AC_MSG_RESULT(no)])

    dnl ** check for .ident assembler directive

    AC_MSG_CHECKING(whether your assembler supports .ident directive)
    dnl See Note [autoconf assembler checks and -flto]
    AC_LINK_IFELSE(
        [AC_LANG_PROGRAM([__asm__ (".ident \"GHC x.y.z\"");], [])],
        [AC_MSG_RESULT(yes)
         TargetHasIdentDirective=YES],
        [AC_MSG_RESULT(no)
         TargetHasIdentDirective=NO])

    dnl *** check for GNU non-executable stack note support (ELF only)
    dnl     (.section .note.GNU-stack,"",@progbits)

    dnl This test doesn't work with "gcc -g" in gcc 4.4 (GHC trac #3889:
    dnl     Error: can't resolve `.note.GNU-stack' {.note.GNU-stack section} - `.Ltext0' {.text section}
    dnl so we empty CFLAGS while running this test
    CFLAGS2="$CFLAGS"
    CFLAGS=
    case $TargetArch in
      arm)
        dnl See #13937.
        progbits="%progbits"
        ;;
      *)
        progbits="@progbits"
        ;;
    esac
    AC_MSG_CHECKING(for GNU non-executable stack support)
    dnl See Note [autoconf assembler checks and -flto]
    AC_LINK_IFELSE(
       dnl the `main` function is placed after the .note.GNU-stack directive
       dnl so we need to ensure that the active segment is correctly set,
       dnl otherwise `main` will be placed in the wrong segment.
        [AC_LANG_PROGRAM([
           __asm__ (".section .note.GNU-stack,\"\",$progbits");
           __asm__ (".section .text");
         ], [0])],
        [AC_MSG_RESULT(yes)
         TargetHasGnuNonexecStack=YES],
        [AC_MSG_RESULT(no)
         TargetHasGnuNonexecStack=NO])
    CFLAGS="$CFLAGS2"

    checkArch "$BuildArch" "HaskellBuildArch"
    checkVendor "$BuildVendor"
    checkOS "$BuildOS" ""

    checkArch "$HostArch" "HaskellHostArch"
    checkVendor "$HostVendor"
    checkOS "$HostOS" "HaskellHostOs"

    checkArch "$TargetArch" "HaskellTargetArch"
    checkVendor "$TargetVendor"
    checkOS "$TargetOS" "HaskellTargetOs"

    AC_SUBST(HaskellHostArch)
    AC_SUBST(HaskellHostOs)
    AC_SUBST(HaskellTargetArch)
    AC_SUBST(HaskellTargetOs)
    AC_SUBST(TargetHasSubsectionsViaSymbols)
    AC_SUBST(TargetHasIdentDirective)
    AC_SUBST(TargetHasGnuNonexecStack)
])
m4trace:m4/fptools_set_platform_vars.m4:4: -1- AC_DEFUN([FPTOOLS_SET_PLATFORM_VARS], [
    # If no argument was given for a configuration variable, then discard
    # the guessed canonical system and use the configuration of the
    # bootstrapping ghc. If an argument was given, map it from gnu format
    # to ghc format.
    #
    # For why we do it this way, see: #3637, #1717, #2951
    #
    # In bindists, we haven't called AC_CANONICAL_{BUILD,HOST,TARGET}
    # so this justs uses $bootstrap_target.

    if test "$build_alias" = ""
    then
        if test "$bootstrap_target" != ""
        then
            build=$bootstrap_target
            echo "Build platform inferred as: $build"
        else
            echo "Can't work out build platform"
            exit 1
        fi

        BuildArch=`echo "$build" | sed 's/-.*//'`
        BuildVendor=`echo "$build" | sed -e 's/.*-\(.*\)-.*/\1/'`
        BuildOS=`echo "$build" | sed 's/.*-//'`
    else
        GHC_CONVERT_CPU([$build_cpu], [BuildArch])
        GHC_CONVERT_VENDOR([$build_vendor], [BuildVendor])
        GHC_CONVERT_OS([$build_os], [$BuildArch], [BuildOS])
    fi

    if test "$host_alias" = ""
    then
        if test "$bootstrap_target" != ""
        then
            host=$bootstrap_target
            echo "Host platform inferred as: $host"
        else
            echo "Can't work out host platform"
            exit 1
        fi

        HostArch=`echo "$host" | sed 's/-.*//'`
        HostVendor=`echo "$host" | sed -e 's/.*-\(.*\)-.*/\1/'`
        HostOS=`echo "$host" | sed 's/.*-//'`
    else
        GHC_CONVERT_CPU([$host_cpu], [HostArch])
        GHC_CONVERT_VENDOR([$host_vendor], [HostVendor])
        GHC_CONVERT_OS([$host_os], [$HostArch], [HostOS])
    fi

    if test "$target_alias" = ""
    then
        if test "$host_alias" != ""
        then
            GHC_CONVERT_CPU([$host_cpu], [TargetArch])
            GHC_CONVERT_VENDOR([$host_vendor], [TargetVendor])
            GHC_CONVERT_OS([$host_os], [$TargetArch],[TargetOS])
        else
            if test "$bootstrap_target" != ""
            then
                target=$bootstrap_target
                echo "Target platform inferred as: $target"
            else
                echo "Can't work out target platform"
                exit 1
            fi

            TargetArch=`echo "$target" | sed 's/-.*//'`
            TargetVendor=`echo "$target" | sed -e 's/.*-\(.*\)-.*/\1/'`
            TargetOS=`echo "$target" | sed 's/.*-//'`
        fi
    else
        GHC_CONVERT_CPU([$target_cpu], [TargetArch])
        GHC_CONVERT_VENDOR([$target_vendor], [TargetVendor])
        GHC_CONVERT_OS([$target_os], [$TargetArch], [TargetOS])
    fi

    GHC_LLVM_TARGET([$target],[$target_cpu],[$target_vendor],[$target_os],[LlvmTarget])

    GHC_SELECT_FILE_EXTENSIONS([$host], [exeext_host], [soext_host])
    GHC_SELECT_FILE_EXTENSIONS([$target], [exeext_target], [soext_target])
    windows=NO
    case $host in
    *-unknown-mingw32)
        windows=YES
        ;;
    esac

    BuildPlatform="$BuildArch-$BuildVendor-$BuildOS"
    BuildPlatform_CPP=`echo "$BuildPlatform" | sed -e 's/\./_/g' -e 's/-/_/g'`
    BuildArch_CPP=`    echo "$BuildArch"     | sed -e 's/\./_/g' -e 's/-/_/g'`
    BuildVendor_CPP=`  echo "$BuildVendor"   | sed -e 's/\./_/g' -e 's/-/_/g'`
    BuildOS_CPP=`      echo "$BuildOS"       | sed -e 's/\./_/g' -e 's/-/_/g'`

    HostPlatform="$HostArch-$HostVendor-$HostOS"
    HostPlatform_CPP=`echo "$HostPlatform" | sed -e 's/\./_/g' -e 's/-/_/g'`
    HostArch_CPP=`    echo "$HostArch"     | sed -e 's/\./_/g' -e 's/-/_/g'`
    HostVendor_CPP=`  echo "$HostVendor"   | sed -e 's/\./_/g' -e 's/-/_/g'`
    HostOS_CPP=`      echo "$HostOS"       | sed -e 's/\./_/g' -e 's/-/_/g'`

    TargetPlatform="$TargetArch-$TargetVendor-$TargetOS"
    TargetPlatform_CPP=`echo "$TargetPlatform" | sed -e 's/\./_/g' -e 's/-/_/g'`
    TargetArch_CPP=`    echo "$TargetArch"     | sed -e 's/\./_/g' -e 's/-/_/g'`
    TargetVendor_CPP=`  echo "$TargetVendor"   | sed -e 's/\./_/g' -e 's/-/_/g'`
    TargetOS_CPP=`      echo "$TargetOS"       | sed -e 's/\./_/g' -e 's/-/_/g'`

    # we intend to pass trough --targets to llvm as is.
    LLVMTarget_CPP=`    echo "$LlvmTarget"`

    echo "GHC build  : $BuildPlatform"
    echo "GHC host   : $HostPlatform"
    echo "GHC target : $TargetPlatform"
    echo "LLVM target: $LlvmTarget"

    AC_SUBST(BuildPlatform)
    AC_SUBST(HostPlatform)
    AC_SUBST(TargetPlatform)
    AC_SUBST(HostPlatform_CPP)
    AC_SUBST(BuildPlatform_CPP)
    AC_SUBST(TargetPlatform_CPP)

    AC_SUBST(HostArch_CPP)
    AC_SUBST(BuildArch_CPP)
    AC_SUBST(TargetArch_CPP)

    AC_SUBST(HostOS_CPP)
    AC_SUBST(BuildOS_CPP)
    AC_SUBST(TargetOS_CPP)
    AC_SUBST(LLVMTarget_CPP)

    AC_SUBST(HostVendor_CPP)
    AC_SUBST(BuildVendor_CPP)
    AC_SUBST(TargetVendor_CPP)

    AC_SUBST(exeext_host)
    AC_SUBST(exeext_target)
    AC_SUBST(soext_host)
    AC_SUBST(soext_target)
])
m4trace:m4/fptools_write_file.m4:4: -1- AC_DEFUN([FPTOOLS_WRITE_FILE], [
cat >$1 <<ACEOF
$2
ACEOF
])
m4trace:m4/get_arm_isa.m4:4: -1- AC_DEFUN([GET_ARM_ISA], [
    AC_COMPILE_IFELSE([
        AC_LANG_PROGRAM(
            [],
            [#if defined(__ARM_ARCH_2__)  || \
                 defined(__ARM_ARCH_3__)  || \
                 defined(__ARM_ARCH_3M__) || \
                 defined(__ARM_ARCH_4__)  || \
                 defined(__ARM_ARCH_4T__) || \
                 defined(__ARM_ARCH_5__)  || \
                 defined(__ARM_ARCH_5T__) || \
                 defined(__ARM_ARCH_5E__) || \
                 defined(__ARM_ARCH_5TE__)
                 return 0;
             #else
                 not pre arm v6
             #endif]
        )],
        [AC_DEFINE(arm_HOST_ARCH_PRE_ARMv6, 1, [ARM pre v6])
         AC_DEFINE(arm_HOST_ARCH_PRE_ARMv7, 1, [ARM pre v7])
         changequote(, )dnl
         ARM_ISA=ARMv5
         ARM_ISA_EXT="[]"
         changequote([, ])dnl
        ],
        [
            AC_COMPILE_IFELSE([
                AC_LANG_PROGRAM(
                    [],
                    [#if defined(__ARM_ARCH_6__)   || \
                         defined(__ARM_ARCH_6J__)  || \
                         defined(__ARM_ARCH_6T2__) || \
                         defined(__ARM_ARCH_6Z__)  || \
                         defined(__ARM_ARCH_6ZK__) || \
                         defined(__ARM_ARCH_6K__)  || \
                         defined(__ARM_ARCH_6KZ__) || \
                         defined(__ARM_ARCH_6M__)
                         return 0;
                     #else
                         not pre arm v7
                     #endif]
                )],
                [AC_DEFINE(arm_HOST_ARCH_PRE_ARMv7, 1, [ARM pre v7])
                 if grep -q Raspbian /etc/issue && uname -m | grep -q armv7; then
                   # Raspbian unfortunately makes some extremely questionable
                   # packaging decisions, configuring gcc to compile for ARMv6
                   # despite the fact that the RPi4 is ARMv8. As ARMv8 doesn't
                   # support all instructions supported by ARMv6 this can
                   # break. Work around this by checking uname to verify
                   # that we aren't running on armv7.
                   # See #17856.
                   AC_MSG_NOTICE([Found compiler which claims to target ARMv6 running on ARMv7, assuming this is ARMv7 on Raspbian (see T17856)])
                   ARM_ISA=ARMv7
                   changequote(, )dnl
                   ARM_ISA_EXT="[VFPv2]"
                   changequote([, ])dnl
                 else
                   ARM_ISA=ARMv6
                   AC_COMPILE_IFELSE([
                          AC_LANG_PROGRAM(
                                  [],
                                  [#if defined(__VFP_FP__)
                                       return 0;
                                  #else
                                       no vfp
                                  #endif]
                          )],
                          [changequote(, )dnl
                           ARM_ISA_EXT="[VFPv2]"
                           changequote([, ])dnl
                          ],
                          [changequote(, )dnl
                           ARM_ISA_EXT="[]"
                           changequote([, ])dnl
                          ]
                  )
                fi],
                [changequote(, )dnl
                 ARM_ISA=ARMv7
                 ARM_ISA_EXT="[VFPv3,NEON]"
                 changequote([, ])dnl
                ])
        ])

        AC_COMPILE_IFELSE(
               [AC_LANG_PROGRAM(
                       [],
                       [#if defined(__SOFTFP__)
                            return 0;
                       #else
                            not softfp
                       #endif]
               )],
               [changequote(, )dnl
                ARM_ABI="SOFT"
                changequote([, ])dnl
               ],
               [AC_COMPILE_IFELSE(
                    [AC_LANG_PROGRAM(
                       [],
                       [#if defined(__ARM_PCS_VFP)
                            return 0;
                       #else
                            no hard float ABI
                       #endif]
                    )],
                    [ARM_ABI="HARD"],
                    [ARM_ABI="SOFTFP"]
               )]
        )

        AC_SUBST(ARM_ISA)
])
m4trace:m4/ghc_convert_cpu.m4:6: -1- AC_DEFUN([GHC_CONVERT_CPU], [
case "$1" in
  aarch64*|arm64*)
    $2="aarch64"
    ;;
  alpha*)
    $2="alpha"
    ;;
  arm*)
    $2="arm"
    ;;
  hppa1.1*)
    $2="hppa1_1"
    ;;
  hppa*)
    $2="hppa"
    ;;
  i386|i486|i586|i686)
    $2="i386"
    ;;
  ia64)
    $2="ia64"
    ;;
  m68k*)
    $2="m68k"
    ;;
  mipseb*)
    $2="mipseb"
    ;;
  mipsel*)
    $2="mipsel"
    ;;
  mips*)
    $2="mips"
    ;;
  nios2)
    $2="nios2"
    ;;
  powerpc64le*)
    $2="powerpc64le"
    ;;
  powerpc64*)
    $2="powerpc64"
    ;;
  powerpc*)
    $2="powerpc"
    ;;
  riscv64*)
    $2="riscv64"
    ;;
  riscv|riscv32*)
    $2="riscv32"
    ;;
  rs6000)
    $2="rs6000"
    ;;
  s390x*)
    $2="s390x"
    ;;
  s390*)
    $2="s390"
    ;;
  sh4)
    $2="sh4"
    ;;
  sparc64*)
    $2="sparc64"
    ;;
  sparc*)
    $2="sparc"
    ;;
  vax)
    $2="vax"
    ;;
  x86_64|amd64)
    $2="x86_64"
    ;;
  *)
    echo "Unknown CPU $1"
    exit 1
    ;;
  esac
])
m4trace:m4/ghc_convert_os.m4:4: -1- AC_DEFUN([GHC_CONVERT_OS], [
    case "$1" in
      gnu*) # e.g. i686-unknown-gnu0.9
        $3="gnu"
        ;;
      # watchos and tvos are ios variants as of May 2017.
      ios|watchos|tvos)
        $3="ios"
        ;;
      linux-android*)
        $3="linux-android"
        ;;
      linux-*|linux)
        $3="linux"
        ;;
      netbsd*)
        $3="netbsd"
        ;;
      openbsd*)
        $3="openbsd"
        ;;
      # As far as I'm aware, none of these have relevant variants
      freebsd|dragonfly|hpux|linuxaout|kfreebsdgnu|freebsd2|mingw32|darwin|nextstep2|nextstep3|sunos4|ultrix|haiku)
        $3="$1"
        ;;
      msys)
        AC_MSG_ERROR([Building GHC using the msys toolchain is not supported; please use mingw instead. Perhaps you need to set 'MSYSTEM=MINGW64 or MINGW32?'])
        ;;
      aix*) # e.g. powerpc-ibm-aix7.1.3.0
        $3="aix"
        ;;
      darwin*) # e.g. aarch64-apple-darwin14
        $3="darwin"
        ;;
      solaris2*)
        $3="solaris2"
        ;;
      freebsd*) # like i686-gentoo-freebsd7
                #      i686-gentoo-freebsd8
                #      i686-gentoo-freebsd8.2
        $3="freebsd"
        ;;
      nto-qnx*)
        $3="nto-qnx"
        ;;
      *)
        echo "Unknown OS $1"
        exit 1
        ;;
      esac
])
m4trace:m4/ghc_convert_vendor.m4:4: -1- AC_DEFUN([GHC_CONVERT_VENDOR], [
  case "$1" in
  pc|gentoo|w64) # like i686-pc-linux-gnu, i686-gentoo-freebsd8, x86_64-w64-mingw32
    $2="unknown"
    ;;
  softfloat) # like armv5tel-softfloat-linux-gnueabi
    $2="unknown"
    ;;
  hardfloat) # like armv7a-hardfloat-linux-gnueabi
    $2="unknown"
    ;;
  *)
    #pass thru by default
    $2="$1"
    ;;
  esac
])
m4trace:m4/ghc_llvm_target.m4:4: -1- AC_DEFUN([GHC_LLVM_TARGET], [
  llvm_target_cpu=$2
  case "$1" in
    *-freebsd*-gnueabihf)
      llvm_target_vendor="unknown"
      llvm_target_os="freebsd-gnueabihf"
      ;;
    *-hardfloat-*eabi)
      llvm_target_vendor="unknown"
      llvm_target_os="$4""hf"
      ;;
    *-mingw32|*-mingw64|*-msys)
      llvm_target_vendor="unknown"
      llvm_target_os="windows"
      ;;
    # apple is a bit about their naming scheme for
    # aarch64; and clang on macOS doesn't know that
    # aarch64 would be arm64. So for LLVM we'll need
    # to call it arm64; while we'll refer to it internally
    # as aarch64 for consistency and sanity.
    aarch64-apple-*|arm64-apple-*)
      llvm_target_cpu="arm64"
      GHC_CONVERT_VENDOR([$3],[llvm_target_vendor])
      GHC_CONVERT_OS([$4],[$2],[llvm_target_os])
      ;;
    *)
      GHC_CONVERT_VENDOR([$3],[llvm_target_vendor])
      GHC_CONVERT_OS([$4],[$2],[llvm_target_os])
      ;;
  esac
  case "$4" in
      # retain any android and gnueabi linux flavours
      # for the LLVM Target. Otherwise these would be
      # turned into just `-linux` and fail to be found
      # in the `llvm-targets` file.
      *-android*|*-gnueabi*|*-musleabi*)
        GHC_CONVERT_VENDOR([$3],[llvm_target_vendor])
        llvm_target_os="$4"
        ;;
  esac
  $5="$llvm_target_cpu-$llvm_target_vendor-$llvm_target_os"
])
m4trace:m4/ghc_select_file_extensions.m4:1: -1- AC_DEFUN([GHC_SELECT_FILE_EXTENSIONS], [
    $2=''
    $3='.so'
    case $1 in
    *-unknown-cygwin32)
        AC_MSG_WARN([GHC does not support the Cygwin target at the moment])
        AC_MSG_WARN([I'm assuming you wanted to build for i386-unknown-mingw32])
        exit 1
        ;;
    # examples: i386-unknown-mingw32, i686-w64-mingw32, x86_64-w64-mingw32
    *-mingw32)
        windows=YES
        $2='.exe'
        $3='.dll'
        ;;
    # apple platform uses .dylib (macOS, iOS, ...)
    *-apple-*)
        $3='.dylib'
        ;;
    esac
])
m4trace:m4/library_version.m4:6: -1- AC_DEFUN([LIBRARY_VERSION], [
cabal_file=m4_default([$2],[$1/$1.cabal])
LIBRARY_[]translit([$1], [-], [_])[]_VERSION=`grep -i "^version:" libraries/${cabal_file} | sed "s/.* //"`
AC_SUBST(LIBRARY_[]translit([$1], [-], [_])[]_VERSION)
])
m4trace:m4/maybe_override_stage0.m4:1: -1- AC_DEFUN([MAYBE_OVERRIDE_STAGE0], [
  if test ! -z "$With_$1" -a "$CrossCompiling" != "YES"; then
      AC_MSG_NOTICE([Not cross-compiling, so --with-$1 also sets $2])
      $2=$With_$1
  fi
])
m4trace:m4/xcode_version.m4:4: -1- AC_DEFUN([XCODE_VERSION], [
    if test "$TargetVendor_CPP" = "apple"
    then
        AC_MSG_CHECKING(Xcode version)
        XcodeVersion=`(xcode-select -p > /dev/null 2>&1 && xcodebuild -version) | grep Xcode | sed "s/Xcode //"`
        # Old Xcode versions don't actually give the Xcode version
        if test "$XcodeVersion" = ""
        then
            AC_MSG_RESULT(not found (too old?))
            XcodeVersion1=0
            XcodeVersion2=0
        else
            AC_MSG_RESULT($XcodeVersion)
            XcodeVersion1=`echo "$XcodeVersion" | sed 's/\..*//'`
            changequote(, )dnl
            XcodeVersion2=`echo "$XcodeVersion" | sed 's/[^.]*\.\([^.]*\).*/\1/'`
            changequote([, ])dnl
            AC_MSG_NOTICE(Xcode version component 1: $XcodeVersion1)
            AC_MSG_NOTICE(Xcode version component 2: $XcodeVersion2)
        fi
    fi
])
m4trace:configure.ac:16: -1- m4_pattern_forbid([^_?A[CHUM]_])
m4trace:configure.ac:16: -1- m4_pattern_forbid([_AC_])
m4trace:configure.ac:16: -1- m4_pattern_forbid([^LIBOBJS$], [do not use LIBOBJS directly, use AC_LIBOBJ (see section `AC_LIBOBJ vs LIBOBJS'])
m4trace:configure.ac:16: -1- m4_pattern_allow([^AS_FLAGS$])
m4trace:configure.ac:16: -1- m4_pattern_forbid([^_?m4_])
m4trace:configure.ac:16: -1- m4_pattern_forbid([^dnl$])
m4trace:configure.ac:16: -1- m4_pattern_forbid([^_?AS_])
m4trace:configure.ac:16: -1- m4_pattern_allow([^SHELL$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^PATH_SEPARATOR$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^PACKAGE_NAME$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^PACKAGE_TARNAME$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^PACKAGE_VERSION$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^PACKAGE_STRING$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^PACKAGE_BUGREPORT$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^PACKAGE_URL$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^exec_prefix$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^prefix$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^program_transform_name$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^bindir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^sbindir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^libexecdir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^datarootdir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^datadir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^sysconfdir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^sharedstatedir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^localstatedir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^runstatedir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^includedir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^oldincludedir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^docdir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^infodir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^htmldir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^dvidir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^pdfdir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^psdir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^libdir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^localedir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^mandir$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^PACKAGE_NAME$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^PACKAGE_TARNAME$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^PACKAGE_VERSION$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^PACKAGE_STRING$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^PACKAGE_BUGREPORT$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^PACKAGE_URL$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^DEFS$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^ECHO_C$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^ECHO_N$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^ECHO_T$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^LIBS$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^build_alias$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^host_alias$])
m4trace:configure.ac:16: -1- m4_pattern_allow([^target_alias$])
m4trace:configure.ac:20: -1- AC_CONFIG_MACRO_DIR([m4])
m4trace:configure.ac:20: -1- AC_CONFIG_MACRO_DIR_TRACE([m4])
m4trace:configure.ac:48: -1- FP_PROG_FIND
m4trace:configure.ac:48: -1- m4_pattern_allow([^fp_prog_find$])
m4trace:configure.ac:48: -1- FP_CHECK_PROG([FindCmd], [find], [], [], [$fp_prog_find])
m4trace:configure.ac:48: -1- m4_pattern_allow([^FindCmd$])
m4trace:configure.ac:48: -1- m4_pattern_allow([^FindCmd$])
m4trace:configure.ac:49: -1- FP_PROG_SORT
m4trace:configure.ac:49: -1- m4_pattern_allow([^fp_prog_sort$])
m4trace:configure.ac:49: -1- FP_CHECK_PROG([SortCmd], [sort], [], [], [$fp_prog_sort])
m4trace:configure.ac:49: -1- m4_pattern_allow([^SortCmd$])
m4trace:configure.ac:49: -1- m4_pattern_allow([^SortCmd$])
m4trace:configure.ac:52: -1- FP_SETUP_PROJECT_VERSION
m4trace:configure.ac:52: -1- m4_pattern_allow([^ProjectName$])
m4trace:configure.ac:52: -1- m4_pattern_allow([^ProjectVersion$])
m4trace:configure.ac:52: -1- m4_pattern_allow([^ProjectGitCommitId$])
m4trace:configure.ac:52: -1- m4_pattern_allow([^ProjectVersionInt$])
m4trace:configure.ac:52: -1- m4_pattern_allow([^ProjectPatchLevel1$])
m4trace:configure.ac:52: -1- m4_pattern_allow([^ProjectPatchLevel2$])
m4trace:configure.ac:52: -1- m4_pattern_allow([^ProjectPatchLevel$])
m4trace:configure.ac:52: -1- m4_pattern_allow([^ProjectVersionMunged$])
m4trace:configure.ac:55: -1- m4_pattern_allow([^release$])
m4trace:configure.ac:73: -1- _m4_warn([obsolete], [The macro `AC_CONFIG_HEADER' is obsolete.
You should run autoupdate.], [./lib/autoconf/status.m4:719: AC_CONFIG_HEADER is expanded from...
configure.ac:73: the top level])
m4trace:configure.ac:92: -1- m4_pattern_allow([^GHC$])
m4trace:configure.ac:93: -1- m4_pattern_allow([^GHC$])
m4trace:configure.ac:97: -1- m4_pattern_allow([^WithGhc$])
m4trace:configure.ac:132: -1- m4_pattern_allow([^DEFAULT_NATIVE_IO_MANAGER$])
m4trace:configure.ac:139: -1- m4_pattern_allow([^CC_STAGE0$])
m4trace:configure.ac:140: -1- m4_pattern_allow([^LD_STAGE0$])
m4trace:configure.ac:141: -1- m4_pattern_allow([^AR_STAGE0$])
m4trace:configure.ac:144: -1- m4_pattern_allow([^RTS_WAYS_STAGE0$])
m4trace:configure.ac:147: -1- FPTOOLS_GHC_VERSION([GhcVersion], [GhcMajVersion], [GhcMinVersion], [GhcPatchLevel])
m4trace:configure.ac:147: -1- FPTOOLS_NOCACHE_CHECK([version of ghc], [fptools_version_of_ghc], ["${WithGhc-ghc}" --version > conftestghc 2>&1
  cat conftestghc >&AS_MESSAGE_LOG_FD
#Useless Use Of cat award...
  fptools_version_of_ghc=`cat conftestghc | sed -n -e 's/, patchlevel *\([[0-9]]\)/.\1/;s/.* version \([[0-9]][[0-9.]]*\).*/\1/p'`
  rm -fr conftest*
  if test "[$]fptools_version_of_ghc" = ""
  then
    fptools_version_of_ghc='unknown'
  fi
fptools_version_of_ghc[_major]=`echo [$]fptools_version_of_ghc | sed -e 's/^\([[0-9]]\).*/\1/'`
fptools_version_of_ghc[_minor]=`echo [$]fptools_version_of_ghc | sed -e 's/^[[0-9]]\.\([[0-9]]*\).*/\1/'`
fptools_version_of_ghc[_pl]=`echo [$]fptools_version_of_ghc | sed -n -e 's/^[[0-9]]\.[[0-9]]*\.\([[0-9]]*\)/\1/p'`
#
if test "[$]fptools_version_of_ghc[_pl]" = ""
then
  fptools_version_of_ghc[_all]="[$]fptools_version_of_ghc[_major].[$]fptools_version_of_ghc[_minor]"
  fptools_version_of_ghc[_pl]="0"
else
  fptools_version_of_ghc[_all]="[$]fptools_version_of_ghc[_major].[$]fptools_version_of_ghc[_minor].[$]fptools_version_of_ghc[_pl]"
fi
#
ifelse(4, [1], [dnl
[GhcVersion]="[$]fptools_version_of_ghc[_all]"
], 4, [2], [dnl
[GhcVersion]="[$]fptools_version_of_ghc[_major]"
[GhcMajVersion]="[$]fptools_version_of_ghc[_minor]"
], 4, [3], [dnl
[GhcVersion]="[$]fptools_version_of_ghc[_major]"
[GhcMajVersion]="[$]fptools_version_of_ghc[_minor]"
[GhcMinVersion]="[$]fptools_version_of_ghc[_pl]"
], 4, [4], [dnl
[GhcVersion]="[$]fptools_version_of_ghc[_all]"
[GhcMajVersion]="[$]fptools_version_of_ghc[_major]"
[GhcMinVersion]="[$]fptools_version_of_ghc[_minor]"
[GhcPatchLevel]="[$]fptools_version_of_ghc[_pl]"
])
])
m4trace:configure.ac:153: -1- m4_pattern_allow([^GhcVersion$])
m4trace:configure.ac:154: -1- m4_pattern_allow([^GhcMajVersion$])
m4trace:configure.ac:155: -1- m4_pattern_allow([^GhcMinVersion$])
m4trace:configure.ac:156: -1- m4_pattern_allow([^GhcPatchLevel$])
m4trace:configure.ac:162: -1- BOOTSTRAPPING_GHC_INFO_FIELD([CC_STAGE0], [C compiler command])
m4trace:configure.ac:162: -1- m4_pattern_allow([^CC_STAGE0$])
m4trace:configure.ac:166: -1- BOOTSTRAPPING_GHC_INFO_FIELD([LD_STAGE0], [ld command])
m4trace:configure.ac:166: -1- m4_pattern_allow([^LD_STAGE0$])
m4trace:configure.ac:169: -1- BOOTSTRAPPING_GHC_INFO_FIELD([AR_STAGE0], [ar command])
m4trace:configure.ac:169: -1- m4_pattern_allow([^AR_STAGE0$])
m4trace:configure.ac:171: -1- BOOTSTRAPPING_GHC_INFO_FIELD([AR_OPTS_STAGE0], [ar flags])
m4trace:configure.ac:171: -1- m4_pattern_allow([^AR_OPTS_STAGE0$])
m4trace:configure.ac:172: -1- BOOTSTRAPPING_GHC_INFO_FIELD([ArSupportsAtFile_STAGE0], [ar supports at file])
m4trace:configure.ac:172: -1- m4_pattern_allow([^ArSupportsAtFile_STAGE0$])
m4trace:configure.ac:173: -1- BOOTSTRAPPING_GHC_INFO_FIELD([SUPPORT_SMP_STAGE0], [Support SMP])
m4trace:configure.ac:173: -1- m4_pattern_allow([^SUPPORT_SMP_STAGE0$])
m4trace:configure.ac:174: -1- BOOTSTRAPPING_GHC_INFO_FIELD([RTS_WAYS_STAGE0], [RTS ways])
m4trace:configure.ac:174: -1- m4_pattern_allow([^RTS_WAYS_STAGE0$])
m4trace:configure.ac:184: -1- m4_pattern_allow([^GhcThreadedRts$])
m4trace:configure.ac:186: -1- m4_pattern_allow([^GhcThreadedRts$])
m4trace:configure.ac:195: -1- FP_COMPARE_VERSIONS([$GhcVersion], [-lt], [8.10], [AC_MSG_ERROR([GHC version 8.10 or later is required to compile GHC.])])
m4trace:configure.ac:227: -1- m4_pattern_allow([^WithGhc$])
m4trace:configure.ac:250: -1- m4_pattern_allow([^build$])
m4trace:configure.ac:250: -1- m4_pattern_allow([^build_cpu$])
m4trace:configure.ac:250: -1- m4_pattern_allow([^build_vendor$])
m4trace:configure.ac:250: -1- m4_pattern_allow([^build_os$])
m4trace:configure.ac:251: -1- m4_pattern_allow([^host$])
m4trace:configure.ac:251: -1- m4_pattern_allow([^host_cpu$])
m4trace:configure.ac:251: -1- m4_pattern_allow([^host_vendor$])
m4trace:configure.ac:251: -1- m4_pattern_allow([^host_os$])
m4trace:configure.ac:252: -1- m4_pattern_allow([^target$])
m4trace:configure.ac:252: -1- m4_pattern_allow([^target_cpu$])
m4trace:configure.ac:252: -1- m4_pattern_allow([^target_vendor$])
m4trace:configure.ac:252: -1- m4_pattern_allow([^target_os$])
m4trace:configure.ac:254: -1- FPTOOLS_SET_PLATFORM_VARS
m4trace:configure.ac:254: -1- GHC_CONVERT_CPU([$build_cpu], [BuildArch])
m4trace:configure.ac:254: -1- GHC_CONVERT_VENDOR([$build_vendor], [BuildVendor])
m4trace:configure.ac:254: -1- GHC_CONVERT_OS([$build_os], [$BuildArch], [BuildOS])
m4trace:configure.ac:254: -1- GHC_CONVERT_CPU([$host_cpu], [HostArch])
m4trace:configure.ac:254: -1- GHC_CONVERT_VENDOR([$host_vendor], [HostVendor])
m4trace:configure.ac:254: -1- GHC_CONVERT_OS([$host_os], [$HostArch], [HostOS])
m4trace:configure.ac:254: -1- GHC_CONVERT_CPU([$host_cpu], [TargetArch])
m4trace:configure.ac:254: -1- GHC_CONVERT_VENDOR([$host_vendor], [TargetVendor])
m4trace:configure.ac:254: -1- GHC_CONVERT_OS([$host_os], [$TargetArch], [TargetOS])
m4trace:configure.ac:254: -1- GHC_CONVERT_CPU([$target_cpu], [TargetArch])
m4trace:configure.ac:254: -1- GHC_CONVERT_VENDOR([$target_vendor], [TargetVendor])
m4trace:configure.ac:254: -1- GHC_CONVERT_OS([$target_os], [$TargetArch], [TargetOS])
m4trace:configure.ac:254: -1- GHC_LLVM_TARGET([$target], [$target_cpu], [$target_vendor], [$target_os], [LlvmTarget])
m4trace:configure.ac:254: -1- GHC_CONVERT_VENDOR([$target_vendor], [llvm_target_vendor])
m4trace:configure.ac:254: -1- GHC_CONVERT_OS([$target_os], [$target_cpu], [llvm_target_os])
m4trace:configure.ac:254: -1- GHC_CONVERT_VENDOR([$target_vendor], [llvm_target_vendor])
m4trace:configure.ac:254: -1- GHC_CONVERT_OS([$target_os], [$target_cpu], [llvm_target_os])
m4trace:configure.ac:254: -1- GHC_CONVERT_VENDOR([$target_vendor], [llvm_target_vendor])
m4trace:configure.ac:254: -1- GHC_SELECT_FILE_EXTENSIONS([$host], [exeext_host], [soext_host])
m4trace:configure.ac:254: -1- GHC_SELECT_FILE_EXTENSIONS([$target], [exeext_target], [soext_target])
m4trace:configure.ac:254: -1- m4_pattern_allow([^BuildPlatform$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^HostPlatform$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^TargetPlatform$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^HostPlatform_CPP$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^BuildPlatform_CPP$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^TargetPlatform_CPP$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^HostArch_CPP$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^BuildArch_CPP$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^TargetArch_CPP$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^HostOS_CPP$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^BuildOS_CPP$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^TargetOS_CPP$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^LLVMTarget_CPP$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^HostVendor_CPP$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^BuildVendor_CPP$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^TargetVendor_CPP$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^exeext_host$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^exeext_target$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^soext_host$])
m4trace:configure.ac:254: -1- m4_pattern_allow([^soext_target$])
m4trace:configure.ac:256: -1- FP_PROG_SH
m4trace:configure.ac:256: -1- m4_pattern_allow([^SH$])
m4trace:configure.ac:256: -1- m4_pattern_allow([^SH$])
m4trace:configure.ac:256: -1- m4_pattern_allow([^SH$])
m4trace:configure.ac:283: -1- m4_pattern_allow([^SOLARIS_BROKEN_SHLD$])
m4trace:configure.ac:299: -1- FP_DEFAULT_CHOICE_OVERRIDE_CHECK([unregisterised], [unregisterised], [registerised], [Unregisterised], [Build a toolchain with the unregisterised ABI (disabled by default on platforms with registerised support)], [NO], [YES], [no])
m4trace:configure.ac:308: -1- m4_pattern_allow([^Unregisterised$])
m4trace:configure.ac:340: -1- FP_DEFAULT_CHOICE_OVERRIDE_CHECK([tables-next-to-code], [tables next to code], [tables apart from code], [TablesNextToCode], [Build a tool chain with info tables laid out next to code (enabled by default when using the registerised ABI, on platforms that support it)])
m4trace:configure.ac:347: -1- m4_pattern_allow([^TABLES_NEXT_TO_CODE$])
m4trace:configure.ac:349: -1- m4_pattern_allow([^TablesNextToCode$])
m4trace:configure.ac:361: -1- m4_pattern_allow([^TargetHasRTSLinker$])
m4trace:configure.ac:364: -1- FP_FIND_ROOT
m4trace:configure.ac:364: -1- m4_pattern_allow([^hardtop$])
m4trace:configure.ac:463: -1- m4_pattern_allow([^Genlib$])
m4trace:configure.ac:474: -1- m4_pattern_allow([^CC$])
m4trace:configure.ac:475: -1- m4_pattern_allow([^NM$])
m4trace:configure.ac:476: -1- m4_pattern_allow([^LD$])
m4trace:configure.ac:477: -1- m4_pattern_allow([^AR$])
m4trace:configure.ac:478: -1- m4_pattern_allow([^RANLIB$])
m4trace:configure.ac:479: -1- m4_pattern_allow([^OBJDUMP$])
m4trace:configure.ac:480: -1- m4_pattern_allow([^DllWrap$])
m4trace:configure.ac:481: -1- m4_pattern_allow([^Windres$])
m4trace:configure.ac:482: -1- m4_pattern_allow([^Genlib$])
m4trace:configure.ac:484: -1- m4_pattern_allow([^Windres$])
m4trace:configure.ac:485: -1- m4_pattern_allow([^DllWrap$])
m4trace:configure.ac:486: -1- m4_pattern_allow([^OBJDUMP$])
m4trace:configure.ac:501: -1- m4_pattern_allow([^DllWrapCmd$])
m4trace:configure.ac:502: -1- m4_pattern_allow([^WindresCmd$])
m4trace:configure.ac:503: -1- m4_pattern_allow([^GenlibCmd$])
m4trace:configure.ac:504: -1- m4_pattern_allow([^HAVE_GENLIB$])
m4trace:configure.ac:506: -1- FP_ICONV
m4trace:configure.ac:506: -1- m4_pattern_allow([^ICONV_INCLUDE_DIRS$])
m4trace:configure.ac:506: -1- m4_pattern_allow([^ICONV_LIB_DIRS$])
m4trace:configure.ac:507: -1- FP_GMP
m4trace:configure.ac:507: -1- m4_pattern_allow([^GMP_INCLUDE_DIRS$])
m4trace:configure.ac:507: -1- m4_pattern_allow([^GMP_LIB_DIRS$])
m4trace:configure.ac:507: -1- m4_pattern_allow([^GMP_FORCE_INTREE$])
m4trace:configure.ac:507: -1- m4_pattern_allow([^GMP_PREFER_FRAMEWORK$])
m4trace:configure.ac:508: -1- FP_CURSES
m4trace:configure.ac:508: -1- m4_pattern_allow([^CURSES_INCLUDE_DIRS$])
m4trace:configure.ac:508: -1- m4_pattern_allow([^CURSES_LIB_DIRS$])
m4trace:configure.ac:516: -1- XCODE_VERSION([])
m4trace:configure.ac:575: -1- m4_pattern_allow([^CrossCompiling$])
m4trace:configure.ac:576: -1- m4_pattern_allow([^CrossCompilePrefix$])
m4trace:configure.ac:577: -1- m4_pattern_allow([^TargetPlatformFull$])
m4trace:configure.ac:578: -1- m4_pattern_allow([^EnableDistroToolchain$])
m4trace:configure.ac:593: -1- m4_pattern_allow([^CC$])
m4trace:configure.ac:593: -1- m4_pattern_allow([^CFLAGS$])
m4trace:configure.ac:593: -1- m4_pattern_allow([^LDFLAGS$])
m4trace:configure.ac:593: -1- m4_pattern_allow([^LIBS$])
m4trace:configure.ac:593: -1- m4_pattern_allow([^CPPFLAGS$])
m4trace:configure.ac:593: -1- m4_pattern_allow([^CC$])
m4trace:configure.ac:593: -1- m4_pattern_allow([^ac_ct_CC$])
m4trace:configure.ac:593: -1- m4_pattern_allow([^EXEEXT$])
m4trace:configure.ac:593: -1- m4_pattern_allow([^OBJEXT$])
m4trace:configure.ac:595: -1- MAYBE_OVERRIDE_STAGE0([ar], [AR_STAGE0])
m4trace:configure.ac:598: -1- AC_DEFUN([_AC_Header_stdio_h], [m4_divert_text([INIT_PREPARE],
  [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list],
  [" stdio.h ]AS_TR_SH([stdio.h]) AS_TR_CPP([HAVE_stdio.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)])
m4trace:configure.ac:598: -1- AC_DEFUN([_AC_Header_stdlib_h], [m4_divert_text([INIT_PREPARE],
  [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list],
  [" stdlib.h ]AS_TR_SH([stdlib.h]) AS_TR_CPP([HAVE_stdlib.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)])
m4trace:configure.ac:598: -1- AC_DEFUN([_AC_Header_string_h], [m4_divert_text([INIT_PREPARE],
  [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list],
  [" string.h ]AS_TR_SH([string.h]) AS_TR_CPP([HAVE_string.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)])
m4trace:configure.ac:598: -1- AC_DEFUN([_AC_Header_inttypes_h], [m4_divert_text([INIT_PREPARE],
  [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list],
  [" inttypes.h ]AS_TR_SH([inttypes.h]) AS_TR_CPP([HAVE_inttypes.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)])
m4trace:configure.ac:598: -1- AC_DEFUN([_AC_Header_stdint_h], [m4_divert_text([INIT_PREPARE],
  [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list],
  [" stdint.h ]AS_TR_SH([stdint.h]) AS_TR_CPP([HAVE_stdint.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)])
m4trace:configure.ac:598: -1- AC_DEFUN([_AC_Header_strings_h], [m4_divert_text([INIT_PREPARE],
  [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list],
  [" strings.h ]AS_TR_SH([strings.h]) AS_TR_CPP([HAVE_strings.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)])
m4trace:configure.ac:598: -1- AC_DEFUN([_AC_Header_sys_stat_h], [m4_divert_text([INIT_PREPARE],
  [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list],
  [" sys/stat.h ]AS_TR_SH([sys/stat.h]) AS_TR_CPP([HAVE_sys/stat.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)])
m4trace:configure.ac:598: -1- AC_DEFUN([_AC_Header_sys_types_h], [m4_divert_text([INIT_PREPARE],
  [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list],
  [" sys/types.h ]AS_TR_SH([sys/types.h]) AS_TR_CPP([HAVE_sys/types.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)])
m4trace:configure.ac:598: -1- AC_DEFUN([_AC_Header_unistd_h], [m4_divert_text([INIT_PREPARE],
  [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list],
  [" unistd.h ]AS_TR_SH([unistd.h]) AS_TR_CPP([HAVE_unistd.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)])
m4trace:configure.ac:598: -1- m4_pattern_allow([^STDC_HEADERS$])
m4trace:configure.ac:598: -1- AC_DEFUN([_AC_Header_wchar_h], [m4_divert_text([INIT_PREPARE],
  [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list],
  [" wchar.h ]AS_TR_SH([wchar.h]) AS_TR_CPP([HAVE_wchar.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)])
m4trace:configure.ac:598: -1- AC_DEFUN([_AC_Header_minix_config_h], [m4_divert_text([INIT_PREPARE],
  [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list],
  [" minix/config.h ]AS_TR_SH([minix/config.h]) AS_TR_CPP([HAVE_minix/config.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)])
m4trace:configure.ac:598: -1- m4_pattern_allow([^_ALL_SOURCE$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^_DARWIN_C_SOURCE$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^_GNU_SOURCE$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^_HPUX_ALT_XOPEN_SOCKET_API$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^_NETBSD_SOURCE$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^_OPENBSD_SOURCE$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^_POSIX_PTHREAD_SEMANTICS$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^__STDC_WANT_IEC_60559_ATTRIBS_EXT__$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^__STDC_WANT_IEC_60559_BFP_EXT__$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^__STDC_WANT_IEC_60559_DFP_EXT__$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^__STDC_WANT_IEC_60559_FUNCS_EXT__$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^__STDC_WANT_IEC_60559_TYPES_EXT__$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^__STDC_WANT_LIB_EXT2__$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^__STDC_WANT_MATH_SPEC_FUNCS__$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^_TANDEM_SOURCE$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^_MINIX$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^_POSIX_SOURCE$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^_POSIX_1_SOURCE$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^__EXTENSIONS__$])
m4trace:configure.ac:598: -1- m4_pattern_allow([^_XOPEN_SOURCE$])
m4trace:configure.ac:601: -1- m4_pattern_allow([^CPP$])
m4trace:configure.ac:601: -1- m4_pattern_allow([^CPPFLAGS$])
m4trace:configure.ac:601: -1- m4_pattern_allow([^CPP$])
m4trace:configure.ac:604: -1- FP_CPP_CMD_WITH_ARGS([HaskellCPPCmd], [HaskellCPPArgs])
m4trace:configure.ac:605: -1- m4_pattern_allow([^HaskellCPPCmd$])
m4trace:configure.ac:606: -1- m4_pattern_allow([^HaskellCPPArgs$])
m4trace:configure.ac:608: -1- FP_SET_CFLAGS_C99([CC], [CFLAGS], [CPPFLAGS])
m4trace:configure.ac:608: -1- FP_COPY_SHELLVAR([CC], [fp_save_CC])
m4trace:configure.ac:608: -1- FP_COPY_SHELLVAR([CFLAGS], [fp_save_CFLAGS])
m4trace:configure.ac:608: -1- FP_COPY_SHELLVAR([CPPFLAGS], [fp_save_CPPFLAGS])
m4trace:configure.ac:608: -1- FP_COPY_SHELLVAR([ac_cv_prog_cc_c99], [fp_save_cc_c99])
m4trace:configure.ac:608: -1- _m4_warn([obsolete], [The macro `AC_PROG_CC_C99' is obsolete.
You should run autoupdate.], [./lib/autoconf/c.m4:1659: AC_PROG_CC_C99 is expanded from...
m4/fp_set_cflags_c99.m4:7: FP_SET_CFLAGS_C99 is expanded from...
configure.ac:608: the top level])
m4trace:configure.ac:608: -1- FP_COPY_SHELLVAR([fp_save_CC], [CC])
m4trace:configure.ac:608: -1- FP_COPY_SHELLVAR([fp_save_CFLAGS], [CFLAGS])
m4trace:configure.ac:608: -1- FP_COPY_SHELLVAR([fp_save_CPPFLAGS], [CPPFLAGS])
m4trace:configure.ac:608: -1- FP_COPY_SHELLVAR([fp_save_cc_c99], [ac_cv_prog_cc_c99])
m4trace:configure.ac:609: -1- FP_SET_CFLAGS_C99([CC_STAGE0], [CONF_CC_OPTS_STAGE0], [CONF_CPP_OPTS_STAGE0])
m4trace:configure.ac:609: -1- FP_COPY_SHELLVAR([CC], [fp_save_CC])
m4trace:configure.ac:609: -1- FP_COPY_SHELLVAR([CFLAGS], [fp_save_CFLAGS])
m4trace:configure.ac:609: -1- FP_COPY_SHELLVAR([CPPFLAGS], [fp_save_CPPFLAGS])
m4trace:configure.ac:609: -1- FP_COPY_SHELLVAR([ac_cv_prog_cc_c99], [fp_save_cc_c99])
m4trace:configure.ac:609: -1- _m4_warn([obsolete], [The macro `AC_PROG_CC_C99' is obsolete.
You should run autoupdate.], [./lib/autoconf/c.m4:1659: AC_PROG_CC_C99 is expanded from...
m4/fp_set_cflags_c99.m4:7: FP_SET_CFLAGS_C99 is expanded from...
configure.ac:609: the top level])
m4trace:configure.ac:609: -1- FP_COPY_SHELLVAR([fp_save_CC], [CC])
m4trace:configure.ac:609: -1- FP_COPY_SHELLVAR([fp_save_CFLAGS], [CFLAGS])
m4trace:configure.ac:609: -1- FP_COPY_SHELLVAR([fp_save_CPPFLAGS], [CPPFLAGS])
m4trace:configure.ac:609: -1- FP_COPY_SHELLVAR([fp_save_cc_c99], [ac_cv_prog_cc_c99])
m4trace:configure.ac:610: -1- FP_SET_CFLAGS_C99([CC], [CONF_CC_OPTS_STAGE1], [CONF_CPP_OPTS_STAGE1])
m4trace:configure.ac:610: -1- FP_COPY_SHELLVAR([CC], [fp_save_CC])
m4trace:configure.ac:610: -1- FP_COPY_SHELLVAR([CFLAGS], [fp_save_CFLAGS])
m4trace:configure.ac:610: -1- FP_COPY_SHELLVAR([CPPFLAGS], [fp_save_CPPFLAGS])
m4trace:configure.ac:610: -1- FP_COPY_SHELLVAR([ac_cv_prog_cc_c99], [fp_save_cc_c99])
m4trace:configure.ac:610: -1- _m4_warn([obsolete], [The macro `AC_PROG_CC_C99' is obsolete.
You should run autoupdate.], [./lib/autoconf/c.m4:1659: AC_PROG_CC_C99 is expanded from...
m4/fp_set_cflags_c99.m4:7: FP_SET_CFLAGS_C99 is expanded from...
configure.ac:610: the top level])
m4trace:configure.ac:610: -1- FP_COPY_SHELLVAR([fp_save_CC], [CC])
m4trace:configure.ac:610: -1- FP_COPY_SHELLVAR([fp_save_CFLAGS], [CFLAGS])
m4trace:configure.ac:610: -1- FP_COPY_SHELLVAR([fp_save_CPPFLAGS], [CPPFLAGS])
m4trace:configure.ac:610: -1- FP_COPY_SHELLVAR([fp_save_cc_c99], [ac_cv_prog_cc_c99])
m4trace:configure.ac:611: -1- FP_SET_CFLAGS_C99([CC], [CONF_CC_OPTS_STAGE2], [CONF_CPP_OPTS_STAGE2])
m4trace:configure.ac:611: -1- FP_COPY_SHELLVAR([CC], [fp_save_CC])
m4trace:configure.ac:611: -1- FP_COPY_SHELLVAR([CFLAGS], [fp_save_CFLAGS])
m4trace:configure.ac:611: -1- FP_COPY_SHELLVAR([CPPFLAGS], [fp_save_CPPFLAGS])
m4trace:configure.ac:611: -1- FP_COPY_SHELLVAR([ac_cv_prog_cc_c99], [fp_save_cc_c99])
m4trace:configure.ac:611: -1- _m4_warn([obsolete], [The macro `AC_PROG_CC_C99' is obsolete.
You should run autoupdate.], [./lib/autoconf/c.m4:1659: AC_PROG_CC_C99 is expanded from...
m4/fp_set_cflags_c99.m4:7: FP_SET_CFLAGS_C99 is expanded from...
configure.ac:611: the top level])
m4trace:configure.ac:611: -1- FP_COPY_SHELLVAR([fp_save_CC], [CC])
m4trace:configure.ac:611: -1- FP_COPY_SHELLVAR([fp_save_CFLAGS], [CFLAGS])
m4trace:configure.ac:611: -1- FP_COPY_SHELLVAR([fp_save_CPPFLAGS], [CPPFLAGS])
m4trace:configure.ac:611: -1- FP_COPY_SHELLVAR([fp_save_cc_c99], [ac_cv_prog_cc_c99])
m4trace:configure.ac:615: -1- m4_pattern_allow([^LD$])
m4trace:configure.ac:616: -1- FIND_LD([$target], [GccUseLdOpt])
m4trace:configure.ac:616: -1- m4_pattern_allow([^LD$])
m4trace:configure.ac:616: -1- m4_pattern_allow([^TmpLd$])
m4trace:configure.ac:616: -1- FP_CC_LINKER_FLAG_TRY([bfd], [GccUseLdOpt])
m4trace:configure.ac:616: -1- FP_CC_LINKER_FLAG_TRY([gold], [GccUseLdOpt])
m4trace:configure.ac:616: -1- FP_BINUTILS_T23856([])
m4trace:configure.ac:616: -1- FP_GCC_SUPPORTS_NO_PIE
m4trace:configure.ac:616: -1- FP_CC_LINKER_FLAG_TRY([lld], [GccUseLdOpt])
m4trace:configure.ac:616: -1- FP_CC_LINKER_FLAG_TRY([lld], [GccUseLdOpt])
m4trace:configure.ac:616: -1- m4_pattern_allow([^LD$])
m4trace:configure.ac:616: -1- m4_pattern_allow([^LD$])
m4trace:configure.ac:616: -1- m4_pattern_allow([^LD$])
m4trace:configure.ac:616: -1- CHECK_LD_COPY_BUG([$target])
m4trace:configure.ac:616: -1- m4_pattern_allow([^READELF$])
m4trace:configure.ac:616: -1- m4_pattern_allow([^AS$])
m4trace:configure.ac:617: -1- FIND_MERGE_OBJECTS([])
m4trace:configure.ac:617: -1- CHECK_FOR_GOLD_T22266([$MergeObjsCmd])
m4trace:configure.ac:617: -1- FPTOOLS_WRITE_FILE([conftest.a.c], [
          __attribute__((section(".data.a")))
          static int int_from_a_1 = 0x11223344;

          __attribute__((section(".data.rel.ro.a")))
          int *p_int_from_a_2 = &int_from_a_1;

          const char *hello (void);

          const char *
          hello (void)
          {
            return "XXXHello, world!" + 3;
          }
        ])
m4trace:configure.ac:617: -1- FPTOOLS_WRITE_FILE([conftest.main.c], [
          #include <stdlib.h>
          #include <string.h>

          extern int *p_int_from_a_2;
          extern const char *hello (void);

          int main (void) {
            if (*p_int_from_a_2 != 0x11223344)
              abort ();
            if (strcmp(hello(), "Hello, world!") != 0)
              abort ();
            return 0;
          }
        ])
m4trace:configure.ac:617: -1- FPTOOLS_WRITE_FILE([conftest.t], [
          SECTIONS
          {
              .text : {
                  *(.text*)
              }
              .rodata :
              {
                  *(.rodata .rodata.* .gnu.linkonce.r.*)
              }
              .data.rel.ro : {
                  *(.data.rel.ro*)
              }
              .data : {
                  *(.data*)
              }
              .bss : {
                  *(.bss*)
              }
          }
        ])
m4trace:configure.ac:617: -1- m4_pattern_allow([^MergeObjsCmd$])
m4trace:configure.ac:617: -1- CHECK_FOR_GOLD_T22266([$MergeObjsCmd])
m4trace:configure.ac:617: -1- FPTOOLS_WRITE_FILE([conftest.a.c], [
          __attribute__((section(".data.a")))
          static int int_from_a_1 = 0x11223344;

          __attribute__((section(".data.rel.ro.a")))
          int *p_int_from_a_2 = &int_from_a_1;

          const char *hello (void);

          const char *
          hello (void)
          {
            return "XXXHello, world!" + 3;
          }
        ])
m4trace:configure.ac:617: -1- FPTOOLS_WRITE_FILE([conftest.main.c], [
          #include <stdlib.h>
          #include <string.h>

          extern int *p_int_from_a_2;
          extern const char *hello (void);

          int main (void) {
            if (*p_int_from_a_2 != 0x11223344)
              abort ();
            if (strcmp(hello(), "Hello, world!") != 0)
              abort ();
            return 0;
          }
        ])
m4trace:configure.ac:617: -1- FPTOOLS_WRITE_FILE([conftest.t], [
          SECTIONS
          {
              .text : {
                  *(.text*)
              }
              .rodata :
              {
                  *(.rodata .rodata.* .gnu.linkonce.r.*)
              }
              .data.rel.ro : {
                  *(.data.rel.ro*)
              }
              .data : {
                  *(.data*)
              }
              .bss : {
                  *(.bss*)
              }
          }
        ])
m4trace:configure.ac:617: -1- m4_pattern_allow([^MergeObjsCmd$])
m4trace:configure.ac:617: -1- m4_pattern_allow([^MergeObjsArgs$])
m4trace:configure.ac:622: -1- m4_pattern_allow([^LdCmd$])
m4trace:configure.ac:624: -1- FP_PROG_LD_IS_GNU
m4trace:configure.ac:624: -1- m4_pattern_allow([^LdIsGNULd$])
m4trace:configure.ac:625: -1- FP_PROG_LD_BUILD_ID
m4trace:configure.ac:625: -1- m4_pattern_allow([^LdHasBuildId$])
m4trace:configure.ac:626: -1- FP_PROG_LD_NO_COMPACT_UNWIND
m4trace:configure.ac:626: -1- m4_pattern_allow([^LdHasNoCompactUnwind$])
m4trace:configure.ac:627: -1- FP_PROG_LD_FILELIST
m4trace:configure.ac:627: -1- m4_pattern_allow([^LdHasFilelist$])
m4trace:configure.ac:631: -1- FP_FIND_NM
m4trace:configure.ac:631: -1- m4_pattern_allow([^NM$])
m4trace:configure.ac:631: -1- m4_pattern_allow([^NmCmd$])
m4trace:configure.ac:639: -1- m4_pattern_allow([^OBJDUMP$])
m4trace:configure.ac:644: -1- m4_pattern_allow([^ObjdumpCmd$])
m4trace:configure.ac:648: -1- m4_pattern_allow([^RANLIB$])
m4trace:configure.ac:653: -1- m4_pattern_allow([^RanlibCmd$])
m4trace:configure.ac:657: -1- m4_pattern_allow([^STRIP$])
m4trace:configure.ac:659: -1- m4_pattern_allow([^StripCmd$])
m4trace:configure.ac:669: -1- m4_pattern_allow([^LIBTOOL$])
m4trace:configure.ac:672: -1- m4_pattern_allow([^LIBTOOL$])
m4trace:configure.ac:675: -1- m4_pattern_allow([^LibtoolCmd$])
m4trace:configure.ac:679: -1- m4_pattern_allow([^OTOOL$])
m4trace:configure.ac:681: -1- m4_pattern_allow([^OtoolCmd$])
m4trace:configure.ac:685: -1- m4_pattern_allow([^INSTALL_NAME_TOOL$])
m4trace:configure.ac:687: -1- m4_pattern_allow([^InstallNameToolCmd$])
m4trace:configure.ac:695: -1- m4_pattern_allow([^LlvmMinVersion$])
m4trace:configure.ac:696: -1- m4_pattern_allow([^LlvmMaxVersion$])
m4trace:configure.ac:699: -1- m4_pattern_allow([^sUPPORTED_LLVM_VERSION_MIN$])
m4trace:configure.ac:700: -1- m4_pattern_allow([^sUPPORTED_LLVM_VERSION_MAX$])
m4trace:configure.ac:704: -1- m4_pattern_allow([^CLANG$])
m4trace:configure.ac:705: -1- m4_pattern_allow([^CLANG$])
m4trace:configure.ac:707: -1- m4_pattern_allow([^ClangCmd$])
m4trace:configure.ac:711: -1- m4_pattern_allow([^LLC$])
m4trace:configure.ac:712: -1- FIND_LLVM_PROG([LLC], [llc], [$LlvmMinVersion], [$LlvmMaxVersion])
m4trace:configure.ac:712: -1- m4_pattern_allow([^LLC$])
m4trace:configure.ac:712: -1- m4_pattern_allow([^ac_ct_LLC$])
m4trace:configure.ac:712: -1- AX_COMPARE_VERSION([$PROG_VERSION], [lt], [$LlvmMinVersion], [AC_MSG_RESULT(no)
             LLC=""
             AC_MSG_NOTICE([We only support llvm $LlvmMinVersion to $LlvmMaxVersion (found $PROG_VERSION).])], [AX_COMPARE_VERSION([$PROG_VERSION], [ge], [$LlvmMaxVersion],
             [AC_MSG_RESULT(no)
              LLC=""
              AC_MSG_NOTICE([We only support llvm $LlvmMinVersion to $LlvmMaxVersion (found $PROG_VERSION).])],
             [AC_MSG_RESULT(yes)])])
m4trace:configure.ac:712: -1- m4_pattern_allow([^AWK$])
m4trace:configure.ac:712: -1- AX_COMPARE_VERSION([$PROG_VERSION], [ge], [$LlvmMaxVersion], [AC_MSG_RESULT(no)
              LLC=""
              AC_MSG_NOTICE([We only support llvm $LlvmMinVersion to $LlvmMaxVersion (found $PROG_VERSION).])], [AC_MSG_RESULT(yes)])
m4trace:configure.ac:714: -1- m4_pattern_allow([^LlcCmd$])
m4trace:configure.ac:718: -1- m4_pattern_allow([^OPT$])
m4trace:configure.ac:719: -1- FIND_LLVM_PROG([OPT], [opt], [$LlvmMinVersion], [$LlvmMaxVersion])
m4trace:configure.ac:719: -1- m4_pattern_allow([^OPT$])
m4trace:configure.ac:719: -1- m4_pattern_allow([^ac_ct_OPT$])
m4trace:configure.ac:719: -1- AX_COMPARE_VERSION([$PROG_VERSION], [lt], [$LlvmMinVersion], [AC_MSG_RESULT(no)
             OPT=""
             AC_MSG_NOTICE([We only support llvm $LlvmMinVersion to $LlvmMaxVersion (found $PROG_VERSION).])], [AX_COMPARE_VERSION([$PROG_VERSION], [ge], [$LlvmMaxVersion],
             [AC_MSG_RESULT(no)
              OPT=""
              AC_MSG_NOTICE([We only support llvm $LlvmMinVersion to $LlvmMaxVersion (found $PROG_VERSION).])],
             [AC_MSG_RESULT(yes)])])
m4trace:configure.ac:719: -1- AX_COMPARE_VERSION([$PROG_VERSION], [ge], [$LlvmMaxVersion], [AC_MSG_RESULT(no)
              OPT=""
              AC_MSG_NOTICE([We only support llvm $LlvmMinVersion to $LlvmMaxVersion (found $PROG_VERSION).])], [AC_MSG_RESULT(yes)])
m4trace:configure.ac:721: -1- m4_pattern_allow([^OptCmd$])
m4trace:configure.ac:760: -1- FP_GCC_VERSION
m4trace:configure.ac:760: -1- FP_COMPARE_VERSIONS([$fp_cv_gcc_version], [-lt], [4.7], [AC_MSG_ERROR([Need at least gcc version 4.7 (newer recommended)])])
m4trace:configure.ac:760: -1- m4_pattern_allow([^GccVersion$])
m4trace:configure.ac:763: -1- FP_GCC_SUPPORTS_NO_PIE
m4trace:configure.ac:769: -1- FP_CC_SUPPORTS__ATOMICS
m4trace:configure.ac:769: -1- m4_pattern_allow([^HAVE_C11_ATOMICS$])
m4trace:configure.ac:769: -1- m4_pattern_allow([^CabalNeedLibatomic$])
m4trace:configure.ac:769: -1- m4_pattern_allow([^CabalNeedLibatomic$])
m4trace:configure.ac:769: -1- m4_pattern_allow([^NEED_ATOMIC_LIB$])
m4trace:configure.ac:771: -1- FP_GCC_EXTRA_FLAGS
m4trace:configure.ac:771: -1- m4_pattern_allow([^GccExtraViaCOpts$])
m4trace:configure.ac:775: -1- FP_CC_LLVM_BACKEND
m4trace:configure.ac:775: -1- m4_pattern_allow([^CC_LLVM_BACKEND$])
m4trace:configure.ac:775: -1- m4_pattern_allow([^CcLlvmBackend$])
m4trace:configure.ac:777: -1- FPTOOLS_SET_C_LD_FLAGS([target], [CFLAGS], [LDFLAGS], [IGNORE_LINKER_LD_FLAGS], [CPPFLAGS])
m4trace:configure.ac:778: -1- FPTOOLS_SET_C_LD_FLAGS([build], [CONF_CC_OPTS_STAGE0], [CONF_GCC_LINKER_OPTS_STAGE0], [CONF_LD_LINKER_OPTS_STAGE0], [CONF_CPP_OPTS_STAGE0])
m4trace:configure.ac:779: -1- FPTOOLS_SET_C_LD_FLAGS([target], [CONF_CC_OPTS_STAGE1], [CONF_GCC_LINKER_OPTS_STAGE1], [CONF_LD_LINKER_OPTS_STAGE1], [CONF_CPP_OPTS_STAGE1])
m4trace:configure.ac:780: -1- FPTOOLS_SET_C_LD_FLAGS([target], [CONF_CC_OPTS_STAGE2], [CONF_GCC_LINKER_OPTS_STAGE2], [CONF_LD_LINKER_OPTS_STAGE2], [CONF_CPP_OPTS_STAGE2])
m4trace:configure.ac:785: -1- FP_CC_SUPPORTS_TARGET
m4trace:configure.ac:789: -1- m4_pattern_allow([^CONF_CC_OPTS_STAGE0$])
m4trace:configure.ac:790: -1- m4_pattern_allow([^CONF_CC_OPTS_STAGE1$])
m4trace:configure.ac:791: -1- m4_pattern_allow([^CONF_CC_OPTS_STAGE2$])
m4trace:configure.ac:793: -1- m4_pattern_allow([^CONF_GCC_LINKER_OPTS_STAGE0$])
m4trace:configure.ac:794: -1- m4_pattern_allow([^CONF_GCC_LINKER_OPTS_STAGE1$])
m4trace:configure.ac:795: -1- m4_pattern_allow([^CONF_GCC_LINKER_OPTS_STAGE2$])
m4trace:configure.ac:797: -1- m4_pattern_allow([^CONF_LD_LINKER_OPTS_STAGE0$])
m4trace:configure.ac:798: -1- m4_pattern_allow([^CONF_LD_LINKER_OPTS_STAGE1$])
m4trace:configure.ac:799: -1- m4_pattern_allow([^CONF_LD_LINKER_OPTS_STAGE2$])
m4trace:configure.ac:801: -1- m4_pattern_allow([^CONF_CPP_OPTS_STAGE0$])
m4trace:configure.ac:802: -1- m4_pattern_allow([^CONF_CPP_OPTS_STAGE1$])
m4trace:configure.ac:803: -1- m4_pattern_allow([^CONF_CPP_OPTS_STAGE2$])
m4trace:configure.ac:805: -1- m4_pattern_allow([^CONF_HC_OPTS_STAGE0$])
m4trace:configure.ac:806: -1- m4_pattern_allow([^CONF_HC_OPTS_STAGE1$])
m4trace:configure.ac:807: -1- m4_pattern_allow([^CONF_HC_OPTS_STAGE2$])
m4trace:configure.ac:812: -1- FPTOOLS_SET_HASKELL_PLATFORM_VARS
m4trace:configure.ac:812: -1- GET_ARM_ISA([])
m4trace:configure.ac:812: -1- m4_pattern_allow([^arm_HOST_ARCH_PRE_ARMv6$])
m4trace:configure.ac:812: -1- m4_pattern_allow([^arm_HOST_ARCH_PRE_ARMv7$])
m4trace:configure.ac:812: -1- m4_pattern_allow([^arm_HOST_ARCH_PRE_ARMv7$])
m4trace:configure.ac:812: -1- m4_pattern_allow([^ARM_ISA$])
m4trace:configure.ac:812: -1- m4_pattern_allow([^HAVE_SUBSECTIONS_VIA_SYMBOLS$])
m4trace:configure.ac:812: -1- m4_pattern_allow([^HaskellHostArch$])
m4trace:configure.ac:812: -1- m4_pattern_allow([^HaskellHostOs$])
m4trace:configure.ac:812: -1- m4_pattern_allow([^HaskellTargetArch$])
m4trace:configure.ac:812: -1- m4_pattern_allow([^HaskellTargetOs$])
m4trace:configure.ac:812: -1- m4_pattern_allow([^TargetHasSubsectionsViaSymbols$])
m4trace:configure.ac:812: -1- m4_pattern_allow([^TargetHasIdentDirective$])
m4trace:configure.ac:812: -1- m4_pattern_allow([^TargetHasGnuNonexecStack$])
m4trace:configure.ac:815: -1- FP_PROG_CONTEXT_DIFF
m4trace:configure.ac:815: -1- m4_pattern_allow([^ContextDiffCmd$])
m4trace:configure.ac:821: -1- m4_pattern_allow([^INSTALL_PROGRAM$])
m4trace:configure.ac:821: -1- m4_pattern_allow([^INSTALL_SCRIPT$])
m4trace:configure.ac:821: -1- m4_pattern_allow([^INSTALL_DATA$])
m4trace:configure.ac:824: -1- FP_PROG_AR_SUPPORTS_ATFILE
m4trace:configure.ac:824: -1- FP_PROG_AR
m4trace:configure.ac:824: -1- m4_pattern_allow([^fp_prog_ar$])
m4trace:configure.ac:824: -1- m4_pattern_allow([^fp_prog_ar$])
m4trace:configure.ac:824: -1- m4_pattern_allow([^fp_prog_ar$])
m4trace:configure.ac:824: -1- FP_PROG_AR_ARGS
m4trace:configure.ac:824: -1- FP_PROG_AR_IS_GNU
m4trace:configure.ac:824: -1- m4_pattern_allow([^ArIsGNUAr$])
m4trace:configure.ac:824: -1- m4_pattern_allow([^ArCmd$])
m4trace:configure.ac:824: -1- m4_pattern_allow([^ArArgs$])
m4trace:configure.ac:824: -1- m4_pattern_allow([^ArSupportsAtFile$])
m4trace:configure.ac:825: -1- FP_PROG_AR_NEEDS_RANLIB
m4trace:configure.ac:825: -1- m4_pattern_allow([^RANLIB$])
m4trace:configure.ac:825: -1- m4_pattern_allow([^REAL_RANLIB_CMD$])
m4trace:configure.ac:825: -1- m4_pattern_allow([^RANLIB_CMD$])
m4trace:configure.ac:828: -1- m4_pattern_allow([^LN_S$])
m4trace:configure.ac:830: -1- FP_SETTINGS
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsCCompilerCommand$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsHaskellCPPCommand$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsHaskellCPPFlags$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsCCompilerFlags$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsCxxCompilerFlags$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsCCompilerLinkFlags$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsCCompilerSupportsNoPie$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsLdCommand$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsLdFlags$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsMergeObjectsCommand$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsMergeObjectsFlags$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsArCommand$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsRanlibCommand$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsOtoolCommand$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsInstallNameToolCommand$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsDllWrapCommand$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsWindresCommand$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsLibtoolCommand$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsTouchCommand$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsClangCommand$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsLlcCommand$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsOptCommand$])
m4trace:configure.ac:830: -1- m4_pattern_allow([^SettingsUseDistroMINGW$])
m4trace:configure.ac:833: -1- m4_pattern_allow([^SedCmd$])
m4trace:configure.ac:837: -1- m4_pattern_allow([^TimeCmd$])
m4trace:configure.ac:841: -1- m4_pattern_allow([^TarCmd$])
m4trace:configure.ac:844: -1- m4_pattern_allow([^Bzip2Cmd$])
m4trace:configure.ac:845: -1- m4_pattern_allow([^GzipCmd$])
m4trace:configure.ac:846: -1- m4_pattern_allow([^XzCmd$])
m4trace:configure.ac:850: -1- m4_pattern_allow([^PatchCmd$])
m4trace:configure.ac:853: -1- m4_pattern_allow([^AutoreconfCmd$])
m4trace:configure.ac:865: -1- m4_pattern_allow([^DtraceCmd$])
m4trace:configure.ac:875: -1- m4_pattern_allow([^HaveDtrace$])
m4trace:configure.ac:877: -1- m4_pattern_allow([^HSCOLOUR$])
m4trace:configure.ac:888: -1- m4_pattern_allow([^SPHINXBUILD$])
m4trace:configure.ac:896: -1- FP_COMPARE_VERSIONS([$fp_cv_sphinx_version], [-lt], [1.0.0], [AC_MSG_WARN([Sphinx version 1.0.0 or later is required to build documentation]); SPHINXBUILD=;])
m4trace:configure.ac:906: -1- m4_pattern_allow([^XELATEX$])
m4trace:configure.ac:907: -1- m4_pattern_allow([^MAKEINDEX$])
m4trace:configure.ac:908: -1- m4_pattern_allow([^GIT$])
m4trace:configure.ac:911: -1- m4_pattern_allow([^MAKEINFO$])
m4trace:configure.ac:914: -1- FIND_PYTHON
m4trace:configure.ac:914: -1- m4_pattern_allow([^PYTHON$])
m4trace:configure.ac:914: -1- m4_pattern_allow([^PythonCmd$])
m4trace:configure.ac:917: -1- FP_PROG_GHC_PKG
m4trace:configure.ac:917: -1- m4_pattern_allow([^GhcPkgCmd$])
m4trace:configure.ac:921: -1- m4_pattern_allow([^HAPPY$])
m4trace:configure.ac:922: -1- FPTOOLS_HAPPY
m4trace:configure.ac:922: -1- m4_pattern_allow([^HAPPY$])
m4trace:configure.ac:922: -1- m4_pattern_allow([^HappyCmd$])
m4trace:configure.ac:922: -1- FP_COMPARE_VERSIONS([$fptools_cv_happy_version], [-lt], [1.20.0], [AC_MSG_ERROR([Happy version 1.20 or later is required to compile GHC.])])
m4trace:configure.ac:922: -1- FP_COMPARE_VERSIONS([$fptools_cv_happy_version], [-ge], [1.21.0], [AC_MSG_ERROR([Happy version 1.20 or earlier is required to compile GHC.])])
m4trace:configure.ac:922: -1- m4_pattern_allow([^HappyVersion$])
m4trace:configure.ac:926: -1- m4_pattern_allow([^ALEX$])
m4trace:configure.ac:927: -1- FPTOOLS_ALEX
m4trace:configure.ac:927: -1- m4_pattern_allow([^ALEX$])
m4trace:configure.ac:927: -1- m4_pattern_allow([^AlexCmd$])
m4trace:configure.ac:927: -1- FP_COMPARE_VERSIONS([$fptools_cv_alex_version], [-lt], [3.2.6], [AC_MSG_ERROR([Alex >= 3.2.6 && < 4 is required to compile GHC.])])
m4trace:configure.ac:927: -1- FP_COMPARE_VERSIONS([$fptools_cv_alex_version], [-ge], [4.0.0], [AC_MSG_ERROR([Alex >= 3.2.6 && < 4 is required to compile GHC.])])
m4trace:configure.ac:927: -1- m4_pattern_allow([^AlexVersion$])
m4trace:configure.ac:939: -1- m4_pattern_allow([^_FILE_OFFSET_BITS$])
m4trace:configure.ac:939: -1- m4_pattern_allow([^_LARGE_FILES$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_CTYPE_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_DIRENT_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_DLFCN_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_ERRNO_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_FCNTL_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_GRP_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_LIMITS_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_LOCALE_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_NLIST_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_PTHREAD_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_PWD_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_SIGNAL_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_SYS_PARAM_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_SYS_MMAN_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_SYS_RESOURCE_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_SYS_SELECT_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_SYS_TIME_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_SYS_TIMEB_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_SYS_TIMERFD_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_SYS_TIMERS_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_SYS_TIMES_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_SYS_UTSNAME_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_SYS_WAIT_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_TERMIOS_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_TIME_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_UTIME_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_WINDOWS_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_WINSOCK_H$])
m4trace:configure.ac:942: -1- m4_pattern_allow([^HAVE_SCHED_H$])
m4trace:configure.ac:945: -1- m4_pattern_allow([^HAVE_SYS_CPUSET_H$])
m4trace:configure.ac:952: -1- FP_CHECK_ENVIRON
m4trace:configure.ac:952: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN])
m4trace:configure.ac:952: -1- m4_pattern_allow([^HAVE_DECL_ENVIRON$])
m4trace:configure.ac:955: -1- _m4_warn([obsolete], [The macro `AC_HEADER_TIME' is obsolete.
You should run autoupdate.], [./lib/autoconf/headers.m4:743: AC_HEADER_TIME is expanded from...
configure.ac:955: the top level])
m4trace:configure.ac:955: -1- AC_DEFUN([_AC_Header_sys_time_h], [m4_divert_text([INIT_PREPARE],
  [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list],
  [" sys/time.h ]AS_TR_SH([sys/time.h]) AS_TR_CPP([HAVE_sys/time.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)])
m4trace:configure.ac:955: -1- m4_pattern_allow([^TIME_WITH_SYS_TIME$])
m4trace:configure.ac:958: -1- m4_pattern_allow([^HAVE_LONG_LONG$])
m4trace:configure.ac:961: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([char])
m4trace:configure.ac:961: -1- m4_pattern_allow([^SIZEOF_CHAR$])
m4trace:configure.ac:961: -1- FP_CHECK_ALIGNMENT([char])
m4trace:configure.ac:961: -1- FP_COMPUTE_INT([offsetof(struct { char c; char ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (char)
See `config.log' for more details.], [77])])
m4trace:configure.ac:961: -1- m4_pattern_allow([^ALIGNMENT_CHAR$])
m4trace:configure.ac:962: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([double])
m4trace:configure.ac:962: -1- m4_pattern_allow([^SIZEOF_DOUBLE$])
m4trace:configure.ac:962: -1- FP_CHECK_ALIGNMENT([double])
m4trace:configure.ac:962: -1- FP_COMPUTE_INT([offsetof(struct { char c; double ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (double)
See `config.log' for more details.], [77])])
m4trace:configure.ac:962: -1- m4_pattern_allow([^ALIGNMENT_DOUBLE$])
m4trace:configure.ac:963: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([float])
m4trace:configure.ac:963: -1- m4_pattern_allow([^SIZEOF_FLOAT$])
m4trace:configure.ac:963: -1- FP_CHECK_ALIGNMENT([float])
m4trace:configure.ac:963: -1- FP_COMPUTE_INT([offsetof(struct { char c; float ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (float)
See `config.log' for more details.], [77])])
m4trace:configure.ac:963: -1- m4_pattern_allow([^ALIGNMENT_FLOAT$])
m4trace:configure.ac:964: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([int])
m4trace:configure.ac:964: -1- m4_pattern_allow([^SIZEOF_INT$])
m4trace:configure.ac:964: -1- FP_CHECK_ALIGNMENT([int])
m4trace:configure.ac:964: -1- FP_COMPUTE_INT([offsetof(struct { char c; int ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (int)
See `config.log' for more details.], [77])])
m4trace:configure.ac:964: -1- m4_pattern_allow([^ALIGNMENT_INT$])
m4trace:configure.ac:965: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([long])
m4trace:configure.ac:965: -1- m4_pattern_allow([^SIZEOF_LONG$])
m4trace:configure.ac:965: -1- FP_CHECK_ALIGNMENT([long])
m4trace:configure.ac:965: -1- FP_COMPUTE_INT([offsetof(struct { char c; long ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (long)
See `config.log' for more details.], [77])])
m4trace:configure.ac:965: -1- m4_pattern_allow([^ALIGNMENT_LONG$])
m4trace:configure.ac:967: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([long long])
m4trace:configure.ac:967: -1- m4_pattern_allow([^SIZEOF_LONG_LONG$])
m4trace:configure.ac:967: -1- FP_CHECK_ALIGNMENT([long long])
m4trace:configure.ac:967: -1- FP_COMPUTE_INT([offsetof(struct { char c; long long ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (long long)
See `config.log' for more details.], [77])])
m4trace:configure.ac:967: -1- m4_pattern_allow([^ALIGNMENT_LONG_LONG$])
m4trace:configure.ac:969: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([short])
m4trace:configure.ac:969: -1- m4_pattern_allow([^SIZEOF_SHORT$])
m4trace:configure.ac:969: -1- FP_CHECK_ALIGNMENT([short])
m4trace:configure.ac:969: -1- FP_COMPUTE_INT([offsetof(struct { char c; short ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (short)
See `config.log' for more details.], [77])])
m4trace:configure.ac:969: -1- m4_pattern_allow([^ALIGNMENT_SHORT$])
m4trace:configure.ac:970: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([unsigned char])
m4trace:configure.ac:970: -1- m4_pattern_allow([^SIZEOF_UNSIGNED_CHAR$])
m4trace:configure.ac:970: -1- FP_CHECK_ALIGNMENT([unsigned char])
m4trace:configure.ac:970: -1- FP_COMPUTE_INT([offsetof(struct { char c; unsigned char ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (unsigned char)
See `config.log' for more details.], [77])])
m4trace:configure.ac:970: -1- m4_pattern_allow([^ALIGNMENT_UNSIGNED_CHAR$])
m4trace:configure.ac:971: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([unsigned int])
m4trace:configure.ac:971: -1- m4_pattern_allow([^SIZEOF_UNSIGNED_INT$])
m4trace:configure.ac:971: -1- FP_CHECK_ALIGNMENT([unsigned int])
m4trace:configure.ac:971: -1- FP_COMPUTE_INT([offsetof(struct { char c; unsigned int ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (unsigned int)
See `config.log' for more details.], [77])])
m4trace:configure.ac:971: -1- m4_pattern_allow([^ALIGNMENT_UNSIGNED_INT$])
m4trace:configure.ac:972: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([unsigned long])
m4trace:configure.ac:972: -1- m4_pattern_allow([^SIZEOF_UNSIGNED_LONG$])
m4trace:configure.ac:972: -1- FP_CHECK_ALIGNMENT([unsigned long])
m4trace:configure.ac:972: -1- FP_COMPUTE_INT([offsetof(struct { char c; unsigned long ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (unsigned long)
See `config.log' for more details.], [77])])
m4trace:configure.ac:972: -1- m4_pattern_allow([^ALIGNMENT_UNSIGNED_LONG$])
m4trace:configure.ac:974: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([unsigned long long])
m4trace:configure.ac:974: -1- m4_pattern_allow([^SIZEOF_UNSIGNED_LONG_LONG$])
m4trace:configure.ac:974: -1- FP_CHECK_ALIGNMENT([unsigned long long])
m4trace:configure.ac:974: -1- FP_COMPUTE_INT([offsetof(struct { char c; unsigned long long ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (unsigned long long)
See `config.log' for more details.], [77])])
m4trace:configure.ac:974: -1- m4_pattern_allow([^ALIGNMENT_UNSIGNED_LONG_LONG$])
m4trace:configure.ac:976: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([unsigned short])
m4trace:configure.ac:976: -1- m4_pattern_allow([^SIZEOF_UNSIGNED_SHORT$])
m4trace:configure.ac:976: -1- FP_CHECK_ALIGNMENT([unsigned short])
m4trace:configure.ac:976: -1- FP_COMPUTE_INT([offsetof(struct { char c; unsigned short ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (unsigned short)
See `config.log' for more details.], [77])])
m4trace:configure.ac:976: -1- m4_pattern_allow([^ALIGNMENT_UNSIGNED_SHORT$])
m4trace:configure.ac:977: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([void *])
m4trace:configure.ac:977: -1- m4_pattern_allow([^SIZEOF_VOID_P$])
m4trace:configure.ac:977: -1- FP_CHECK_ALIGNMENT([void *])
m4trace:configure.ac:977: -1- FP_COMPUTE_INT([offsetof(struct { char c; void * ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (void *)
See `config.log' for more details.], [77])])
m4trace:configure.ac:977: -1- m4_pattern_allow([^ALIGNMENT_VOID_P$])
m4trace:configure.ac:979: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([int8_t])
m4trace:configure.ac:979: -1- m4_pattern_allow([^SIZEOF_INT8_T$])
m4trace:configure.ac:979: -1- FP_CHECK_ALIGNMENT([int8_t])
m4trace:configure.ac:979: -1- FP_COMPUTE_INT([offsetof(struct { char c; int8_t ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (int8_t)
See `config.log' for more details.], [77])])
m4trace:configure.ac:979: -1- m4_pattern_allow([^ALIGNMENT_INT8_T$])
m4trace:configure.ac:980: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([uint8_t])
m4trace:configure.ac:980: -1- m4_pattern_allow([^SIZEOF_UINT8_T$])
m4trace:configure.ac:980: -1- FP_CHECK_ALIGNMENT([uint8_t])
m4trace:configure.ac:980: -1- FP_COMPUTE_INT([offsetof(struct { char c; uint8_t ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (uint8_t)
See `config.log' for more details.], [77])])
m4trace:configure.ac:980: -1- m4_pattern_allow([^ALIGNMENT_UINT8_T$])
m4trace:configure.ac:981: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([int16_t])
m4trace:configure.ac:981: -1- m4_pattern_allow([^SIZEOF_INT16_T$])
m4trace:configure.ac:981: -1- FP_CHECK_ALIGNMENT([int16_t])
m4trace:configure.ac:981: -1- FP_COMPUTE_INT([offsetof(struct { char c; int16_t ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (int16_t)
See `config.log' for more details.], [77])])
m4trace:configure.ac:981: -1- m4_pattern_allow([^ALIGNMENT_INT16_T$])
m4trace:configure.ac:982: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([uint16_t])
m4trace:configure.ac:982: -1- m4_pattern_allow([^SIZEOF_UINT16_T$])
m4trace:configure.ac:982: -1- FP_CHECK_ALIGNMENT([uint16_t])
m4trace:configure.ac:982: -1- FP_COMPUTE_INT([offsetof(struct { char c; uint16_t ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (uint16_t)
See `config.log' for more details.], [77])])
m4trace:configure.ac:982: -1- m4_pattern_allow([^ALIGNMENT_UINT16_T$])
m4trace:configure.ac:983: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([int32_t])
m4trace:configure.ac:983: -1- m4_pattern_allow([^SIZEOF_INT32_T$])
m4trace:configure.ac:983: -1- FP_CHECK_ALIGNMENT([int32_t])
m4trace:configure.ac:983: -1- FP_COMPUTE_INT([offsetof(struct { char c; int32_t ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (int32_t)
See `config.log' for more details.], [77])])
m4trace:configure.ac:983: -1- m4_pattern_allow([^ALIGNMENT_INT32_T$])
m4trace:configure.ac:984: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([uint32_t])
m4trace:configure.ac:984: -1- m4_pattern_allow([^SIZEOF_UINT32_T$])
m4trace:configure.ac:984: -1- FP_CHECK_ALIGNMENT([uint32_t])
m4trace:configure.ac:984: -1- FP_COMPUTE_INT([offsetof(struct { char c; uint32_t ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (uint32_t)
See `config.log' for more details.], [77])])
m4trace:configure.ac:984: -1- m4_pattern_allow([^ALIGNMENT_UINT32_T$])
m4trace:configure.ac:985: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([int64_t])
m4trace:configure.ac:985: -1- m4_pattern_allow([^SIZEOF_INT64_T$])
m4trace:configure.ac:985: -1- FP_CHECK_ALIGNMENT([int64_t])
m4trace:configure.ac:985: -1- FP_COMPUTE_INT([offsetof(struct { char c; int64_t ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (int64_t)
See `config.log' for more details.], [77])])
m4trace:configure.ac:985: -1- m4_pattern_allow([^ALIGNMENT_INT64_T$])
m4trace:configure.ac:986: -1- FP_CHECK_SIZEOF_AND_ALIGNMENT([uint64_t])
m4trace:configure.ac:986: -1- m4_pattern_allow([^SIZEOF_UINT64_T$])
m4trace:configure.ac:986: -1- FP_CHECK_ALIGNMENT([uint64_t])
m4trace:configure.ac:986: -1- FP_COMPUTE_INT([offsetof(struct { char c; uint64_t ty; },ty)], [fp_Cache], [AC_INCLUDES_DEFAULT([])], [AC_MSG_ERROR([cannot compute alignment (uint64_t)
See `config.log' for more details.], [77])])
m4trace:configure.ac:986: -1- m4_pattern_allow([^ALIGNMENT_UINT64_T$])
m4trace:configure.ac:992: -1- m4_pattern_allow([^Cabal64bit$])
m4trace:configure.ac:994: -1- m4_pattern_allow([^Cabal64bit$])
m4trace:configure.ac:996: -1- m4_pattern_allow([^TargetWordSize$])
m4trace:configure.ac:998: -1- m4_pattern_allow([^AC_APPLE_UNIVERSAL_BUILD$])
m4trace:configure.ac:999: -1- m4_pattern_allow([^TargetWordBigEndian$])
m4trace:configure.ac:1001: -1- FP_CHECK_FUNC([WinExec], [@%:@include <windows.h>], [WinExec("",0)])
m4trace:configure.ac:1001: -1- m4_pattern_allow([^HAVE_WINEXEC$])
m4trace:configure.ac:1004: -1- FP_CHECK_FUNC([GetModuleFileName], [@%:@include <windows.h>], [GetModuleFileName((HMODULE)0,(LPTSTR)0,0)])
m4trace:configure.ac:1004: -1- m4_pattern_allow([^HAVE_GETMODULEFILENAME$])
m4trace:configure.ac:1009: -1- m4_pattern_allow([^HAVE_GETCLOCK$])
m4trace:configure.ac:1009: -1- m4_pattern_allow([^HAVE_GETRUSAGE$])
m4trace:configure.ac:1009: -1- m4_pattern_allow([^HAVE_GETTIMEOFDAY$])
m4trace:configure.ac:1009: -1- m4_pattern_allow([^HAVE_SETITIMER$])
m4trace:configure.ac:1009: -1- m4_pattern_allow([^HAVE_SIGINTERRUPT$])
m4trace:configure.ac:1009: -1- m4_pattern_allow([^HAVE_SYSCONF$])
m4trace:configure.ac:1009: -1- m4_pattern_allow([^HAVE_TIMES$])
m4trace:configure.ac:1009: -1- m4_pattern_allow([^HAVE_CTIME_R$])
m4trace:configure.ac:1009: -1- m4_pattern_allow([^HAVE_SCHED_SETAFFINITY$])
m4trace:configure.ac:1009: -1- m4_pattern_allow([^HAVE_SCHED_GETAFFINITY$])
m4trace:configure.ac:1009: -1- m4_pattern_allow([^HAVE_SETLOCALE$])
m4trace:configure.ac:1013: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN])
m4trace:configure.ac:1013: -1- m4_pattern_allow([^HAVE_DECL_CTIME_R$])
m4trace:configure.ac:1019: -1- m4_pattern_allow([^HaveLibMingwEx$])
m4trace:configure.ac:1019: -1- m4_pattern_allow([^CabalMingwex$])
m4trace:configure.ac:1019: -1- m4_pattern_allow([^HaveLibMingwEx$])
m4trace:configure.ac:1019: -1- m4_pattern_allow([^CabalMingwex$])
m4trace:configure.ac:1026: -1- m4_pattern_allow([^HAVE_MINGWEX$])
m4trace:configure.ac:1037: -1- m4_pattern_allow([^HAVE_LIBM$])
m4trace:configure.ac:1038: -1- m4_pattern_allow([^CabalHaveLibm$])
m4trace:configure.ac:1040: -1- m4_pattern_allow([^CabalHaveLibm$])
m4trace:configure.ac:1043: -1- FP_BFD_SUPPORT
m4trace:configure.ac:1043: -1- m4_pattern_allow([^CabalHaveLibbfd$])
m4trace:configure.ac:1043: -1- m4_pattern_allow([^HAVE_BFD_H$])
m4trace:configure.ac:1043: -1- m4_pattern_allow([^HAVE_LIBIBERTY$])
m4trace:configure.ac:1043: -1- m4_pattern_allow([^HAVE_LIBBFD$])
m4trace:configure.ac:1043: -1- m4_pattern_allow([^CabalHaveLibbfd$])
m4trace:configure.ac:1061: -1- m4_pattern_allow([^UseSystemLibFFI$])
m4trace:configure.ac:1062: -1- m4_pattern_allow([^CabalUseSystemLibFFI$])
m4trace:configure.ac:1077: -1- m4_pattern_allow([^FFIIncludeDir$])
m4trace:configure.ac:1091: -1- m4_pattern_allow([^FFILibDir$])
m4trace:configure.ac:1093: -1- m4_pattern_allow([^HAVE_FFI_H$])
m4trace:configure.ac:1093: -1- m4_pattern_allow([^HAVE_SYSTEM_LIBFFI$])
m4trace:configure.ac:1116: -1- m4_pattern_allow([^HAVE_LIBDL$])
m4trace:configure.ac:1117: -1- m4_pattern_allow([^CabalHaveLibdl$])
m4trace:configure.ac:1117: -1- m4_pattern_allow([^CabalHaveLibdl$])
m4trace:configure.ac:1119: -1- m4_pattern_allow([^HAVE_DLINFO$])
m4trace:configure.ac:1126: -1- m4_pattern_allow([^size_t$])
m4trace:configure.ac:1126: -1- m4_pattern_allow([^HAVE_ALLOCA_H$])
m4trace:configure.ac:1126: -1- m4_pattern_allow([^HAVE_ALLOCA$])
m4trace:configure.ac:1126: -1- m4_pattern_allow([^ALLOCA$])
m4trace:configure.ac:1126: -1- m4_pattern_allow([^C_ALLOCA$])
m4trace:configure.ac:1126: -1- m4_pattern_allow([^STACK_DIRECTION$])
m4trace:configure.ac:1129: -1- m4_pattern_allow([^pid_t$])
m4trace:configure.ac:1129: -1- AC_DEFUN([_AC_Header_vfork_h], [m4_divert_text([INIT_PREPARE],
  [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list],
  [" vfork.h ]AS_TR_SH([vfork.h]) AS_TR_CPP([HAVE_vfork.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)])
m4trace:configure.ac:1129: -1- AC_DEFUN([_AC_Func_fork], [m4_divert_text([INIT_PREPARE],
  [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list],
  [" fork ]AS_TR_CPP([HAVE_fork])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)])
m4trace:configure.ac:1129: -1- AC_DEFUN([_AC_Func_vfork], [m4_divert_text([INIT_PREPARE],
  [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list],
  [" vfork ]AS_TR_CPP([HAVE_vfork])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)])
m4trace:configure.ac:1129: -1- m4_pattern_allow([^HAVE_WORKING_VFORK$])
m4trace:configure.ac:1129: -1- m4_pattern_allow([^vfork$])
m4trace:configure.ac:1129: -1- m4_pattern_allow([^HAVE_WORKING_FORK$])
m4trace:configure.ac:1132: -1- m4_pattern_allow([^const$])
m4trace:configure.ac:1135: -1- m4_pattern_allow([^WORDS_BIGENDIAN$])
m4trace:configure.ac:1135: -1- m4_pattern_allow([^AC_APPLE_UNIVERSAL_BUILD$])
m4trace:configure.ac:1136: -1- FPTOOLS_FLOAT_WORD_ORDER_BIGENDIAN
m4trace:configure.ac:1136: -1- m4_pattern_allow([^FLOAT_WORDS_BIGENDIAN$])
m4trace:configure.ac:1139: -1- FP_LEADING_UNDERSCORE
m4trace:configure.ac:1139: -1- m4_pattern_allow([^LeadingUnderscore$])
m4trace:configure.ac:1139: -1- m4_pattern_allow([^CabalLeadingUnderscore$])
m4trace:configure.ac:1139: -1- m4_pattern_allow([^LEADING_UNDERSCORE$])
m4trace:configure.ac:1139: -1- m4_pattern_allow([^CabalLeadingUnderscore$])
m4trace:configure.ac:1141: -1- FP_VISIBILITY_HIDDEN
m4trace:configure.ac:1141: -1- m4_pattern_allow([^HAS_VISIBILITY_HIDDEN$])
m4trace:configure.ac:1144: -1- m4_pattern_allow([^HAVE_LIBRT$])
m4trace:configure.ac:1145: -1- m4_pattern_allow([^CabalHaveLibrt$])
m4trace:configure.ac:1145: -1- m4_pattern_allow([^CabalHaveLibrt$])
m4trace:configure.ac:1146: -1- m4_pattern_allow([^HAVE_CLOCK_GETTIME$])
m4trace:configure.ac:1146: -1- m4_pattern_allow([^HAVE_TIMER_SETTIME$])
m4trace:configure.ac:1147: -1- FP_CHECK_TIMER_CREATE
m4trace:configure.ac:1147: -1- m4_pattern_allow([^USE_TIMER_CREATE$])
m4trace:configure.ac:1147: -1- _m4_warn([obsolete], [The macro `AC_TRY_RUN' is obsolete.
You should run autoupdate.], [./lib/autoconf/general.m4:2997: AC_TRY_RUN is expanded from...
lib/m4sugar/m4sh.m4:692: _AS_IF_ELSE is expanded from...
lib/m4sugar/m4sh.m4:699: AS_IF is expanded from...
./lib/autoconf/general.m4:2249: AC_CACHE_VAL is expanded from...
./lib/autoconf/general.m4:2270: AC_CACHE_CHECK is expanded from...
m4/fp_check_timer_create.m4:5: FP_CHECK_TIMER_CREATE is expanded from...
configure.ac:1147: the top level])
m4trace:configure.ac:1147: -1- _m4_warn([cross], [AC_RUN_IFELSE called without default to allow cross compiling], [./lib/autoconf/general.m4:2981: AC_RUN_IFELSE is expanded from...
./lib/autoconf/general.m4:2997: AC_TRY_RUN is expanded from...
lib/m4sugar/m4sh.m4:692: _AS_IF_ELSE is expanded from...
lib/m4sugar/m4sh.m4:699: AS_IF is expanded from...
./lib/autoconf/general.m4:2249: AC_CACHE_VAL is expanded from...
./lib/autoconf/general.m4:2270: AC_CACHE_CHECK is expanded from...
m4/fp_check_timer_create.m4:5: FP_CHECK_TIMER_CREATE is expanded from...
configure.ac:1147: the top level])
m4trace:configure.ac:1147: -1- m4_pattern_allow([^USE_TIMER_CREATE$])
m4trace:configure.ac:1151: -1- m4_pattern_allow([^HAVE_PRINTF_LDBLSTUB$])
m4trace:configure.ac:1151: -1- m4_pattern_allow([^HAVE_PRINTF_LDBLSTUB$])
m4trace:configure.ac:1163: -1- FP_CHECK_PTHREADS
m4trace:configure.ac:1163: -1- m4_pattern_allow([^CabalNeedLibpthread$])
m4trace:configure.ac:1163: -1- m4_pattern_allow([^CabalNeedLibpthread$])
m4trace:configure.ac:1163: -1- m4_pattern_allow([^CabalNeedLibpthread$])
m4trace:configure.ac:1163: -1- m4_pattern_allow([^NEED_PTHREAD_LIB$])
m4trace:configure.ac:1163: -1- m4_pattern_allow([^HAVE_PTHREAD_NP_H$])
m4trace:configure.ac:1163: -1- m4_pattern_allow([^HAVE_LIBPTHREAD$])
m4trace:configure.ac:1163: -1- m4_pattern_allow([^HAVE_PTHREAD_SETNAME_NP_DARWIN$])
m4trace:configure.ac:1163: -1- m4_pattern_allow([^HAVE_PTHREAD_SETNAME_NP$])
m4trace:configure.ac:1163: -1- m4_pattern_allow([^HAVE_PTHREAD_SET_NAME_NP$])
m4trace:configure.ac:1163: -1- AC_DEFUN([_AC_Func_pthread_condattr_setclock], [m4_divert_text([INIT_PREPARE],
  [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list],
  [" pthread_condattr_setclock ]AS_TR_CPP([HAVE_pthread_condattr_setclock])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)])
m4trace:configure.ac:1166: -1- m4_pattern_allow([^HAVE_SYS_EVENTFD_H$])
m4trace:configure.ac:1167: -1- m4_pattern_allow([^HAVE_EVENTFD$])
m4trace:configure.ac:1171: -1- m4_pattern_allow([^CC_SUPPORTS_TLS$])
m4trace:configure.ac:1171: -1- m4_pattern_allow([^CC_SUPPORTS_TLS$])
m4trace:configure.ac:1218: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN])
m4trace:configure.ac:1218: -1- m4_pattern_allow([^HAVE_DECL_MAP_NORESERVE$])
m4trace:configure.ac:1218: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN])
m4trace:configure.ac:1218: -1- m4_pattern_allow([^HAVE_DECL_MADV_FREE$])
m4trace:configure.ac:1218: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN])
m4trace:configure.ac:1218: -1- m4_pattern_allow([^HAVE_DECL_MADV_DONTNEED$])
m4trace:configure.ac:1234: -1- m4_pattern_allow([^USE_LARGE_ADDRESS_SPACE$])
m4trace:configure.ac:1253: -1- m4_pattern_allow([^RTS_LINKER_USE_MMAP$])
m4trace:configure.ac:1305: -1- m4_pattern_allow([^CabalLibffiAdjustors$])
m4trace:configure.ac:1306: -1- m4_pattern_allow([^UseLibffiForAdjustors$])
m4trace:configure.ac:1310: -1- FP_FIND_LIBDW
m4trace:configure.ac:1310: -1- m4_pattern_allow([^LibdwLibDir$])
m4trace:configure.ac:1310: -1- m4_pattern_allow([^LibdwIncludeDir$])
m4trace:configure.ac:1310: -1- m4_pattern_allow([^HAVE_ELFUTILS_LIBDW_H$])
m4trace:configure.ac:1310: -1- m4_pattern_allow([^UseLibdw$])
m4trace:configure.ac:1310: -1- m4_pattern_allow([^CabalHaveLibdw$])
m4trace:configure.ac:1310: -1- m4_pattern_allow([^CabalHaveLibdw$])
m4trace:configure.ac:1310: -1- m4_pattern_allow([^USE_LIBDW$])
m4trace:configure.ac:1311: -1- FP_FIND_LIBNUMA
m4trace:configure.ac:1311: -1- m4_pattern_allow([^LibNumaLibDir$])
m4trace:configure.ac:1311: -1- m4_pattern_allow([^LibNumaIncludeDir$])
m4trace:configure.ac:1311: -1- m4_pattern_allow([^HAVE_NUMA_H$])
m4trace:configure.ac:1311: -1- m4_pattern_allow([^HAVE_NUMAIF_H$])
m4trace:configure.ac:1311: -1- m4_pattern_allow([^HAVE_LIBNUMA$])
m4trace:configure.ac:1311: -1- m4_pattern_allow([^UseLibNuma$])
m4trace:configure.ac:1311: -1- m4_pattern_allow([^CabalHaveLibNuma$])
m4trace:configure.ac:1311: -1- m4_pattern_allow([^UseLibNuma$])
m4trace:configure.ac:1311: -1- m4_pattern_allow([^CabalHaveLibNuma$])
m4trace:configure.ac:1334: -1- m4_pattern_allow([^BUILD_MAN$])
m4trace:configure.ac:1335: -1- m4_pattern_allow([^BUILD_SPHINX_HTML$])
m4trace:configure.ac:1336: -1- m4_pattern_allow([^BUILD_SPHINX_PDF$])
m4trace:configure.ac:1341: -1- LIBRARY_VERSION([base])
m4trace:configure.ac:1341: -1- m4_pattern_allow([^LIBRARY_base_VERSION$])
m4trace:configure.ac:1342: -1- LIBRARY_VERSION([Cabal], [Cabal/Cabal/Cabal.cabal])
m4trace:configure.ac:1342: -1- m4_pattern_allow([^LIBRARY_Cabal_VERSION$])
m4trace:configure.ac:1345: -1- LIBRARY_VERSION([template-haskell], [template-haskell/template-haskell.cabal.in])
m4trace:configure.ac:1345: -1- m4_pattern_allow([^LIBRARY_template_haskell_VERSION$])
m4trace:configure.ac:1346: -1- LIBRARY_VERSION([array])
m4trace:configure.ac:1346: -1- m4_pattern_allow([^LIBRARY_array_VERSION$])
m4trace:configure.ac:1347: -1- LIBRARY_VERSION([ghc-prim])
m4trace:configure.ac:1347: -1- m4_pattern_allow([^LIBRARY_ghc_prim_VERSION$])
m4trace:configure.ac:1348: -1- LIBRARY_VERSION([ghc-compact])
m4trace:configure.ac:1348: -1- m4_pattern_allow([^LIBRARY_ghc_compact_VERSION$])
m4trace:configure.ac:1350: -1- m4_pattern_allow([^LIBRARY_ghc_VERSION$])
m4trace:configure.ac:1378: -1- m4_pattern_allow([^MakeCmd$])
m4trace:configure.ac:1417: -1- m4_pattern_allow([^LIB@&t@OBJS$])
m4trace:configure.ac:1417: -1- m4_pattern_allow([^LTLIBOBJS$])
