js/src/configure.in
author Gregory Szorc <gps@mozilla.com>
Mon, 25 Feb 2013 14:09:16 -0800
changeset 123701 632f21df7be14b26688adeb73634e8cfde685c1b
parent 122272 e4448a24543bcd556b1ecb14c6578ffac5815de1
child 123702 f5edb9df59386952a904d6b0251ec83479b3cffb
permissions -rw-r--r--
Bug 784841 - Part 19: Remove allmakefiles.sh and friends; r=ted

dnl -*- Mode: Autoconf; tab-width: 4; indent-tabs-mode: nil; -*-
dnl vi: set tabstop=4 shiftwidth=4 expandtab syntax=m4:
dnl This Source Code Form is subject to the terms of the Mozilla Public
dnl License, v. 2.0. If a copy of the MPL was not distributed with this
dnl file, You can obtain one at http://mozilla.org/MPL/2.0/.

dnl Process this file with autoconf to produce a configure script.
dnl ========================================================

AC_PREREQ(2.13)
AC_INIT(jsapi.h)
AC_CONFIG_AUX_DIR(${srcdir}/build/autoconf)
AC_CONFIG_HEADER(js-config.h)
AC_CANONICAL_SYSTEM
TARGET_CPU="${target_cpu}"
TARGET_VENDOR="${target_vendor}"
TARGET_OS="${target_os}"

dnl ========================================================
dnl =
dnl = Don't change the following two lines.  Doing so breaks:
dnl =
dnl = CFLAGS="-foo" ./configure
dnl =
dnl ========================================================
CFLAGS="${CFLAGS=}"
CPPFLAGS="${CPPFLAGS=}"
CXXFLAGS="${CXXFLAGS=}"
LDFLAGS="${LDFLAGS=}"
HOST_CFLAGS="${HOST_CFLAGS=}"
HOST_CXXFLAGS="${HOST_CXXFLAGS=}"
HOST_LDFLAGS="${HOST_LDFLAGS=}"

dnl ========================================================
dnl = Preserve certain environment flags passed to configure
dnl = We want sub projects to receive the same flags
dnl = untainted by this configure script
dnl ========================================================
_SUBDIR_CC="$CC"
_SUBDIR_CXX="$CXX"
_SUBDIR_CFLAGS="$CFLAGS"
_SUBDIR_CPPFLAGS="$CPPFLAGS"
_SUBDIR_CXXFLAGS="$CXXFLAGS"
_SUBDIR_LDFLAGS="$LDFLAGS"
_SUBDIR_HOST_CC="$HOST_CC"
_SUBDIR_HOST_CFLAGS="$HOST_CFLAGS"
_SUBDIR_HOST_CXXFLAGS="$HOST_CXXFLAGS"
_SUBDIR_HOST_LDFLAGS="$HOST_LDFLAGS"
_SUBDIR_CONFIG_ARGS="$ac_configure_args"

dnl Set the version number of the libs included with mozilla
dnl ========================================================
NSPR_VERSION=4

dnl Set the minimum version of toolkit libs used by mozilla
dnl ========================================================
PERL_VERSION=5.006
WINDRES_VERSION=2.14.90
W32API_VERSION=3.14

MSMANIFEST_TOOL=

dnl Set various checks
dnl ========================================================
MISSING_X=
AC_PROG_AWK

dnl Initialize the Pthread test variables early so they can be
dnl  overridden by each platform.
dnl ========================================================
USE_PTHREADS=
_PTHREAD_LDFLAGS=""

dnl Do not allow a separate objdir build if a srcdir build exists.
dnl ==============================================================
_topsrcdir=`cd \`dirname $0\`; pwd`
_objdir=`pwd`

if test "$_topsrcdir" != "$_objdir"
then
  # Check for a couple representative files in the source tree
  _conflict_files=
  for file in $_topsrcdir/Makefile $_topsrcdir/config/autoconf.mk; do
    if test -f $file; then
      _conflict_files="$_conflict_files $file"
    fi
  done
  if test "$_conflict_files"; then
    echo "***"
    echo "*   Your source tree contains these files:"
    for file in $_conflict_files; do
      echo "*         $file"
    done
    cat 1>&2 <<-EOF
	*   This indicates that you previously built in the source tree.
	*   A source tree build can confuse the separate objdir build.
	*
	*   To clean up the source tree:
	*     1. cd $_topsrcdir
	*     2. gmake distclean
	***
	EOF
    exit 1
    break
  fi
fi
MOZ_BUILD_ROOT=`pwd`

dnl Choose where to put the 'dist' directory.
dnl ==============================================================

MOZ_ARG_WITH_STRING(dist-dir,
[  --with-dist-dir=DIR     Use DIR as 'dist' staging area.  DIR may be
                          relative to the top of SpiderMonkey build tree,
                          or absolute.],
    TOP_DIST=$withval,
    TOP_DIST=dist)
AC_SUBST(TOP_DIST)

MOZ_DEFAULT_COMPILER

COMPILE_ENVIRONMENT=1
MOZ_ARG_DISABLE_BOOL(compile-environment,
[  --disable-compile-environment
                          Disable compiler/library checks.],
    COMPILE_ENVIRONMENT= )

dnl Check for Perl first -- needed for win32 SDK checks
MOZ_PATH_PROGS(PERL, $PERL perl5 perl )
if test -z "$PERL" -o "$PERL" = ":"; then
    AC_MSG_ERROR([perl not found in \$PATH])
fi

MOZ_ARG_ENABLE_BOOL(shared-js,
[  --disable-shared-js
                          Do not create a shared library.],
    DISABLE_SHARED_JS=0,
    DISABLE_SHARED_JS=1)

if test "$DISABLE_SHARED_JS" = "1" ; then
  AC_DEFINE(STATIC_EXPORTABLE_JS_API)
else
  JS_SHARED_LIBRARY=1
fi
AC_SUBST(JS_SHARED_LIBRARY)

if test "$JS_STANDALONE" = no; then
  JS_STANDALONE=
else
  JS_STANDALONE=1
fi
AC_SUBST(JS_STANDALONE)

MOZ_ARG_WITH_STRING(gonk,
[  --with-gonk=DIR
               location of gonk dir],
    gonkdir=$withval)

MOZ_ARG_WITH_STRING(gonk-toolchain-prefix,
[  --with-gonk-toolchain-prefix=DIR
                          prefix to gonk toolchain commands],
    gonk_toolchain_prefix=$withval)

if test -n "$gonkdir" ; then
    kernel_name=`uname -s | tr "[[:upper:]]" "[[:lower:]]"`

    dnl set up compilers
    AS="$gonk_toolchain_prefix"as
    CC="$gonk_toolchain_prefix"gcc
    CXX="$gonk_toolchain_prefix"g++
    CPP="$gonk_toolchain_prefix"cpp
    LD="$gonk_toolchain_prefix"ld
    AR="$gonk_toolchain_prefix"ar
    RANLIB="$gonk_toolchain_prefix"ranlib
    STRIP="$gonk_toolchain_prefix"strip
    OBJCOPY="$gonk_toolchain_prefix"objcopy

    STLPORT_CPPFLAGS="-I$gonkdir/external/stlport/stlport"
    STLPORT_LIBS="-lstlport"

    case "$target_cpu" in
    arm)
        ARCH_DIR=arch-arm
        ;;
    i?86)
        ARCH_DIR=arch-x86
        ;;
    esac

    CPPFLAGS="-DANDROID -isystem $gonkdir/bionic/libc/$ARCH_DIR/include -isystem $gonkdir/bionic/libc/include/ -isystem $gonkdir/bionic/libc/kernel/common -isystem $gonkdir/bionic/libc/kernel/$ARCH_DIR -isystem $gonkdir/bionic/libm/include -I$gonkdir/frameworks/base/native/include -I$gonkdir/system/core/include -isystem $gonkdir/bionic $CPPFLAGS"
    CFLAGS="-mandroid -fno-short-enums -fno-exceptions $CFLAGS"
    CXXFLAGS="-mandroid -fno-short-enums -fno-exceptions -Wno-psabi $CXXFLAGS $STLPORT_CPPFLAGS"
    LIBS="$LIBS $STLPORT_LIBS"

    dnl Add -llog by default, since we use it all over the place.
    LDFLAGS="-mandroid -L$gonkdir/out/target/product/$GONK_PRODUCT/obj/lib -Wl,-rpath-link=$gonkdir/out/target/product/$GONK_PRODUCT/obj/lib --sysroot=$gonkdir/out/target/product/$GONK_PRODUCT/obj/ -llog $LDFLAGS"

    dnl prevent cross compile section from using these flags as host flags
    if test -z "$HOST_CPPFLAGS" ; then
        HOST_CPPFLAGS=" "
    fi
    if test -z "$HOST_CFLAGS" ; then
        HOST_CFLAGS=" "
    fi
    if test -z "$HOST_CXXFLAGS" ; then
        HOST_CXXFLAGS=" "
    fi
    if test -z "$HOST_LDFLAGS" ; then
        HOST_LDFLAGS=" "
    fi

    AC_DEFINE(ANDROID)
    AC_DEFINE(GONK)
    CROSS_COMPILE=1
else
    MOZ_ANDROID_NDK
fi

dnl ========================================================
dnl Checks for compilers.
dnl ========================================================
dnl Set CROSS_COMPILE in the environment when running configure
dnl to use the cross-compile setup for now
dnl ========================================================

dnl AR_FLAGS set here so HOST_AR_FLAGS can be set correctly (see bug 538269)
AR_FLAGS='cr $@'

if test "$COMPILE_ENVIRONMENT"; then

# Note:
#   In Mozilla, we use the names $target, $host and $build incorrectly, but are
#   too far gone to back out now. See Bug 475488:
#     - When we say $target, we mean $host, that is, the system on which
#       Mozilla will be run.
#     - When we say $host, we mean $build, that is, the system on which Mozilla
#       is built.
#     - $target (in its correct usage) is for compilers who generate code for a
#       different platform than $host, so it would not be used by Mozilla.
if test "$target" != "$host"; then
    echo "cross compiling from $host to $target"

    _SAVE_CC="$CC"
    _SAVE_CFLAGS="$CFLAGS"
    _SAVE_LDFLAGS="$LDFLAGS"

    AC_MSG_CHECKING([for host c compiler])
    AC_CHECK_PROGS(HOST_CC, $HOST_CC gcc cc /usr/ucb/cc cl icc, "")
    if test -z "$HOST_CC"; then
        AC_MSG_ERROR([no acceptable c compiler found in \$PATH])
    fi
    AC_MSG_RESULT([$HOST_CC])
    AC_MSG_CHECKING([for host c++ compiler])
    AC_CHECK_PROGS(HOST_CXX, $HOST_CXX $CCC c++ g++ gcc CC cxx cc++ cl icc, "")
    if test -z "$HOST_CXX"; then
        AC_MSG_ERROR([no acceptable c++ compiler found in \$PATH])
    fi
    AC_MSG_RESULT([$HOST_CXX])

    if test -z "$HOST_CFLAGS"; then
        HOST_CFLAGS="$CFLAGS"
    fi
    if test -z "$HOST_CXXFLAGS"; then
        HOST_CXXFLAGS="$CXXFLAGS"
    fi
    if test -z "$HOST_LDFLAGS"; then
        HOST_LDFLAGS="$LDFLAGS"
    fi
    if test -z "$HOST_AR_FLAGS"; then
        HOST_AR_FLAGS="$AR_FLAGS"
    fi
    AC_CHECK_PROGS(HOST_RANLIB, $HOST_RANLIB ranlib, ranlib, :)
    AC_CHECK_PROGS(HOST_AR, $HOST_AR ar, ar, :)
    CC="$HOST_CC"
    CFLAGS="$HOST_CFLAGS"
    LDFLAGS="$HOST_LDFLAGS"

    AC_MSG_CHECKING([whether the host c compiler ($HOST_CC $HOST_CFLAGS $HOST_LDFLAGS) works])
    AC_TRY_COMPILE([], [return(0);],
	[ac_cv_prog_hostcc_works=1 AC_MSG_RESULT([yes])],
	AC_MSG_ERROR([installation or configuration problem: host compiler $HOST_CC cannot create executables.]) )

    CC="$HOST_CXX"
    CFLAGS="$HOST_CXXFLAGS"

    AC_MSG_CHECKING([whether the host c++ compiler ($HOST_CXX $HOST_CXXFLAGS $HOST_LDFLAGS) works])
    AC_TRY_COMPILE([], [return(0);],
	[ac_cv_prog_hostcxx_works=1 AC_MSG_RESULT([yes])],
	AC_MSG_ERROR([installation or configuration problem: host compiler $HOST_CXX cannot create executables.]) )

    CC=$_SAVE_CC
    CFLAGS=$_SAVE_CFLAGS
    LDFLAGS=$_SAVE_LDFLAGS

    AC_CHECK_PROGS(CC, $CC "${target_alias}-gcc" "${target}-gcc", :)
    unset ac_cv_prog_CC
    AC_PROG_CC
    AC_CHECK_PROGS(CXX, $CXX "${target_alias}-g++" "${target}-g++", :)
    unset ac_cv_prog_CXX
    AC_PROG_CXX

    AC_CHECK_PROGS(RANLIB, $RANLIB "${target_alias}-ranlib" "${target}-ranlib", :)
    AC_CHECK_PROGS(AR, $AR "${target_alias}-ar" "${target}-ar", :)
    MOZ_PATH_PROGS(AS, $AS "${target_alias}-as" "${target}-as", :)
    AC_CHECK_PROGS(LD, $LD "${target_alias}-ld" "${target}-ld", :)
    AC_CHECK_PROGS(STRIP, $STRIP "${target_alias}-strip" "${target}-strip", :)
    AC_CHECK_PROGS(WINDRES, $WINDRES "${target_alias}-windres" "${target}-windres", :)
    AC_DEFINE(CROSS_COMPILE)

    dnl If we cross compile for ppc on Mac OS X x86, cross_compiling will
    dnl have erroneously been set to "no", because the x86 build host is
    dnl able to run ppc code in a translated environment, making a cross
    dnl compiler appear native.  So we override that here.
    cross_compiling=yes
else
    AC_PROG_CC
    AC_PROG_CXX
    AC_PROG_RANLIB
    MOZ_PATH_PROGS(AS, $AS as, $CC)
    AC_CHECK_PROGS(AR, ar, :)
    AC_CHECK_PROGS(LD, ld, :)
    AC_CHECK_PROGS(STRIP, strip, :)
    AC_CHECK_PROGS(WINDRES, windres, :)
    if test -z "$HOST_CC"; then
        HOST_CC='$(CC)'
    fi
    if test -z "$HOST_CFLAGS"; then
        HOST_CFLAGS='$(CFLAGS)'
    fi
    if test -z "$HOST_CXX"; then
        HOST_CXX='$(CXX)'
    fi
    if test -z "$HOST_CXXFLAGS"; then
        HOST_CXXFLAGS='$(CXXFLAGS)'
    fi
    if test -z "$HOST_LDFLAGS"; then
        HOST_LDFLAGS='$(LDFLAGS)'
    fi
    if test -z "$HOST_RANLIB"; then
        HOST_RANLIB='$(RANLIB)'
    fi
    if test -z "$HOST_AR"; then
        HOST_AR='$(AR)'
    fi
    if test -z "$HOST_AR_FLAGS"; then
        HOST_AR_FLAGS='$(AR_FLAGS)'
    fi
fi

MOZ_TOOL_VARIABLES

if test -n "$GNU_CC" -a -z "$CLANG_CC" ; then
    if test "$GCC_MAJOR_VERSION" -eq 4 -a "$GCC_MINOR_VERSION" -lt 4 ||
       test "$GCC_MAJOR_VERSION" -lt 4; then
        AC_MSG_ERROR([Only GCC 4.4 or newer supported])
    fi
fi

dnl Special win32 checks
dnl ========================================================

MOZ_ARG_ENABLE_BOOL(metro,
[  --enable-metro           Enable Windows Metro build targets],
    MOZ_METRO=1,
    MOZ_METRO=)
if test -n "$MOZ_METRO"; then
    AC_DEFINE(MOZ_METRO)
    # Target the Windows 8 Kit
    WINSDK_TARGETVER=602
    WINVER=502
else
    # Target the Windows 7 SDK by default
    WINSDK_TARGETVER=601
    WINVER=502
fi

MOZ_ARG_WITH_STRING(windows-version,
[  --with-windows-version=WINSDK_TARGETVER
                          Windows SDK version to target. Lowest version
                          currently allowed is 601, highest is 602],
  WINSDK_TARGETVER=$withval)

# Currently only two sdk versions allowed, 601 and 602
case "$WINSDK_TARGETVER" in
601|602)
    MOZ_WINSDK_TARGETVER=0${WINSDK_TARGETVER}0000
    ;;

*)
    AC_MSG_ERROR([Invalid value for --with-windows-version ($WINSDK_TARGETVER)]);
    ;;
esac

case "$target" in
*-mingw*)
    if test "$GCC" != "yes"; then
        # Check to see if we are really running in a msvc environemnt
        _WIN32_MSVC=1

        # Make sure compilers are valid
        CFLAGS="$CFLAGS -TC -nologo"
        CXXFLAGS="$CXXFLAGS -TP -nologo"
        # MSVC warning C4345 warns of newly conformant behavior as of VS2003.
        # MSVC warning C4351 warns of newly conformant behavior as of VS2005.
        # MSVC warning C4800 warns when a value is implicitly cast to bool,
        # because this also forces narrowing to a single byte, which can be a
        # perf hit.  But this matters so little in practice (and often we want
        # that behavior) that it's better to turn it off.
        # _CRT_SECURE_NO_WARNINGS disables warnings about using MSVC-specific
        # secure CRT functions.
        CXXFLAGS="$CXXFLAGS -wd4345 -wd4351 -wd4800 -D_CRT_SECURE_NO_WARNINGS"
        AC_LANG_SAVE
        AC_LANG_C
        AC_TRY_COMPILE([#include <stdio.h>],
            [ printf("Hello World\n"); ],,
            AC_MSG_ERROR([\$(CC) test failed.  You must have MS VC++ in your path to build.]) )

        AC_LANG_CPLUSPLUS
        AC_TRY_COMPILE([#include <new.h>],
            [ unsigned *test = new unsigned(42); ],,
            AC_MSG_ERROR([\$(CXX) test failed.  You must have MS VC++ in your path to build.]) )
        AC_LANG_RESTORE

        changequote(,)
        _MSVC_VER_FILTER='s|.*[^!-~]([0-9]+\.[0-9]+\.[0-9]+(\.[0-9]+)?).*|\1|p'
        changequote([,])

        # Determine compiler version
        CC_VERSION=`"${CC}" -v 2>&1 | sed -nre "$_MSVC_VER_FILTER"`
        _CC_MAJOR_VERSION=`echo ${CC_VERSION} | $AWK -F\. '{ print $1 }'`
        _CC_MINOR_VERSION=`echo ${CC_VERSION} | $AWK -F\. '{ print $2 }'`
        _CC_RELEASE=`echo ${CC_VERSION} | $AWK -F\. '{ print $3 }'`
        _CC_BUILD=`echo ${CC_VERSION} | $AWK -F\. '{ print $4 }'`
        _MSC_VER=${_CC_MAJOR_VERSION}${_CC_MINOR_VERSION}

        CXX_VERSION=`"${CXX}" -v 2>&1 | sed -nre "$_MSVC_VER_FILTER"`
        _CXX_MAJOR_VERSION=`echo ${CXX_VERSION} | $AWK -F\. '{ print $1 }'`

        if test "$_CC_MAJOR_VERSION" != "$_CXX_MAJOR_VERSION"; then
            AC_MSG_ERROR([The major versions of \$CC and \$CXX do not match.])
        fi

        if test "$_CC_MAJOR_VERSION" = "14"; then
            dnl Require VC8SP1 or newer.
            dnl VC8 is 14.00.50727.42, VC8SP1 is 14.00.50727.762.
            if test "$_CC_RELEASE" -lt 50727 -o \
                    \( "$_CC_RELEASE" -eq 50727 -a "$_CC_BUILD" -lt 762 \); then
              AC_MSG_ERROR([This version ($CC_VERSION) of the MSVC compiler is unsupported. You probably need to install Service Pack 1 of Visual Studio 2005. See https://developer.mozilla.org/en/Windows_Build_Prerequisites.])
            fi

            _CC_SUITE=8
            AC_DEFINE(_CRT_SECURE_NO_DEPRECATE)
            AC_DEFINE(_CRT_NONSTDC_NO_DEPRECATE)
        elif test "$_CC_MAJOR_VERSION" = "15"; then
            _CC_SUITE=9
            AC_DEFINE(_CRT_SECURE_NO_WARNINGS)
            AC_DEFINE(_CRT_NONSTDC_NO_WARNINGS)
        elif test "$_CC_MAJOR_VERSION" = "16"; then
            _CC_SUITE=10
            AC_DEFINE(_CRT_SECURE_NO_WARNINGS)
            AC_DEFINE(_CRT_NONSTDC_NO_WARNINGS)
        elif test "$_CC_MAJOR_VERSION" = "17"; then
            _CC_SUITE=11
            AC_DEFINE(_CRT_SECURE_NO_WARNINGS)
            AC_DEFINE(_CRT_NONSTDC_NO_WARNINGS)
        else
            AC_MSG_ERROR([This version ($CC_VERSION) of the MSVC compiler is unsupported. See https://developer.mozilla.org/en/Windows_Build_Prerequisites.])
        fi

        dnl Ensure that mt.exe is 'Microsoft (R) Manifest Tool',
        dnl not something else like "magnetic tape manipulation utility".
        MSMT_TOOL=`mt 2>&1|grep 'Microsoft (R) Manifest Tool'`
        if test -z "$MSMT_TOOL"; then
          AC_MSG_ERROR([Microsoft (R) Manifest Tool must be in your \$PATH.])
        fi

        changequote(,)
        _MSMT_VER_FILTER='s|.*[^!-~]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\).*|\1|p'
        changequote([,])
        MSMANIFEST_TOOL_VERSION=`echo ${MSMT_TOOL}|sed -ne "$_MSMT_VER_FILTER"`
        if test -z "$MSMANIFEST_TOOL_VERSION"; then
          AC_MSG_WARN([Unknown version of the Microsoft (R) Manifest Tool.])
        fi

        MSMANIFEST_TOOL=1
        unset MSMT_TOOL

        # Check linker version
        _LD_FULL_VERSION=`"${LD}" -v 2>&1 | sed -nre "$_MSVC_VER_FILTER"`
        _LD_MAJOR_VERSION=`echo ${_LD_FULL_VERSION} | $AWK -F\. '{ print $1 }'`
        if test "$_LD_MAJOR_VERSION" != "$_CC_SUITE"; then
            AC_MSG_ERROR([The linker major version, $_LD_FULL_VERSION,  does not match the compiler suite version, $_CC_SUITE.])
        fi

        INCREMENTAL_LINKER=1

        # Identify which version of the SDK we're building with
        # Windows Server 2008 and newer SDKs have WinSDKVer.h, get the version
        # from there
        MOZ_CHECK_HEADERS([winsdkver.h])
        if test "$ac_cv_header_winsdkver_h" = "yes"; then
            # Get the highest _WIN32_WINNT and NTDDI versions supported
            # Take the higher of the two
            # This is done because the Windows 7 beta SDK reports its
            # NTDDI_MAXVER to be 0x06000100 instead of 0x06010000, as it should
            AC_CACHE_CHECK(for highest Windows version supported by this SDK,
                           ac_cv_winsdk_maxver,
                           [cat > conftest.h <<EOF
#include <winsdkver.h>
#include <sdkddkver.h>

#if (NTDDI_VERSION_FROM_WIN32_WINNT(_WIN32_WINNT_MAXVER) > NTDDI_MAXVER)
#define WINSDK_MAXVER NTDDI_VERSION_FROM_WIN32_WINNT(_WIN32_WINNT_MAXVER)
#else
#define WINSDK_MAXVER NTDDI_MAXVER
#endif

WINSDK_MAXVER
EOF
                            ac_cv_winsdk_maxver=`$CPP conftest.h 2>/dev/null | tail -n1`
                            rm -f conftest.h
                           ])
            MOZ_WINSDK_MAXVER=${ac_cv_winsdk_maxver}
        else
            # Any SDK which doesn't have WinSDKVer.h is too old.
            AC_MSG_ERROR([Your SDK does not have WinSDKVer.h. It is probably too old. Please upgrade to a newer SDK or try running the Windows SDK Configuration Tool and selecting a newer SDK. See https://developer.mozilla.org/En/Windows_SDK_versions for more details on fixing this.])
        fi

        unset _MSVC_VER_FILTER
    else
        # Check w32api version
        _W32API_MAJOR_VERSION=`echo $W32API_VERSION | $AWK -F\. '{ print $1 }'`
        _W32API_MINOR_VERSION=`echo $W32API_VERSION | $AWK -F\. '{ print $2 }'`
        AC_MSG_CHECKING([for w32api version >= $W32API_VERSION])
        AC_TRY_COMPILE([#include <w32api.h>],
            #if (__W32API_MAJOR_VERSION < $_W32API_MAJOR_VERSION) || \
                (__W32API_MAJOR_VERSION == $_W32API_MAJOR_VERSION && \
                 __W32API_MINOR_VERSION < $_W32API_MINOR_VERSION)
                #error "test failed."
            #endif
            , [ res=yes ], [ res=no ])
        AC_MSG_RESULT([$res])
        if test "$res" != "yes"; then
            AC_MSG_ERROR([w32api version $W32API_VERSION or higher required.])
        fi
        # Check windres version
        AC_MSG_CHECKING([for windres version >= $WINDRES_VERSION])
        _WINDRES_VERSION=`${WINDRES} --version 2>&1 | grep -i windres 2>/dev/null | $AWK '{ print $3 }'`
        AC_MSG_RESULT([$_WINDRES_VERSION])
        _WINDRES_MAJOR_VERSION=`echo $_WINDRES_VERSION | $AWK -F\. '{ print $1 }'`
        _WINDRES_MINOR_VERSION=`echo $_WINDRES_VERSION | $AWK -F\. '{ print $2 }'`
        _WINDRES_RELEASE_VERSION=`echo $_WINDRES_VERSION | $AWK -F\. '{ print $3 }'`
        WINDRES_MAJOR_VERSION=`echo $WINDRES_VERSION | $AWK -F\. '{ print $1 }'`
        WINDRES_MINOR_VERSION=`echo $WINDRES_VERSION | $AWK -F\. '{ print $2 }'`
        WINDRES_RELEASE_VERSION=`echo $WINDRES_VERSION | $AWK -F\. '{ print $3 }'`
        if test "$_WINDRES_MAJOR_VERSION" -lt "$WINDRES_MAJOR_VERSION" -o \
                "$_WINDRES_MAJOR_VERSION" -eq "$WINDRES_MAJOR_VERSION" -a \
                "$_WINDRES_MINOR_VERSION" -lt "$WINDRES_MINOR_VERSION" -o \
                "$_WINDRES_MAJOR_VERSION" -eq "$WINDRES_MAJOR_VERSION" -a \
                "$_WINDRES_MINOR_VERSION" -eq "$WINDRES_MINOR_VERSION" -a \
                "$_WINDRES_RELEASE_VERSION" -lt "$WINDRES_RELEASE_VERSION"
        then
            AC_MSG_ERROR([windres version $WINDRES_VERSION or higher is required to build.])
        fi

        MOZ_WINSDK_MAXVER=0x06010000
    fi # !GNU_CC

    AC_DEFINE_UNQUOTED(WINVER,0x$WINVER)
    AC_DEFINE_UNQUOTED(_WIN32_WINNT,0x$WINVER)
    # Require OS features provided by IE 6.0 SP2 (XP SP2)
    AC_DEFINE_UNQUOTED(_WIN32_IE,0x0603)

    # If the maximum version supported by this SDK is lower than the target
    # version, error out
    AC_MSG_CHECKING([for Windows SDK being recent enough])
    if $PERL -e "exit(0x$MOZ_WINSDK_TARGETVER > $MOZ_WINSDK_MAXVER)"; then
        AC_MSG_RESULT("yes")
    else
        AC_MSG_RESULT("no")
        AC_MSG_ERROR([You are targeting Windows version 0x$MOZ_WINSDK_TARGETVER, but your SDK only supports up to version $MOZ_WINSDK_MAXVER. Install and use an updated SDK, or target a lower version using --with-windows-version. Alternatively, try running the Windows SDK Configuration Tool and selecting a newer SDK. See https://developer.mozilla.org/En/Windows_SDK_versions for more details on fixing this.])
    fi

    AC_DEFINE_UNQUOTED(MOZ_WINSDK_TARGETVER,0x$MOZ_WINSDK_TARGETVER)
    # Definitions matching sdkddkver.h
    AC_DEFINE_UNQUOTED(MOZ_NTDDI_WIN7, 0x06010000)
    ;;
esac

AC_PROG_CPP
AC_PROG_CXXCPP

if test -n "$_WIN32_MSVC"; then
    SKIP_PATH_CHECKS=1
    SKIP_COMPILER_CHECKS=1
    SKIP_LIBRARY_CHECKS=1

    # Since we're skipping compiler and library checks, hard-code
    # some facts here.

    # Common to all MSVC environments:

    # Windows lacks <stdint.h>, but has __int8, and so on.
    AC_DEFINE(JS_HAVE___INTN)
    AC_DEFINE(HAVE_LOCALECONV)

    # Windows <stddef.h> defines intptr_t and uintptr_t.
    # VS2005: http://msdn.microsoft.com/en-us/library/323b6b3k(VS.80).aspx
    # VS2008: http://msdn.microsoft.com/en-us/library/323b6b3k.aspx
    AC_DEFINE(JS_STDDEF_H_HAS_INTPTR_T)
fi

fi # COMPILE_ENVIRONMENT

if test "$cross_compiling"  = "yes"; then
    CROSS_COMPILE=1
else
    CROSS_COMPILE=
fi

# Check to see if we are running in a broken QEMU scratchbox.
# We know that anything below 1.0.16 is broken.
AC_CHECK_PROGS(SBCONF, sb-conf ve, "")
if test -n "$SBCONF"; then
    _sb_version=`$SBCONF ve`
    _sb_version_major=`echo $_sb_version | cut -f1 -d.`
    _sb_version_minor=`echo $_sb_version | cut -f2 -d.`
    _sb_version_point=`echo $_sb_version | cut -f3 -d.`
    if test $_sb_version_major -eq 1 -a $_sb_version_minor -eq 0 -a $_sb_version_point -le 16; then
        QEMU_CANT_RUN_JS_SHELL=1
    fi
fi
AC_SUBST(QEMU_CANT_RUN_JS_SHELL)

AC_SUBST(_MSC_VER)

AC_SUBST(GNU_AS)
AC_SUBST(GNU_LD)
AC_SUBST(GNU_CC)
AC_SUBST(GNU_CXX)
AC_SUBST(INTEL_CC)
AC_SUBST(INTEL_CXX)

dnl ========================================================
dnl Checks for programs.
dnl ========================================================
AC_PROG_INSTALL
AC_PROG_LN_S

if test -z "$TINDERBOX_SKIP_PERL_VERSION_CHECK"; then
AC_MSG_CHECKING([for minimum required perl version >= $PERL_VERSION])
_perl_version=`PERL_VERSION=$PERL_VERSION $PERL -e 'print "$]"; if ($] >= $ENV{PERL_VERSION}) { exit(0); } else { exit(1); }' 2>&5`
_perl_res=$?
AC_MSG_RESULT([$_perl_version])

if test "$_perl_res" != 0; then
    AC_MSG_ERROR([Perl $PERL_VERSION or higher is required.])
fi
fi

AC_MSG_CHECKING([for full perl installation])
_perl_archlib=`$PERL -e 'use Config; if ( -d $Config{archlib} ) { exit(0); } else { exit(1); }' 2>&5`
_perl_res=$?
if test "$_perl_res" != 0; then
    AC_MSG_RESULT([no])
    AC_MSG_ERROR([Cannot find Config.pm or \$Config{archlib}.  A full perl installation is required.])
else
    AC_MSG_RESULT([yes])
fi

MOZ_PYTHON

if test -z "$COMPILE_ENVIRONMENT"; then
    NSINSTALL_BIN='$(PYTHON) $(topsrcdir)/config/nsinstall.py'
fi
AC_SUBST(NSINSTALL_BIN)

MOZ_PATH_PROG(DOXYGEN, doxygen, :)
MOZ_PATH_PROG(AUTOCONF, autoconf, :)
MOZ_PATH_PROG(XARGS, xargs)
if test -z "$XARGS" -o "$XARGS" = ":"; then
    AC_MSG_ERROR([xargs not found in \$PATH .])
fi

if test "$COMPILE_ENVIRONMENT"; then

dnl ========================================================
dnl = Mac OS X toolchain support
dnl ========================================================

dnl The universal machinery sets UNIVERSAL_BINARY to inform packager.mk
dnl that a universal binary is being produced and MOZ_CAN_RUN_PROGRAMS
dnl when we can run target binaries.
AC_SUBST(UNIVERSAL_BINARY)
AC_SUBST(MOZ_CAN_RUN_PROGRAMS)

dnl ========================================================
dnl Check for MacOS deployment target version
dnl ========================================================

MOZ_ARG_ENABLE_STRING(macos-target,
                      [  --enable-macos-target=VER (default=10.6)
                          Set the minimum MacOS version needed at runtime],
                      [_MACOSX_DEPLOYMENT_TARGET=$enableval])

if test "$target_cpu" != "arm"; then
case "$target" in
*-darwin*)
    if test -n "$_MACOSX_DEPLOYMENT_TARGET" ; then
        dnl Use the specified value
        export MACOSX_DEPLOYMENT_TARGET=$_MACOSX_DEPLOYMENT_TARGET
    else
        dnl No value specified on the command line or in the environment,
        dnl use architecture minimum.
        export MACOSX_DEPLOYMENT_TARGET=10.6
    fi
    ;;
esac
fi

AC_SUBST(MACOSX_DEPLOYMENT_TARGET)

dnl ========================================================
dnl = Mac OS X SDK support
dnl ========================================================
MACOS_SDK_DIR=
NEXT_ROOT=
MOZ_ARG_WITH_STRING(macos-sdk,
[  --with-macos-sdk=dir    Location of platform SDK to use (Mac OS X only)],
    MACOS_SDK_DIR=$withval)

dnl MACOS_SDK_DIR will be set to the SDK location whenever one is in use.
dnl NEXT_ROOT will be set and exported only if it's needed.
AC_SUBST(MACOS_SDK_DIR)
AC_SUBST(NEXT_ROOT)

if test "$MACOS_SDK_DIR"; then
  dnl Sync this section with the ones in NSPR and NSS.
  dnl Changes to the cross environment here need to be accounted for in
  dnl the libIDL checks (below) and xpidl build.

  if test ! -d "$MACOS_SDK_DIR"; then
    AC_MSG_ERROR([SDK not found.  When using --with-macos-sdk, you must
specify a valid SDK.  SDKs are installed when the optional cross-development
tools are selected during the Xcode/Developer Tools installation.])
  fi

  CFLAGS="$CFLAGS -isysroot ${MACOS_SDK_DIR}"
  CXXFLAGS="$CXXFLAGS -isysroot ${MACOS_SDK_DIR}"

  dnl CPP/CXXCPP needs to be set for MOZ_CHECK_HEADER.
  CPP="$CPP -isysroot ${MACOS_SDK_DIR}"
  CXXCPP="$CXXCPP -isysroot ${MACOS_SDK_DIR}"

  AC_LANG_SAVE
  AC_MSG_CHECKING([for valid compiler/Mac OS X SDK combination])
  AC_LANG_CPLUSPLUS
  AC_TRY_COMPILE([#include <new>
                 int main() { return 0; }],
   result=yes,
   result=no)
  AC_LANG_RESTORE
  AC_MSG_RESULT($result)

  if test "$result" = "no" ; then
    AC_MSG_ERROR([The selected compiler and Mac OS X SDK are incompatible.])
  fi
fi

fi # COMPILE_ENVIRONMENT

if test -n "$MAKE"; then
  if test `echo $MAKE | grep -c make.py` != 1; then
     NOT_PYMAKE=$MAKE
  fi
fi

case "$host_os" in
mingw*)
    MOZ_PATH_PROGS(GMAKE, $GMAKE $NOT_PYMAKE make gmake, :)
    ;;
*)
    MOZ_PATH_PROGS(GMAKE, $GMAKE $NOT_PYMAKE gmake make, :)
    ;;
esac
if test "$GMAKE" = ":"; then
   AC_MSG_ERROR([GNU make not found])
fi

# MAKE will be set by client.mk, but still need this for standalone js builds
if test -z "$MAKE"; then
  MAKE=$GMAKE
fi

if test "$COMPILE_ENVIRONMENT"; then

AC_PATH_XTRA

XCFLAGS="$X_CFLAGS"

fi # COMPILE_ENVIRONMENT

dnl ========================================================
dnl set the defaults first
dnl ========================================================
AS_BIN=$AS
AR_LIST='$(AR) t'
AR_EXTRACT='$(AR) x'
AR_DELETE='$(AR) d'
AS='$(CC)'
AS_DASH_C_FLAG='-c'
DLL_PREFIX=lib
LIB_PREFIX=lib
DLL_SUFFIX=.so
OBJ_SUFFIX=o
LIB_SUFFIX=a
ASM_SUFFIX=s
IMPORT_LIB_SUFFIX=
TARGET_MD_ARCH=unix
DIRENT_INO=d_ino
MOZ_USER_DIR=".mozilla"

MOZ_JS_LIBS='-L$(libdir) -lmozjs'
MOZ_FIX_LINK_PATHS='-Wl,-rpath-link,$(LIBXUL_DIST)/bin -Wl,-rpath-link,$(prefix)/lib'

MOZ_COMPONENT_NSPR_LIBS='-L$(LIBXUL_DIST)/bin $(NSPR_LIBS)'

USE_DEPENDENT_LIBS=1

_PLATFORM_DEFAULT_TOOLKIT=cairo-gtk2

if test -n "$CROSS_COMPILE"; then
    OS_TARGET="${target_os}"
    OS_ARCH=`echo $target_os | sed -e 's|/|_|g'`
    OS_RELEASE=
    case "${target_os}" in
        linux*)       OS_ARCH=Linux OS_TARGET=Linux ;;
        kfreebsd*-gnu) OS_ARCH=GNU_kFreeBSD OS_TARGET=GNU_kFreeBSD ;;
        gnu*)         OS_ARCH=GNU ;;
        solaris*)     OS_ARCH=SunOS OS_RELEASE=5 ;;
        mingw*)       OS_ARCH=WINNT OS_TARGET=WINNT ;;
        darwin*)      OS_ARCH=Darwin OS_TARGET=Darwin ;;
    esac
    case "${target}" in
        *-android*|*-linuxandroid*) OS_ARCH=Linux OS_TARGET=Android ;;
    esac
else
    OS_TARGET=`uname -s`
    OS_ARCH=`uname -s | sed -e 's|/|_|g'`
    OS_RELEASE=`uname -r`
fi

# Before this used `uname -m` when not cross compiling
# but that breaks when you have a 64 bit kernel with a 32 bit userland.
OS_TEST="${target_cpu}"

HOST_OS_ARCH=`echo $host_os | sed -e 's|/|_|g'`

#######################################################################
# Master "Core Components" macros for getting the OS target           #
#######################################################################

#
# If OS_TARGET is not specified, it defaults to $(OS_ARCH), i.e., no
# cross-compilation.
#

#
# Define and override various archtecture-specific variables, including
# HOST_OS_ARCH
# OS_ARCH
# OS_TEST
# OS_TARGET
# OS_RELEASE
# OS_MINOR_RELEASE
#

case "$HOST_OS_ARCH" in
mingw*)
    HOST_OS_ARCH=WINNT
    ;;
darwin*)
    HOST_OS_ARCH=Darwin
    ;;
linux*)
    HOST_OS_ARCH=Linux
    ;;
solaris*)
    HOST_OS_ARCH=SunOS
    SOLARIS_SUNPRO_CC=
    SOLARIS_SUNPRO_CXX=
    if test -z "$GNU_CC"; then
        if test "`$CC -V 2>&1 | egrep -c 'Sun.*C '`" != "0"; then
            SOLARIS_SUNPRO_CC=1
       fi
    fi

    if test -z "$GNU_CXX"; then
       if test "`$CXX -V 2>&1 | egrep -c 'Sun.*C\+\+ '`" != "0"; then
           SOLARIS_SUNPRO_CXX=1
       fi
    fi
    AC_SUBST(SOLARIS_SUNPRO_CC)
    AC_SUBST(SOLARIS_SUNPRO_CXX)
    ;;
OS_2)
    HOST_OS_ARCH=OS2
    ;;
esac

case "$OS_ARCH" in
WINNT)
    if test -z "$CROSS_COMPILE" ; then
        OS_TEST=`uname -p`
    fi
    ;;
Windows_NT)
#
# If uname -s returns "Windows_NT", we assume that we are using
# the uname.exe in MKS toolkit.
#
# The -r option of MKS uname only returns the major version number.
# So we need to use its -v option to get the minor version number.
# Moreover, it doesn't have the -p option, so we need to use uname -m.
#
    OS_ARCH=WINNT
    OS_TARGET=WINNT
    OS_MINOR_RELEASE=`uname -v`
    if test "$OS_MINOR_RELEASE" = "00"; then
        OS_MINOR_RELEASE=0
    fi
    OS_RELEASE="${OS_RELEASE}.${OS_MINOR_RELEASE}"
    ;;
MINGW*_NT*)
#
# If uname -s returns MINGW32_NT-5.1, we assume that we are using
# the uname.exe in the MSYS tools.
#
    OS_RELEASE=`expr $OS_ARCH : '.*NT-\(.*\)'`
    OS_ARCH=WINNT
    OS_TARGET=WINNT
    ;;
AIX)
    OS_RELEASE=`uname -v`.`uname -r`
    OS_TEST=${target_cpu}
    if test -z "$GNU_CC"; then
        if test "`$CC -qversion 2>&1 | egrep -c 'IBM XL'`" != "0"; then
            AIX_IBM_XLC=1
        fi
    fi
    ;;
OS_2)
    OS_ARCH=OS2
    OS_TARGET=OS2
    OS_RELEASE=`uname -v`
    ;;
Darwin)
    case "${target_cpu}" in
    powerpc*)
        OS_TEST=ppc
        ;;
    i*86*)
        OS_TEST=i386
        ;;
    x86_64)
        OS_TEST=x86_64
        ;;
    *)
        if test -z "$CROSS_COMPILE" ; then
            OS_TEST=`uname -p`
        fi
        ;;
    esac
    ;;
esac

# Only set CPU_ARCH if we recognize the value of OS_TEST

case "$OS_TEST" in
*86 | i86pc)
    CPU_ARCH=x86
    ;;

powerpc64 | ppc64)
    CPU_ARCH=ppc64
    ;;

powerpc | ppc | rs6000)
    CPU_ARCH=ppc
    ;;

Alpha | alpha | ALPHA)
    CPU_ARCH=Alpha
    ;;

s390)
    CPU_ARCH=s390
    ;;

s390x)
    CPU_ARCH=s390x
    ;;

hppa* | parisc)
    CPU_ARCH=hppa
    ;;

sun4u | sparc*)
    CPU_ARCH=sparc
    ;;

x86_64 | ia64)
    CPU_ARCH="$OS_TEST"
    ;;

arm*)
    CPU_ARCH=arm
    ;;

mips|mipsel)
    CPU_ARCH="mips"
    ;;
esac

if test -z "$OS_TARGET"; then
    OS_TARGET=$OS_ARCH
fi
OS_CONFIG="${OS_TARGET}${OS_RELEASE}"

dnl Set INTEL_ARCHITECTURE if we're compiling for x86-32 or x86-64.
dnl ===============================================================
INTEL_ARCHITECTURE=
case "$OS_TEST" in
    x86_64|i?86)
      INTEL_ARCHITECTURE=1
esac

dnl Configure platform-specific CPU architecture compiler options.
dnl ==============================================================
MOZ_ARCH_OPTS

dnl =================================================================
dnl Set up and test static assertion macros used to avoid AC_TRY_RUN,
dnl which is bad when cross compiling.
dnl =================================================================
if test "$COMPILE_ENVIRONMENT"; then
configure_static_assert_macros='
#define CONFIGURE_STATIC_ASSERT(condition) CONFIGURE_STATIC_ASSERT_IMPL(condition, __LINE__)
#define CONFIGURE_STATIC_ASSERT_IMPL(condition, line) CONFIGURE_STATIC_ASSERT_IMPL2(condition, line)
#define CONFIGURE_STATIC_ASSERT_IMPL2(condition, line) typedef int static_assert_line_##line[(condition) ? 1 : -1]
'

dnl test that the macros actually work:
AC_MSG_CHECKING(that static assertion macros used in autoconf tests work)
AC_CACHE_VAL(ac_cv_static_assertion_macros_work,
 [AC_LANG_SAVE
  AC_LANG_C
  ac_cv_static_assertion_macros_work="yes"
  AC_TRY_COMPILE([$configure_static_assert_macros],
                 [CONFIGURE_STATIC_ASSERT(1)],
                 ,
                 ac_cv_static_assertion_macros_work="no")
  AC_TRY_COMPILE([$configure_static_assert_macros],
                 [CONFIGURE_STATIC_ASSERT(0)],
                 ac_cv_static_assertion_macros_work="no",
                 )
  AC_LANG_CPLUSPLUS
  AC_TRY_COMPILE([$configure_static_assert_macros],
                 [CONFIGURE_STATIC_ASSERT(1)],
                 ,
                 ac_cv_static_assertion_macros_work="no")
  AC_TRY_COMPILE([$configure_static_assert_macros],
                 [CONFIGURE_STATIC_ASSERT(0)],
                 ac_cv_static_assertion_macros_work="no",
                 )
  AC_LANG_RESTORE
 ])
AC_MSG_RESULT("$ac_cv_static_assertion_macros_work")
if test "$ac_cv_static_assertion_macros_work" = "no"; then
    AC_MSG_ERROR([Compiler cannot compile macros used in autoconf tests.])
fi
fi # COMPILE_ENVIRONMENT

dnl ========================================================
dnl Android libstdc++, placed here so it can use MOZ_ARCH
dnl computed above.
dnl ========================================================

MOZ_ANDROID_STLPORT

dnl ========================================================
dnl Suppress Clang Argument Warnings
dnl ========================================================
if test -n "$CLANG_CC"; then
    _WARNINGS_CFLAGS="-Qunused-arguments ${_WARNINGS_CFLAGS}"
    CPPFLAGS="-Qunused-arguments ${CPPFLAGS}"
fi
if test -n "$CLANG_CXX"; then
    _WARNINGS_CXXFLAGS="-Qunused-arguments ${_WARNINGS_CXXFLAGS}"
fi

dnl ========================================================
dnl = Use Address Sanitizer
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(address-sanitizer,
[  --enable-address-sanitizer       Enable Address Sanitizer (default=no)],
    MOZ_ASAN=1,
    MOZ_ASAN= )
if test -n "$MOZ_ASAN"; then
    MOZ_LLVM_HACKS=1
    AC_DEFINE(MOZ_ASAN)
fi
AC_SUBST(MOZ_ASAN)

dnl ========================================================
dnl = Enable hacks required for LLVM instrumentations
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(llvm-hacks,
[  --enable-llvm-hacks       Enable workarounds required for several LLVM instrumentations (default=no)],
    MOZ_LLVM_HACKS=1,
    MOZ_LLVM_HACKS= )
if test -n "$MOZ_LLVM_HACKS"; then
    MOZ_NO_WLZDEFS=1
fi

dnl ========================================================
dnl GNU specific defaults
dnl ========================================================
if test "$GNU_CC"; then
    # Per bug 719659 comment 2, some of the headers on ancient build machines
    # may require gnu89 inline semantics.  But otherwise, we use C99.
    CFLAGS="$CFLAGS -std=gnu99 -fgnu89-inline"
    MKSHLIB='$(CXX) $(CXXFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -Wl,-h,$@ -o $@'
    MKCSHLIB='$(CC) $(CFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -Wl,-h,$@ -o $@'
    DSO_LDOPTS='-shared'
    if test "$GCC_USE_GNU_LD"; then
        # Some tools like ASan use a runtime library that is only
        # linked against executables, so we must allow undefined
        # symbols for shared objects in some cases.
        if test -z "$MOZ_NO_WLZDEFS"; then
            # Don't allow undefined symbols in libraries
            DSO_LDOPTS="$DSO_LDOPTS -Wl,-z,defs"
        fi
    fi
    WARNINGS_AS_ERRORS='-Werror'
    # Don't treat -Wuninitialized as error b/c it has lots of false positives.
    WARNINGS_AS_ERRORS="$WARNINGS_AS_ERRORS -Wno-error=uninitialized"
    # Don't treat -Wdeprecated-declarations as error b/c we don't want our
    # builds held hostage when a platform-specific API is suddenly deprecated.
    WARNINGS_AS_ERRORS="$WARNINGS_AS_ERRORS -Wno-error=deprecated-declarations"
    DSO_CFLAGS=''
    DSO_PIC_CFLAGS='-fPIC'
    ASFLAGS="$ASFLAGS -fPIC"

    AC_MSG_CHECKING([for --build-id option to ld])
    _SAVE_LDFLAGS=$LDFLAGS
    LDFLAGS="$LDFLAGS -Wl,--build-id"
    AC_TRY_LINK(,,AC_MSG_RESULT([yes]),
                  AC_MSG_RESULT([no])
                  LDFLAGS=$_SAVE_LDFLAGS)

    # Turn on GNU-specific warnings:
    # -Wall - turn on a lot of warnings
    # -Wpointer-arith - good to have
    # -Wdeclaration-after-statement - MSVC doesn't like these
    # -Werror=return-type - catches missing returns, zero false positives
    # -Wtype-limits - catches overflow bugs, few false positives
    # -Wempty-body - catches bugs, e.g. "if (c); foo();", few false positives
    #
    _WARNINGS_CFLAGS="${_WARNINGS_CFLAGS} -Wall -Wpointer-arith -Wdeclaration-after-statement"
    MOZ_C_SUPPORTS_WARNING(-W, error=return-type, ac_c_has_werror_return_type)
    MOZ_C_SUPPORTS_WARNING(-W, type-limits, ac_c_has_wtype_limits)
    MOZ_C_SUPPORTS_WARNING(-W, empty-body, ac_c_has_wempty_body)

    # Turn off the following warnings that -Wall turns on:
    # -Wno-unused - lots of violations in third-party code
    #
    _WARNINGS_CFLAGS="${_WARNINGS_CFLAGS} -Wno-unused"

    if test -z "$INTEL_CC" -a -z "$CLANG_CC"; then
       # Don't use -Wcast-align with ICC or clang
       case "$CPU_ARCH" in
           # And don't use it on hppa, ia64, sparc, arm, since it's noisy there
           hppa | ia64 | sparc | arm)
           ;;
           *)
        _WARNINGS_CFLAGS="${_WARNINGS_CFLAGS} -Wcast-align"
           ;;
       esac
    fi

    _DEFINES_CFLAGS='-include $(DEPTH)/js-confdefs.h -DMOZILLA_CLIENT'
    _USE_CPP_INCLUDE_FLAG=1

elif test "$SOLARIS_SUNPRO_CC"; then
    DSO_CFLAGS=''
    if test "$CPU_ARCH" = "sparc"; then
        # for Sun Studio on Solaris/SPARC
        DSO_PIC_CFLAGS='-xcode=pic32'
    else
        DSO_PIC_CFLAGS='-KPIC'
    fi
    _DEFINES_CFLAGS='$(ACDEFINES) -D_JS_CONFDEFS_H_ -DMOZILLA_CLIENT'
else
    MKSHLIB='$(LD) $(DSO_LDOPTS) -h $@ -o $@'
    MKCSHLIB='$(LD) $(DSO_LDOPTS) -h $@ -o $@'

    DSO_LDOPTS='-shared'
    if test "$GNU_LD"; then
        # Don't allow undefined symbols in libraries
        DSO_LDOPTS="$DSO_LDOPTS -z defs"
    fi

    DSO_CFLAGS=''
    DSO_PIC_CFLAGS='-KPIC'
    _DEFINES_CFLAGS='$(ACDEFINES) -D_JS_CONFDEFS_H_ -DMOZILLA_CLIENT'
fi

if test "$GNU_CXX"; then
    # Turn on GNU-specific warnings:
    # -Wall - turn on a lot of warnings
    # -Wpointer-arith - good to have
    # -Woverloaded-virtual - ???
    # -Werror=return-type - catches missing returns, zero false positives
    # -Wtype-limits - catches overflow bugs, few false positives
    # -Wempty-body - catches bugs, e.g. "if (c); foo();", few false positives
    # -Werror=conversion-null - catches conversions between NULL and non-pointer types
    #
    _WARNINGS_CXXFLAGS="${_WARNINGS_CXXFLAGS} -Wall -Wpointer-arith -Woverloaded-virtual"
    MOZ_CXX_SUPPORTS_WARNING(-W, error=return-type, ac_cxx_has_werror_return_type)
    MOZ_CXX_SUPPORTS_WARNING(-W, type-limits, ac_cxx_has_wtype_limits)
    MOZ_CXX_SUPPORTS_WARNING(-W, empty-body, ac_cxx_has_wempty_body)
    MOZ_CXX_SUPPORTS_WARNING(-W, error=conversion-null, ac_cxx_has_werror_conversion_null)

    # Turn off the following warnings that -Wall turns on:
    # -Wno-invalid-offsetof - we use offsetof on non-POD types frequently
    #
    MOZ_CXX_SUPPORTS_WARNING(-Wno-, invalid-offsetof, ac_cxx_has_wno_invalid_offsetof)

    if test -z "$INTEL_CXX" -a -z "$CLANG_CXX"; then
       # Don't use -Wcast-align with ICC or clang
       case "$CPU_ARCH" in
           # And don't use it on hppa, ia64, sparc, arm, since it's noisy there
           hppa | ia64 | sparc | arm)
           ;;
           *)
        _WARNINGS_CXXFLAGS="${_WARNINGS_CXXFLAGS} -Wcast-align"
           ;;
       esac
    fi

    _DEFINES_CXXFLAGS='-DMOZILLA_CLIENT -include $(DEPTH)/js-confdefs.h'
    _USE_CPP_INCLUDE_FLAG=1

    # Recent clang and gcc support C++11 deleted functions without warnings if
    # compiling with -std=c++0x or -std=gnu++0x (or c++11 or gnu++11 in very new
    # versions).  We can't use -std=c++0x yet, so gcc's support must remain
    # unused.  But clang's warning can be disabled, so when compiling with clang
    # we use it to opt out of the warning, enabling (macro-encapsulated) use of
    # deleted function syntax.
    if test "$CLANG_CXX"; then
        _WARNINGS_CXXFLAGS="${_WARNINGS_CXXFLAGS} -Wno-c++0x-extensions"
        MOZ_CXX_SUPPORTS_WARNING(-Wno-, extended-offsetof, ac_cxx_has_wno_extended_offsetof)
    fi

else
    _DEFINES_CXXFLAGS='-DMOZILLA_CLIENT -D_JS_CONFDEFS_H_ $(ACDEFINES)'
fi

dnl gcc can come with its own linker so it is better to use the pass-thru calls
dnl MKSHLIB_FORCE_ALL is used to force the linker to include all object
dnl files present in an archive. MKSHLIB_UNFORCE_ALL reverts the linker to
dnl normal behavior.
dnl ========================================================
MKSHLIB_FORCE_ALL=
MKSHLIB_UNFORCE_ALL=

if test "$COMPILE_ENVIRONMENT"; then
if test "$GNU_CC"; then
  AC_MSG_CHECKING(whether ld has archive extraction flags)
  AC_CACHE_VAL(ac_cv_mkshlib_force_and_unforce,
   [_SAVE_LDFLAGS=$LDFLAGS; _SAVE_LIBS=$LIBS
    ac_cv_mkshlib_force_and_unforce="no"
    exec 3<&0 <<LOOP_INPUT
	force="-Wl,--whole-archive";   unforce="-Wl,--no-whole-archive"
	force="-Wl,-z -Wl,allextract"; unforce="-Wl,-z -Wl,defaultextract"
	force="-Wl,-all";              unforce="-Wl,-none"
LOOP_INPUT
    while read line
    do
      eval $line
      LDFLAGS=$force
      LIBS=$unforce
      AC_TRY_LINK(,, ac_cv_mkshlib_force_and_unforce=$line; break)
    done
    exec 0<&3 3<&-
    LDFLAGS=$_SAVE_LDFLAGS; LIBS=$_SAVE_LIBS
   ])
  if test "$ac_cv_mkshlib_force_and_unforce" = "no"; then
    AC_MSG_RESULT(no)
  else
    AC_MSG_RESULT(yes)
    eval $ac_cv_mkshlib_force_and_unforce
    MKSHLIB_FORCE_ALL=$force
    MKSHLIB_UNFORCE_ALL=$unforce
  fi
fi # GNU_CC
fi # COMPILE_ENVIRONMENT

dnl ========================================================
dnl Checking for 64-bit OS
dnl ========================================================
if test "$COMPILE_ENVIRONMENT"; then
AC_LANG_SAVE
AC_LANG_C
AC_MSG_CHECKING(for 64-bit OS)
AC_TRY_COMPILE([$configure_static_assert_macros],
               [CONFIGURE_STATIC_ASSERT(sizeof(void*) == 8)],
               result="yes", result="no")
AC_MSG_RESULT("$result")
if test "$result" = "yes"; then
    AC_DEFINE(HAVE_64BIT_OS)
    HAVE_64BIT_OS=1
fi
AC_SUBST(HAVE_64BIT_OS)
AC_LANG_RESTORE
fi # COMPILE_ENVIRONMENT

dnl ========================================================
dnl Enable high-memory support on OS/2 by default.
dnl ========================================================
MOZ_OS2_HIGH_MEMORY=1
MOZ_ARG_DISABLE_BOOL(os2-high-mem,
[  --disable-os2-high-mem  Disable high-memory support on OS/2],
    MOZ_OS2_HIGH_MEMORY=,
    MOZ_OS2_HIGH_MEMORY=1 )
AC_SUBST(MOZ_OS2_HIGH_MEMORY)

dnl ========================================================
dnl = Use profiling compile flags
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(profiling,
[  --enable-profiling      Set compile flags necessary for using sampling profilers (e.g. shark, perf)],
    MOZ_PROFILING=1,
    MOZ_PROFILING= )

dnl ========================================================
dnl System overrides of the defaults for host
dnl ========================================================
case "$host" in
*mingw*)
    if test -n "$_WIN32_MSVC"; then
        HOST_AR=lib
        HOST_AR_FLAGS='-NOLOGO -OUT:"$@"'
        HOST_CFLAGS="$HOST_CFLAGS -TC -nologo -Fd\$(HOST_PDBFILE)"
        HOST_RANLIB='echo ranlib'
    else
        HOST_CFLAGS="$HOST_CFLAGS -mwindows"
    fi
    HOST_CFLAGS="$HOST_CFLAGS -DXP_WIN32 -DXP_WIN -DWIN32 -D_WIN32 -DNO_X11 -D_CRT_SECURE_NO_WARNINGS"
    HOST_NSPR_MDCPUCFG='\"md/_winnt.cfg\"'
    HOST_OPTIMIZE_FLAGS="${HOST_OPTIMIZE_FLAGS=-O2}"
    HOST_BIN_SUFFIX=.exe
    case "$host" in
    *mingw*)
        PERL="/bin/sh ${_topsrcdir}/build/msys-perl-wrapper"
        ;;
    esac

    case "${host_cpu}" in
    i*86)
        if test -n "$_WIN32_MSVC"; then
            HOST_LDFLAGS="$HOST_LDFLAGS -MACHINE:X86"
        fi
        ;;
    x86_64)
        if test -n "$_WIN32_MSVC"; then
            HOST_LDFLAGS="$HOST_LDFLAGS -MACHINE:X64"
        fi
        HOST_CFLAGS="$HOST_CFLAGS -D_AMD64_"
        ;;
    esac
    ;;

*-darwin*)
    HOST_CFLAGS="$HOST_CFLAGS -DXP_UNIX -DXP_MACOSX -DNO_X11"
    HOST_NSPR_MDCPUCFG='\"md/_darwin.cfg\"'
    HOST_OPTIMIZE_FLAGS="${HOST_OPTIMIZE_FLAGS=-O3}"
    ;;

*-linux*|*-kfreebsd*-gnu|*-gnu*)
    HOST_CFLAGS="$HOST_CFLAGS -DXP_UNIX"
    HOST_NSPR_MDCPUCFG='\"md/_linux.cfg\"'
    HOST_OPTIMIZE_FLAGS="${HOST_OPTIMIZE_FLAGS=-O3}"
    ;;

*os2*)
    HOST_CFLAGS="$HOST_CFLAGS -DXP_OS2 -DNO_X11 -Zomf"
    HOST_NSPR_MDCPUCFG='\"md/_os2.cfg\"'
    HOST_OPTIMIZE_FLAGS="${HOST_OPTIMIZE_FLAGS=-O2}"
    HOST_BIN_SUFFIX=.exe
    MOZ_FIX_LINK_PATHS=
    ;;

*)
    HOST_CFLAGS="$HOST_CFLAGS -DXP_UNIX"
    HOST_OPTIMIZE_FLAGS="${HOST_OPTIMIZE_FLAGS=-O2}"
    ;;
esac

dnl Check for using a custom <stdint.h> implementation
dnl ========================================================
AC_MSG_CHECKING(for custom <stdint.h> implementation)
if test "$MOZ_CUSTOM_STDINT_H"; then
  AC_DEFINE_UNQUOTED(MOZ_CUSTOM_STDINT_H, "$MOZ_CUSTOM_STDINT_H")
  AC_MSG_RESULT(using $MOZ_CUSTOM_STDINT_H)
else
  AC_MSG_RESULT(none specified)
fi

MOZ_DOING_LTO(lto_is_enabled)

dnl ========================================================
dnl System overrides of the defaults for target
dnl ========================================================

case "$target" in
*-aix*)
    AC_DEFINE(AIX)
    if test ! "$GNU_CC"; then
        if test ! "$HAVE_64BIT_OS"; then
            # Compiling with Visual Age C++ object model compat is the
            # default. To compile with object model ibm, add
            # AIX_OBJMODEL=ibm to .mozconfig.
            if test "$AIX_OBJMODEL" = "ibm"; then
                CXXFLAGS="$CXXFLAGS -qobjmodel=ibm"
            else
                AIX_OBJMODEL=compat
            fi
        else
            AIX_OBJMODEL=compat
        fi
        AC_SUBST(AIX_OBJMODEL)
        DSO_LDOPTS='-qmkshrobj=1'
        DSO_CFLAGS='-qflag=w:w'
        DSO_PIC_CFLAGS=
        LDFLAGS="$LDFLAGS -Wl,-brtl -blibpath:/usr/lib:/lib"
        MOZ_FIX_LINK_PATHS=
        MKSHLIB='$(CXX) $(DSO_LDOPTS) -o $@'
        MKCSHLIB='$(CC) $(DSO_LDOPTS) -o $@'
        if test "$COMPILE_ENVIRONMENT"; then
            AC_LANG_SAVE
            AC_LANG_CPLUSPLUS
            AC_MSG_CHECKING([for IBM XLC/C++ compiler version >= 9.0.0.7])
            AC_TRY_COMPILE([],
                [#if (__IBMCPP__ < 900)
                 #error "Bad compiler"
                 #endif],
                _BAD_COMPILER=,_BAD_COMPILER=1)
            if test -n "$_BAD_COMPILER"; then
                AC_MSG_RESULT([no])
                AC_MSG_ERROR([IBM XLC/C++ 9.0.0.7 or higher is required to build.])
            else
                AC_MSG_RESULT([yes])
            fi
            AC_LANG_RESTORE
            TARGET_COMPILER_ABI="ibmc"
            CC_VERSION=`lslpp -Lcq vac.C 2>/dev/null | awk -F: '{ print $3 }'`
            CXX_VERSION=`lslpp -Lcq vacpp.cmp.core 2>/dev/null | awk -F: '{ print $3 }'`
        fi
    fi
    case "${target_os}" in
    aix4.1*)
        DLL_SUFFIX='_shr.a'
        ;;
    esac
    if test "$COMPILE_ENVIRONMENT"; then
        MOZ_CHECK_HEADERS(sys/inttypes.h)
    fi
    AC_DEFINE(JS_SYS_TYPES_H_DEFINES_EXACT_SIZE_TYPES)
    AC_DEFINE(NSCAP_DISABLE_DEBUG_PTR_TYPES)
    ;;

*-darwin*)
    MKSHLIB='$(CXX) $(CXXFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -o $@'
    MKCSHLIB='$(CC) $(CFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -o $@'
    MOZ_OPTIMIZE_FLAGS="-O3 -fno-stack-protector"
    CFLAGS="$CFLAGS -fno-common"
    CXXFLAGS="$CXXFLAGS -fno-common"
    DLL_SUFFIX=".dylib"
    DSO_LDOPTS=''
    STRIP="$STRIP -x -S"
    _PLATFORM_DEFAULT_TOOLKIT='cairo-cocoa'
    TARGET_NSPR_MDCPUCFG='\"md/_darwin.cfg\"'
    LDFLAGS="$LDFLAGS -lobjc"
    LIBXUL_LIBS='$(XPCOM_FROZEN_LDOPTS) $(LIBXUL_DIST)/bin/XUL'
    # The ExceptionHandling framework is needed for Objective-C exception
    # logging code in nsObjCExceptions.h. Currently we only use that in debug
    # builds.
    _SAVE_LDFLAGS=$LDFLAGS
     AC_MSG_CHECKING([for -framework ExceptionHandling])
    LDFLAGS="$LDFLAGS -framework ExceptionHandling"
    AC_TRY_LINK(,[return 0;],
                ac_cv_have_framework_exceptionhandling="yes",
                ac_cv_have_framework_exceptionhandling="no")
    AC_MSG_RESULT([$ac_cv_have_framework_exceptionhandling])
    if test  "$ac_cv_have_framework_exceptionhandling" = "yes"; then
      MOZ_DEBUG_LDFLAGS="$MOZ_DEBUG_LDFLAGS -framework ExceptionHandling";
    fi
    LDFLAGS=$_SAVE_LDFLAGS

    if test "x$lto_is_enabled" = "xyes"; then
        echo "Skipping -dead_strip because lto is enabled."
    dnl DTrace and -dead_strip don't interact well. See bug 403132.
    dnl ===================================================================
    elif test "x$enable_dtrace" = "xyes"; then
        echo "Skipping -dead_strip because DTrace is enabled. See bug 403132."
    else
        dnl check for the presence of the -dead_strip linker flag
        AC_MSG_CHECKING([for -dead_strip option to ld])
        _SAVE_LDFLAGS=$LDFLAGS
        LDFLAGS="$LDFLAGS -Wl,-dead_strip"
        AC_TRY_LINK(,[return 0;],_HAVE_DEAD_STRIP=1,_HAVE_DEAD_STRIP=)
        if test -n "$_HAVE_DEAD_STRIP" ; then
            AC_MSG_RESULT([yes])
            MOZ_OPTIMIZE_LDFLAGS="-Wl,-dead_strip"
        else
            AC_MSG_RESULT([no])
        fi

        LDFLAGS=$_SAVE_LDFLAGS
    fi
    MOZ_FIX_LINK_PATHS='-Wl,-executable_path,$(LIBXUL_DIST)/bin'
    ;;

ia64*-hpux*)
    DLL_SUFFIX=".so"
    if test ! "$GNU_CC"; then
       DSO_LDOPTS='-b'
       DSO_CFLAGS=""
       DSO_PIC_CFLAGS=
       MKSHLIB='$(CXX) $(CXXFLAGS) $(DSO_LDOPTS) -o $@'
       MKCSHLIB='$(CC) $(CFLAGS) $(DSO_LDOPTS) -o $@'
       CXXFLAGS="$CXXFLAGS -Wc,-ansi_for_scope,on"
    else
       DSO_LDOPTS='-b -E'
       MKSHLIB='$(LD) $(DSO_LDOPTS) -o $@'
       MKCSHLIB='$(LD) $(DSO_LDOPTS) -o $@'
    fi
    MOZ_FIX_LINK_PATHS=
    AC_DEFINE(NSCAP_DISABLE_DEBUG_PTR_TYPES)
    AC_DEFINE(_LARGEFILE64_SOURCE)
    ;;

*-hpux*)
    DLL_SUFFIX=".sl"
    if test ! "$GNU_CC"; then
    	DSO_LDOPTS='-b -Wl,+s'
    	DSO_CFLAGS=""
    	DSO_PIC_CFLAGS="+Z"
    	MKSHLIB='$(CXX) $(CXXFLAGS) $(DSO_LDOPTS) -L$(LIBXUL_DIST)/bin -o $@'
    	MKCSHLIB='$(LD) -b +s -L$(LIBXUL_DIST)/bin -o $@'
        CXXFLAGS="$CXXFLAGS -Wc,-ansi_for_scope,on"
    else
        DSO_LDOPTS='-b -E +s'
        MKSHLIB='$(LD) $(DSO_LDOPTS) -L$(LIBXUL_DIST)/bin -L$(LIBXUL_DIST)/lib -o $@'
        MKCSHLIB='$(LD) $(DSO_LDOPTS) -L$(LIBXUL_DIST)/bin -L$(LIBXUL_DIST)/lib -o $@'
    fi
    MOZ_POST_PROGRAM_COMMAND='chatr +s enable'
    AC_DEFINE(NSCAP_DISABLE_DEBUG_PTR_TYPES)
    ;;

*-android*|*-linuxandroid*)
    AC_DEFINE(NO_PW_GECOS)
    no_x=yes
    _PLATFORM_DEFAULT_TOOLKIT=cairo-android
    TARGET_NSPR_MDCPUCFG='\"md/_linux.cfg\"'

    MOZ_GFX_OPTIMIZE_MOBILE=1
    MOZ_OPTIMIZE_FLAGS="-O3 -freorder-blocks -fno-reorder-functions"
    # The Maemo builders don't know about this flag
    MOZ_ARM_VFP_FLAGS="-mfpu=vfp"
    ;;

*-*linux*)
    # Note: both GNU_CC and INTEL_CC are set when using Intel's C compiler.
    # Similarly for GNU_CXX and INTEL_CXX.
    if test "$INTEL_CC" -o "$INTEL_CXX"; then
        # -Os has been broken on Intel's C/C++ compilers for quite a
        # while; Intel recommends against using it.
        MOZ_OPTIMIZE_FLAGS="-O2"
        MOZ_DEBUG_FLAGS="-g"
    elif test "$GNU_CC" -o "$GNU_CXX"; then
        case $GCC_VERSION in
        4.5.*)
            # -Os is broken on gcc 4.5.x we need to tweak it to get good results.
            MOZ_OPTIMIZE_SIZE_TWEAK="-finline-limit=50"
        esac
        MOZ_PGO_OPTIMIZE_FLAGS="-O3"
        MOZ_OPTIMIZE_FLAGS="-O3 -freorder-blocks $MOZ_OPTIMIZE_SIZE_TWEAK"
        MOZ_DEBUG_FLAGS="-g"
    fi

    TARGET_NSPR_MDCPUCFG='\"md/_linux.cfg\"'

    case "${target_cpu}" in
    alpha*)
    	CFLAGS="$CFLAGS -mieee"
    	CXXFLAGS="$CXXFLAGS -mieee"
    ;;
    mips*)
        MOZ_DEBUG_FLAGS="-g" # We want inlining
    ;;
    esac

    if test -z "$MC"; then
        MC=mc.exe
    fi
    ;;

*-mingw*)
    DSO_CFLAGS=
    DSO_PIC_CFLAGS=
    DLL_SUFFIX=.dll
    RC=rc.exe
    MC=mc.exe
    if test -n "$GNU_CC"; then
        CC="$CC -mwindows"
        CXX="$CXX -mwindows"
        CPP="$CPP -mwindows"
        CFLAGS="$CFLAGS -mms-bitfields"
        CXXFLAGS="$CXXFLAGS -mms-bitfields"
        DSO_LDOPTS='-shared'
        MKSHLIB='$(CXX) $(DSO_LDOPTS) -o $@'
        MKCSHLIB='$(CC) $(DSO_LDOPTS) -o $@'
        RC='$(WINDRES)'
        # Use static libgcc and libstdc++
        LDFLAGS="$LDFLAGS -static-libgcc -static-libstdc++"
        # Use temp file for windres (bug 213281)
        RCFLAGS='-O coff --use-temp-file'
        # mingw doesn't require kernel32, user32, and advapi32 explicitly
        LIBS="$LIBS -lgdi32 -lwinmm -lwsock32 -lpsapi"
        MOZ_JS_LIBS='-L$(libdir) -lmozjs'
        MOZ_FIX_LINK_PATHS=
        DYNAMIC_XPCOM_LIBS='-L$(LIBXUL_DIST)/lib -lxpcom -lxpcom_core -lmozalloc'
        XPCOM_FROZEN_LDOPTS='-L$(LIBXUL_DIST)/lib -lxpcom -lmozalloc'
        DLL_PREFIX=
        IMPORT_LIB_SUFFIX=dll.a

        # We use mix of both POSIX and Win32 printf format across the tree, so format
        # warnings are useless on mingw.
        MOZ_C_SUPPORTS_WARNING(-Wno-, format, ac_c_has_wno_format)
        MOZ_CXX_SUPPORTS_WARNING(-Wno-, format, ac_cxx_has_wno_format)
    else
        TARGET_COMPILER_ABI=msvc
        HOST_CC='$(CC)'
        HOST_CXX='$(CXX)'
        HOST_LD='$(LD)'
        if test "$AS_BIN"; then
            AS="$(basename "$AS_BIN")"
        fi
        AR='lib'
        AR_FLAGS='-NOLOGO -OUT:"$@"'
        AR_EXTRACT=
        RANLIB='echo not_ranlib'
        STRIP='echo not_strip'
        PKG_SKIP_STRIP=1
        XARGS=xargs
        DOXYGEN=:
        ASM_SUFFIX=asm
        OBJ_SUFFIX=obj
        LIB_SUFFIX=lib
        DLL_PREFIX=
        LIB_PREFIX=
        IMPORT_LIB_SUFFIX=lib
        MKSHLIB='$(LD) -NOLOGO -DLL -OUT:$@ -PDB:$(LINK_PDBFILE) $(DSO_LDOPTS)'
        MKCSHLIB='$(LD) -NOLOGO -DLL -OUT:$@ -PDB:$(LINK_PDBFILE) $(DSO_LDOPTS)'
        MKSHLIB_FORCE_ALL=
        MKSHLIB_UNFORCE_ALL=
        DSO_LDOPTS=-SUBSYSTEM:WINDOWS
        _USE_CPP_INCLUDE_FLAG=1
        _DEFINES_CFLAGS='-FI $(DEPTH)/js-confdefs.h -DMOZILLA_CLIENT'
        _DEFINES_CXXFLAGS='-FI $(DEPTH)/js-confdefs.h -DMOZILLA_CLIENT'
        CFLAGS="$CFLAGS -W3 -Gy -Fd\$(COMPILE_PDBFILE)"
        CXXFLAGS="$CXXFLAGS -W3 -Gy -Fd\$(COMPILE_PDBFILE)"
        # MSVC warning C4244 is ubiquitous, useless, and annoying.
        CXXFLAGS="$CXXFLAGS -wd4244"
        # make 'foo == bar;' error out
        CFLAGS="$CFLAGS -we4553"
        CXXFLAGS="$CXXFLAGS -we4553"
        LIBS="$LIBS kernel32.lib user32.lib gdi32.lib winmm.lib wsock32.lib advapi32.lib psapi.lib"
        MOZ_DEBUG_FLAGS='-Zi'
        MOZ_DEBUG_LDFLAGS='-DEBUG -DEBUGTYPE:CV'
        WARNINGS_AS_ERRORS='-WX'
        MOZ_OPTIMIZE_FLAGS="-O2"
        MOZ_JS_LIBS='$(libdir)/mozjs.lib'
        MOZ_FIX_LINK_PATHS=
        DYNAMIC_XPCOM_LIBS='$(LIBXUL_DIST)/lib/xpcom.lib $(LIBXUL_DIST)/lib/xpcom_core.lib $(LIBXUL_DIST)/lib/mozalloc.lib'
        XPCOM_FROZEN_LDOPTS='$(LIBXUL_DIST)/lib/xpcom.lib $(LIBXUL_DIST)/lib/mozalloc.lib'
        LIBXUL_LIBS='$(LIBXUL_DIST)/lib/xpcom.lib $(LIBXUL_DIST)/lib/xul.lib $(LIBXUL_DIST)/lib/mozalloc.lib'
        MOZ_COMPONENT_NSPR_LIBS='$(NSPR_LIBS)'
        LDFLAGS="$LDFLAGS -LARGEADDRESSAWARE -NXCOMPAT"
        dnl For profile-guided optimization
        PROFILE_GEN_CFLAGS="-GL"
        PROFILE_GEN_LDFLAGS="-LTCG:PGINSTRUMENT"
        dnl XXX: PGO builds can fail with warnings treated as errors,
        dnl specifically "no profile data available" appears to be
        dnl treated as an error sometimes. This might be a consequence
        dnl of using WARNINGS_AS_ERRORS in some modules, combined
        dnl with the linker doing most of the work in the whole-program
        dnl optimization/PGO case. I think it's probably a compiler bug,
        dnl but we work around it here.
        PROFILE_USE_CFLAGS="-GL -wd4624 -wd4952"
        dnl XXX: should be -LTCG:PGOPTIMIZE, but that fails on libxul.
        dnl Probably also a compiler bug, but what can you do?
        PROFILE_USE_LDFLAGS="-LTCG:PGUPDATE"
        LDFLAGS="$LDFLAGS -DYNAMICBASE"
    fi
    AC_DEFINE(HAVE_SNPRINTF)
    AC_DEFINE(_WINDOWS)
    AC_DEFINE(WIN32)
    AC_DEFINE(XP_WIN)
    AC_DEFINE(XP_WIN32)
    AC_DEFINE(HW_THREADS)
    AC_DEFINE(STDC_HEADERS)
    AC_DEFINE(NEW_H, <new>)
    AC_DEFINE(WIN32_LEAN_AND_MEAN)
    TARGET_MD_ARCH=win32
    _PLATFORM_DEFAULT_TOOLKIT='cairo-windows'
    BIN_SUFFIX='.exe'
    MOZ_USER_DIR="Mozilla"

    dnl Hardcode to win95 for now - cls
    TARGET_NSPR_MDCPUCFG='\"md/_win95.cfg\"'

    dnl set NO_X11 defines here as the general check is skipped on win32
    no_x=yes
    AC_DEFINE(NO_X11)

    case "$host" in
    *-mingw*)
        MOZ_BUILD_ROOT=`cd $MOZ_BUILD_ROOT && pwd -W`
        ;;
    esac

    case "$host" in
    *-mingw*)
        if test -z "$MOZ_TOOLS"; then
            AC_MSG_ERROR([MOZ_TOOLS is not set])
        fi
        MOZ_TOOLS_DIR=`cd $MOZ_TOOLS && pwd -W`
        if test "$?" != "0" -o -z "$MOZ_TOOLS_DIR"; then
            AC_MSG_ERROR([cd \$MOZ_TOOLS failed. MOZ_TOOLS ==? $MOZ_TOOLS])
        fi
        MOZ_TOOLS_BIN_DIR="$(cd "$MOZ_TOOLS_DIR/bin" && pwd)"
        if test `echo ${PATH}: | grep -ic "$MOZ_TOOLS_BINDIR:"` = 0; then
            AC_MSG_ERROR([\$MOZ_TOOLS\\bin must be in your path.])
        fi
        ;;
    esac

    case "$host_os" in
    cygwin*|msvc*|mks*)
        AC_MSG_ERROR([Using a Cygwin build environment is unsupported. Configure cannot check for presence of necessary headers. Please upgrade to MozillaBuild; see https://developer.mozilla.org/en/Windows_Build_Prerequisites.])
        ;;
    esac

    case "$target" in
    i*86-*)
        if test "$HAVE_64BIT_OS"; then
            AC_MSG_ERROR([You are targeting i386 but using the 64-bit compiler.])
        fi

        if test -n "$GNU_CC"; then
            CFLAGS="$CFLAGS -mstackrealign -fno-keep-inline-dllexport"
            CXXFLAGS="$CXXFLAGS -mstackrealign -fno-keep-inline-dllexport"
        else
            DSO_LDOPTS="$DSO_LDOPTS -MACHINE:X86"
            LDFLAGS="$LDFLAGS -SAFESEH"
        fi

    	AC_DEFINE(_X86_)
	;;
    x86_64-*)
        if test -n "$_WIN32_MSVC"; then
            DSO_LDOPTS="$DSO_LDOPTS -MACHINE:X64"
        fi
        AC_DEFINE(_AMD64_)
        ;;
    *)
    	AC_DEFINE(_CPU_ARCH_NOT_DEFINED)
	;;
    esac

    if test "$HAVE_64BIT_OS"; then
    	AC_DEFINE(_WIN64)
    fi
    ;;

*-netbsd*)
    DSO_CFLAGS=''
    CFLAGS="$CFLAGS -Dunix"
    CXXFLAGS="$CXXFLAGS -Dunix"
    if $CC -E - -dM </dev/null | grep __ELF__ >/dev/null; then
        DLL_SUFFIX=".so"
        DSO_PIC_CFLAGS='-fPIC -DPIC'
        DSO_LDOPTS='-shared'
	BIN_FLAGS='-Wl,--export-dynamic'
    else
    	DSO_PIC_CFLAGS='-fPIC -DPIC'
    	DLL_SUFFIX=".so.1.0"
    	DSO_LDOPTS='-shared'
    fi
    # This will fail on a.out systems prior to 1.5.1_ALPHA.
    MKSHLIB_FORCE_ALL='-Wl,--whole-archive'
    MKSHLIB_UNFORCE_ALL='-Wl,--no-whole-archive'
    if test "$LIBRUNPATH"; then
	DSO_LDOPTS="-Wl,-R$LIBRUNPATH $DSO_LDOPTS"
    fi
    MKSHLIB='$(CXX) $(CXXFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -Wl,-soname,lib$(LIBRARY_NAME)$(DLL_SUFFIX) -o $@'
    MKCSHLIB='$(CC) $(CFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -Wl,-soname,lib$(LIBRARY_NAME)$(DLL_SUFFIX) -o $@'
    ;;

*-openbsd*)
    DLL_SUFFIX=".so.1.0"
    DSO_CFLAGS=''
    DSO_PIC_CFLAGS='-fPIC'
    DSO_LDOPTS='-shared -fPIC'
    if test "$LIBRUNPATH"; then
	DSO_LDOPTS="-R$LIBRUNPATH $DSO_LDOPTS"
    fi
    ;;

*-os2*)
    MKSHLIB='$(CXX) $(CXXFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -o $@'
    MKCSHLIB='$(CC) $(CFLAGS) $(DSO_PIC_CFLAGS) $(DSO_LDOPTS) -o $@'
    AC_DEFINE(OS2)
    AC_DEFINE(XP_OS2)
    AC_DEFINE(OS2EMX_PLAIN_CHAR)
    AC_DEFINE(TCPV40HDRS)
    DLL_PREFIX=
    LIB_PREFIX=
    LIB_SUFFIX=lib
    BIN_SUFFIX=".exe"
    DLL_SUFFIX=".dll"
    IMPORT_LIB_SUFFIX=lib
    DSO_PIC_CFLAGS=
    AR=emxomfar
    AR_FLAGS='r $@'
    CFLAGS="$CFLAGS -Zomf"
    CXXFLAGS="$CXXFLAGS -Zomf"
    DSO_LDOPTS='-Zdll'
    BIN_FLAGS='-Zlinker /ST:0x100000'
    IMPLIB='emximp -o'
    FILTER='true'
    LDFLAGS='-Zmap'
    WARNINGS_AS_ERRORS='-Werror'
    MOZ_DEBUG_FLAGS="-g -fno-inline"
    MOZ_OPTIMIZE_FLAGS="-O2"
    MOZ_OPTIMIZE_LDFLAGS="-s -Zlinker /EXEPACK:2 -Zlinker /PACKCODE -Zlinker /PACKDATA"
    DYNAMIC_XPCOM_LIBS='-L$(LIBXUL_DIST)/lib $(LIBXUL_DIST)/lib/xpcom.lib $(LIBXUL_DIST)/lib/xpcom_core.lib $(LIBXUL_DIST)/lib/mozalloc.lib'
    LIBXUL_LIBS='-L$(LIBXUL_DIST)/lib $(LIBXUL_DIST)/lib/xpcom.lib $(LIBXUL_DIST)/lib/xul.lib $(LIBXUL_DIST)/lib/mozalloc.lib'
    TARGET_MD_ARCH=os2
    _PLATFORM_DEFAULT_TOOLKIT="cairo-os2"
    RC=rc.exe
    MC=mc.exe
    RCFLAGS='-n'
    MOZ_USER_DIR="Mozilla"

    if test "$MOZTOOLS"; then
        MOZ_TOOLS_DIR=`echo $MOZTOOLS | sed -e 's|\\\\|/|g'`
    else
        AC_MSG_ERROR([MOZTOOLS is not set])
    fi
    if test -n "$MOZ_OS2_HIGH_MEMORY"; then
        DSO_LDOPTS="$DSO_LDOPTS -Zhigh-mem"
        LDFLAGS="$LDFLAGS -Zhigh-mem"
        MOZ_OPTIMIZE_LDFLAGS="$MOZ_OPTIMIZE_LDFLAGS -Zhigh-mem"
        AC_DEFINE(MOZ_OS2_HIGH_MEMORY)
    fi

    # GCC for OS/2 currently predefines these, but we don't want them
    _DEFINES_CFLAGS="$_DEFINES_CFLAGS -Uunix -U__unix -U__unix__"
    _DEFINES_CXXFLAGS="$_DEFINES_CXXFLAGS -Uunix -U__unix -U__unix__"

    AC_CACHE_CHECK(for __declspec(dllexport),
        ac_os2_declspec,
        [AC_TRY_COMPILE([__declspec(dllexport) void ac_os2_declspec(void) {}],
                        [return 0;],
                        ac_os2_declspec="yes",
                        ac_os2_declspec="no")])
    if test "$ac_os2_declspec" != "yes"; then
        AC_MSG_ERROR([Compiler does not support __declspec(dllexport), install GCC-4.3.2 or newer])
    fi
    ;;

*-solaris*)
    AC_DEFINE(SOLARIS)
    TARGET_NSPR_MDCPUCFG='\"md/_solaris.cfg\"'
    if test -z "$CROSS_COMPILE" && pkginfo -q SUNWpr && pkginfo -q SUNWprd; then
       NO_NSPR_CONFIG_SYSTEM_LDFLAGS="-L/usr/lib/mps -R/usr/lib/mps -lnspr4"
       NO_NSPR_CONFIG_SYSTEM_CFLAGS="-I/usr/include/mps"
       NO_NSPR_CONFIG_SYSTEM_VERSION=["`pkgparam SUNWpr SUNW_PRODVERS | sed -e 's/^[1-9][0-9]*\.[0-9][0-9]*$/&.0/'`"]
    fi
    MOZ_FIX_LINK_PATHS=
    # $ORIGIN/.. is for shared libraries under components/ to locate shared
    # libraries one level up (e.g. libnspr4.so)
    if test "$SOLARIS_SUNPRO_CC"; then
       LDFLAGS="$LDFLAGS -z ignore -R '\$\$ORIGIN:\$\$ORIGIN/..' -z lazyload -z combreloc -z muldefs"
       LIBS="-lCrun -lCstd -lc $LIBS"
       AC_DEFINE(NSCAP_DISABLE_DEBUG_PTR_TYPES)
       CFLAGS="$CFLAGS -xlibmieee -xstrconst -xbuiltin=%all -D__FUNCTION__=__func__"
       CXXFLAGS="$CXXFLAGS -xlibmieee -xbuiltin=%all -features=tmplife,tmplrefstatic,extensions,no%except -norunpath -D__FUNCTION__=__func__ -template=no%extdef"
       LDFLAGS="-xildoff $LDFLAGS"
       if test -z "$CROSS_COMPILE" -a -f /usr/lib/ld/map.noexstk; then
           _SAVE_LDFLAGS=$LDFLAGS
           LDFLAGS="-M /usr/lib/ld/map.noexstk $LDFLAGS"
           AC_TRY_LINK([#include <stdio.h>],
                       [printf("Hello World\n");],
                       ,
                       [LDFLAGS=$_SAVE_LDFLAGS])
       fi
       MOZ_OPTIMIZE_FLAGS="-xO4"
       MKSHLIB='$(CXX) $(CXXFLAGS) $(DSO_PIC_FLAGS) $(DSO_LDOPTS) -h $@ -o $@'
       MKCSHLIB='$(CC) $(CFLAGS) $(DSO_PIC_FLAGS) $(DSO_LDOPTS) -h $@ -o $@'
       MKSHLIB_FORCE_ALL='-z allextract'
       MKSHLIB_UNFORCE_ALL='-z defaultextract'
       DSO_LDOPTS='-G'
       AR_LIST="$AR t"
       AR_EXTRACT="$AR x"
       AR_DELETE="$AR d"
       AR='$(CXX) -xar'
       AR_FLAGS='-o $@'
       AS='/usr/ccs/bin/as'
       ASFLAGS="$ASFLAGS -K PIC -L -P -D_ASM -D__STDC__=0"
       AS_DASH_C_FLAG=''
       TARGET_COMPILER_ABI="sunc"
       CC_VERSION=`$CC -V 2>&1 | grep '^cc:' 2>/dev/null | $AWK -F\: '{ print $2 }'`
       CXX_VERSION=`$CXX -V 2>&1 | grep '^CC:' 2>/dev/null | $AWK -F\: '{ print $2 }'`
       AC_MSG_CHECKING([for Sun C++ compiler version >= 5.9])
       AC_LANG_SAVE
       AC_LANG_CPLUSPLUS
       AC_TRY_COMPILE([],
           [#if (__SUNPRO_CC < 0x590)
           #error "Denied"
           #endif],
           _BAD_COMPILER=,_BAD_COMPILER=1)
       if test -n "$_BAD_COMPILER"; then
           _res="no"
           AC_MSG_ERROR([Sun C++ 5.9 (Sun Studio 12) or higher is required to build. Your compiler version is $CXX_VERSION .])
       else
           _res="yes"
       fi
       AC_TRY_COMPILE([],
           [#if (__SUNPRO_CC >= 0x5100)
           #error "Sun C++ 5.10 or above"
           #endif],
           _ABOVE_SS12U1=,_ABOVE_SS12U1=1)
       if test "$_ABOVE_SS12U1"; then
           # disable xannotate
           CXXFLAGS="$CXXFLAGS -xannotate=no"
       fi
       AC_MSG_RESULT([$_res])
       AC_LANG_RESTORE
    else
       LDFLAGS="$LDFLAGS -Wl,-z,ignore -Wl,-R,'\$\$ORIGIN:\$\$ORIGIN/..' -Wl,-z,lazyload -Wl,-z,combreloc -Wl,-z,muldefs"
       LIBS="-lc $LIBS"
       MKSHLIB_FORCE_ALL='-Wl,-z -Wl,allextract'
       MKSHLIB_UNFORCE_ALL='-Wl,-z -Wl,defaultextract'
       ASFLAGS="$ASFLAGS -fPIC"
       DSO_LDOPTS='-shared'
       WARNINGS_AS_ERRORS='-Werror'
       _WARNINGS_CFLAGS=''
       _WARNINGS_CXXFLAGS=''
       if test "$OS_RELEASE" = "5.3"; then
           AC_DEFINE(MUST_UNDEF_HAVE_BOOLEAN_AFTER_INCLUDES)
       fi
    fi
    if test "$OS_RELEASE" = "5.5.1"; then
        AC_DEFINE(NEED_USLEEP_PROTOTYPE)
    fi
    ;;

*-sunos*)
    DSO_LDOPTS='-Bdynamic'
    MKSHLIB='-$(LD) $(DSO_LDOPTS) -o $@'
    MKCSHLIB='-$(LD) $(DSO_LDOPTS) -o $@'
    AC_DEFINE(SUNOS4)
    AC_DEFINE(SPRINTF_RETURNS_STRING)
    case "$(target_os)" in
    sunos4.1*)
        DLL_SUFFIX='.so.1.0'
        ;;
    esac
    ;;

*-os2*)
    HOST_NSPR_MDCPUCFG='\"md/_os2.cfg\"'
    ;;

esac

dnl Only one oddball right now (QNX), but this gives us flexibility
dnl if any other platforms need to override this in the future.
AC_DEFINE_UNQUOTED(D_INO,$DIRENT_INO)

dnl ========================================================
dnl Any platform that doesn't have MKSHLIB_FORCE_ALL defined
dnl by now will not have any way to link most binaries (tests
dnl as well as viewer, apprunner, etc.), because some symbols
dnl will be left out of the "composite" .so's by ld as unneeded.
dnl So, by defining NO_LD_ARCHIVE_FLAGS for these platforms,
dnl they can link in the static libs that provide the missing
dnl symbols.
dnl ========================================================
NO_LD_ARCHIVE_FLAGS=
if test -z "$MKSHLIB_FORCE_ALL" -o -z "$MKSHLIB_UNFORCE_ALL"; then
    NO_LD_ARCHIVE_FLAGS=1
fi
case "$target" in
*-os2*)
    NO_LD_ARCHIVE_FLAGS=
    ;;
*-aix4.3*|*-aix5*)
    NO_LD_ARCHIVE_FLAGS=
    ;;
*-mingw*)
    if test -z "$GNU_CC"; then
        NO_LD_ARCHIVE_FLAGS=
    fi
    ;;
esac
AC_SUBST(NO_LD_ARCHIVE_FLAGS)

dnl ========================================================
dnl = Flags to strip unused symbols from .so components
dnl ========================================================
case "$target" in
    *-linux*|*-kfreebsd*-gnu|*-gnu*)
        MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS='-Wl,--version-script -Wl,$(BUILD_TOOLS)/gnu-ld-scripts/components-version-script'
        ;;
    *-solaris*)
        if test -z "$GNU_CC"; then
         MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS='-M $(BUILD_TOOLS)/gnu-ld-scripts/components-mapfile'
        else
         if test -z "$GCC_USE_GNU_LD"; then
          MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS='-Wl,-M -Wl,$(BUILD_TOOLS)/gnu-ld-scripts/components-mapfile'
         else
          MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS='-Wl,--version-script -Wl,$(BUILD_TOOLS)/gnu-ld-scripts/components-version-script'
         fi
        fi
        ;;
    *-darwin*)
        MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS='-Wl,-exported_symbols_list -Wl,$(BUILD_TOOLS)/gnu-ld-scripts/components-export-list'
        ;;
    *-mingw*)
        if test -n "$GNU_CC"; then
           MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS='-Wl,--version-script,$(BUILD_TOOLS)/gnu-ld-scripts/components-version-script'
        fi
        ;;
esac

if test -z "$COMPILE_ENVIRONMENT"; then
    SKIP_COMPILER_CHECKS=1
    SKIP_LIBRARY_CHECKS=1
fi

dnl Configure JIT support

case "$target" in
i?86-*)
    ENABLE_METHODJIT=1
    ENABLE_ION=1
    ENABLE_MONOIC=1
    ENABLE_POLYIC=1
    ENABLE_METHODJIT_TYPED_ARRAY=1
    AC_DEFINE(JS_CPU_X86)
    AC_DEFINE(JS_NUNBOX32)
    ;;
x86_64*-*)
    ENABLE_METHODJIT=1
    ENABLE_ION=1
    ENABLE_MONOIC=1
    ENABLE_POLYIC=1
    ENABLE_METHODJIT_TYPED_ARRAY=1
    AC_DEFINE(JS_CPU_X64)
    AC_DEFINE(JS_PUNBOX64)
    ;;
arm*-*)
    ENABLE_METHODJIT=1
    ENABLE_ION=1
    ENABLE_MONOIC=1
    ENABLE_POLYIC=1
    ENABLE_METHODJIT_TYPED_ARRAY=1
    AC_DEFINE(JS_CPU_ARM)
    AC_DEFINE(JS_NUNBOX32)
    ;;
sparc*-*)
    if test ! "$HAVE_64BIT_OS" ; then
    ENABLE_METHODJIT=1
    ENABLE_MONOIC=1
    ENABLE_POLYIC=1
    ENABLE_METHODJIT_TYPED_ARRAY=1
dnl ENABLE_ION=0
    AC_DEFINE(JS_CPU_SPARC)
    AC_DEFINE(JS_NUNBOX32)
    fi
    ;;
mips*-*)
    ENABLE_METHODJIT=1
    ENABLE_MONOIC=1
    ENABLE_POLYIC=1
    ENABLE_METHODJIT_TYPED_ARRAY=1
    AC_DEFINE(JS_CPU_MIPS)
    AC_DEFINE(JS_NUNBOX32)
    ;;
esac

MOZ_ARG_DISABLE_BOOL(ion,
[  --disable-ion      Disable use of the IonMonkey JIT],
  ENABLE_ION= )

MOZ_ARG_DISABLE_BOOL(methodjit,
[  --disable-methodjit           Disable method JIT support],
  ENABLE_METHODJIT= )

MOZ_ARG_DISABLE_BOOL(monoic,
[  --disable-monoic      Disable use of MICs by JIT compiler],
  ENABLE_MONOIC= )

MOZ_ARG_DISABLE_BOOL(polyic,
[  --disable-polyic      Disable use of PICs by JIT compiler],
  ENABLE_POLYIC= )

MOZ_ARG_ENABLE_BOOL(methodjit-spew,
[  --enable-methodjit-spew      Enable method JIT spew support],
  ENABLE_METHODJIT_SPEW=1,
  ENABLE_METHODJIT_SPEW= )

AC_SUBST(ENABLE_METHODJIT)
AC_SUBST(ENABLE_METHODJIT_SPEW)

if test "$ENABLE_METHODJIT"; then
    AC_DEFINE(JS_METHODJIT)
else
    ENABLE_ION=
fi

# Disable IonMonkey for B2G, for now.
if test "$MOZ_APP_NAME" = b2g; then
    ENABLE_ION=
fi

if test "$ENABLE_MONOIC"; then
    AC_DEFINE(JS_MONOIC)
fi

if test "$ENABLE_POLYIC"; then
    AC_DEFINE(JS_POLYIC)
fi

if test "$ENABLE_METHODJIT_TYPED_ARRAY"; then
    AC_DEFINE(JS_METHODJIT_TYPED_ARRAY)
fi

AC_SUBST(ENABLE_ION)

if test "$ENABLE_ION"; then
    AC_DEFINE(JS_ION)
fi

MOZ_COMPILER_OPTS
if test -z "$SKIP_COMPILER_CHECKS"; then
dnl Checks for typedefs, structures, and compiler characteristics.
dnl ========================================================
AC_HEADER_STDC
AC_C_CONST
AC_TYPE_MODE_T
AC_TYPE_OFF_T
AC_TYPE_PID_T
AC_TYPE_SIZE_T
AC_LANG_CPLUSPLUS
AC_MSG_CHECKING(for __stdcall)
AC_CACHE_VAL(ac_cv___stdcall,
 [AC_TRY_COMPILE([template <typename Method> struct foo;
                  template <> struct foo<void (*)()> {};
                  template <> struct foo<void (__stdcall*)()> {};],
                 [],
                 [ac_cv___stdcall=true],
                 [ac_cv___stdcall=false])])
if test "$ac_cv___stdcall" = true ; then
  AC_DEFINE(HAVE_STDCALL)
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi
AC_LANG_C
AC_MSG_CHECKING(for ssize_t)
AC_CACHE_VAL(ac_cv_type_ssize_t,
 [AC_TRY_COMPILE([#include <stdio.h>
                  #include <sys/types.h>],
                 [ssize_t foo = 0;],
                 [ac_cv_type_ssize_t=true],
                 [ac_cv_type_ssize_t=false])])
if test "$ac_cv_type_ssize_t" = true ; then
  AC_DEFINE(HAVE_SSIZE_T)
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi
AC_STRUCT_ST_BLKSIZE
AC_MSG_CHECKING(for siginfo_t)
AC_CACHE_VAL(ac_cv_siginfo_t,
 [AC_TRY_COMPILE([#define _POSIX_C_SOURCE 199506L
                  #include <signal.h>],
                 [siginfo_t* info;],
                 [ac_cv_siginfo_t=true],
                 [ac_cv_siginfo_t=false])])
if test "$ac_cv_siginfo_t" = true ; then
  AC_DEFINE(HAVE_SIGINFO_T)
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi

MOZ_SIZE_OF_TYPE(JS_BYTES_PER_WORD, void*, 4 8)
if test "$moz_cv_size_of_JS_BYTES_PER_WORD" -eq "4"; then
  AC_DEFINE(JS_BITS_PER_WORD_LOG2, 5)
elif test "$moz_cv_size_of_JS_BYTES_PER_WORD" -eq "8"; then
  AC_DEFINE(JS_BITS_PER_WORD_LOG2, 6)
else
  AC_MSG_ERROR([Unexpected JS_BYTES_PER_WORD])
fi

MOZ_ALIGN_OF_TYPE(JS_ALIGN_OF_POINTER, void*, 2 4 8 16)
MOZ_SIZE_OF_TYPE(JS_BYTES_PER_DOUBLE, double, 6 8 10 12 14)

MOZ_CHECK_HEADERS(endian.h)
if test "$ac_cv_header_endian_h" = yes; then
    AC_DEFINE(JS_HAVE_ENDIAN_H)
fi

MOZ_CHECK_HEADERS([machine/endian.h],[],[],[#include <sys/types.h>])
if test "$ac_cv_header_machine_endian_h" = yes; then
    AC_DEFINE(JS_HAVE_MACHINE_ENDIAN_H)
fi

MOZ_CHECK_HEADERS(sys/isa_defs.h)
if test "$ac_cv_header_sys_isa_defs_h" = yes; then
    AC_DEFINE(JS_HAVE_SYS_ISA_DEFS_H)
fi

dnl Check for uint and uint_t.
dnl ========================================================
AC_MSG_CHECKING(for uint)
AC_CACHE_VAL(ac_cv_uint,
 [AC_TRY_COMPILE([#include <stdio.h>
                  #include <sys/types.h>],
                 [uint foo = 0;],
                 [ac_cv_uint=true],
                 [ac_cv_uint=false])])
if test "$ac_cv_uint" = true ; then
  AC_DEFINE(HAVE_UINT)
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi
AC_MSG_CHECKING(for uint_t)
AC_CACHE_VAL(ac_cv_uint_t,
 [AC_TRY_COMPILE([#include <stdio.h>
                  #include <sys/types.h>],
                 [uint_t foo = 0;],
                 [ac_cv_uint_t=true],
                 [ac_cv_uint_t=false])])
if test "$ac_cv_uint_t" = true ; then
  AC_DEFINE(HAVE_UINT_T)
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi

dnl On the gcc trunk (as of 2001-02-09) _GNU_SOURCE, and thus __USE_GNU,
dnl are defined when compiling C++ but not C.  Since the result of this
dnl test is used only in C++, do it in C++.
AC_LANG_CPLUSPLUS

AC_MSG_CHECKING(for uname.domainname)
AC_CACHE_VAL(ac_cv_have_uname_domainname_field,
    [AC_TRY_COMPILE([#include <sys/utsname.h>],
        [ struct utsname *res; char *domain;
            (void)uname(res);  if (res != 0) { domain = res->domainname; } ],
        [ac_cv_have_uname_domainname_field=true],
        [ac_cv_have_uname_domainname_field=false])])

if test "$ac_cv_have_uname_domainname_field" = "true"; then
    AC_DEFINE(HAVE_UNAME_DOMAINNAME_FIELD)
    AC_MSG_RESULT(yes)
else
    AC_MSG_RESULT(no)
fi

AC_MSG_CHECKING(for uname.__domainname)
AC_CACHE_VAL(ac_cv_have_uname_us_domainname_field,
    [AC_TRY_COMPILE([#include <sys/utsname.h>],
        [ struct utsname *res; char *domain;
            (void)uname(res);  if (res != 0) { domain = res->__domainname; } ],
        [ac_cv_have_uname_us_domainname_field=true],
        [ac_cv_have_uname_us_domainname_field=false])])

if test "$ac_cv_have_uname_us_domainname_field" = "true"; then
    AC_DEFINE(HAVE_UNAME_US_DOMAINNAME_FIELD)
    AC_MSG_RESULT(yes)
else
    AC_MSG_RESULT(no)
fi

AC_LANG_C

dnl Check for .hidden assembler directive and visibility attribute.
dnl Borrowed from glibc configure.in
dnl ===============================================================
if test "$GNU_CC"; then
  AC_CACHE_CHECK(for visibility(hidden) attribute,
                 ac_cv_visibility_hidden,
                 [cat > conftest.c <<EOF
                  int foo __attribute__ ((visibility ("hidden"))) = 1;
EOF
                  ac_cv_visibility_hidden=no
                  if ${CC-cc} -Werror -S conftest.c -o conftest.s >/dev/null 2>&1; then
                    if egrep '\.(hidden|private_extern).*foo' conftest.s >/dev/null; then
                      ac_cv_visibility_hidden=yes
                    fi
                  fi
                  rm -f conftest.[cs]
                 ])
  if test "$ac_cv_visibility_hidden" = "yes"; then
    AC_DEFINE(HAVE_VISIBILITY_HIDDEN_ATTRIBUTE)

    AC_CACHE_CHECK(for visibility(default) attribute,
                   ac_cv_visibility_default,
                   [cat > conftest.c <<EOF
                    int foo __attribute__ ((visibility ("default"))) = 1;
EOF
                    ac_cv_visibility_default=no
                    if ${CC-cc} -fvisibility=hidden -Werror -S conftest.c -o conftest.s >/dev/null 2>&1; then
                      if ! egrep '\.(hidden|private_extern).*foo' conftest.s >/dev/null; then
                        ac_cv_visibility_default=yes
                      fi
                    fi
                    rm -f conftest.[cs]
                   ])
    if test "$ac_cv_visibility_default" = "yes"; then
      AC_DEFINE(HAVE_VISIBILITY_ATTRIBUTE)

      AC_CACHE_CHECK(for visibility pragma support,
                     ac_cv_visibility_pragma,
                     [cat > conftest.c <<EOF
#pragma GCC visibility push(hidden)
                      int foo_hidden = 1;
#pragma GCC visibility push(default)
                      int foo_default = 1;
EOF
                      ac_cv_visibility_pragma=no
                      if ${CC-cc} -Werror -S conftest.c -o conftest.s >/dev/null 2>&1; then
                        if egrep '\.(hidden|private_extern).*foo_hidden' conftest.s >/dev/null; then
                          if ! egrep '\.(hidden|private_extern).*foo_default' conftest.s > /dev/null; then
                            ac_cv_visibility_pragma=yes
                          fi
                        fi
                      fi
                      rm -f conftest.[cs]
                    ])
      if test "$ac_cv_visibility_pragma" = "yes"; then
        AC_CACHE_CHECK(For gcc visibility bug with class-level attributes (GCC bug 26905),
                       ac_cv_have_visibility_class_bug,
                       [cat > conftest.c <<EOF
#pragma GCC visibility push(hidden)
struct __attribute__ ((visibility ("default"))) TestStruct {
  static void Init();
};
__attribute__ ((visibility ("default"))) void TestFunc() {
  TestStruct::Init();
}
EOF
                       ac_cv_have_visibility_class_bug=no
                       if ! ${CXX-g++} ${CXXFLAGS} ${DSO_PIC_CFLAGS} ${DSO_LDOPTS} -S -o conftest.S conftest.c > /dev/null 2>&1 ; then
                         ac_cv_have_visibility_class_bug=yes
                       else
                         if test `egrep -c '@PLT|\\$stub' conftest.S` = 0; then
                           ac_cv_have_visibility_class_bug=yes
                         fi
                       fi
                       rm -rf conftest.{c,S}
                       ])

        AC_CACHE_CHECK(For x86_64 gcc visibility bug with builtins (GCC bug 20297),
                       ac_cv_have_visibility_builtin_bug,
                       [cat > conftest.c <<EOF
#pragma GCC visibility push(hidden)
#pragma GCC visibility push(default)
#include <string.h>
#pragma GCC visibility pop

__attribute__ ((visibility ("default"))) void Func() {
  char c[[100]];
  memset(c, 0, sizeof(c));
}
EOF
                       ac_cv_have_visibility_builtin_bug=no
                       if ! ${CC-cc} ${CFLAGS} ${DSO_PIC_CFLAGS} ${DSO_LDOPTS} -O2 -S -o conftest.S conftest.c > /dev/null 2>&1 ; then
                         ac_cv_have_visibility_builtin_bug=yes
                       else
                         if test `grep -c "@PLT" conftest.S` = 0; then
                           ac_cv_visibility_builtin_bug=yes
                         fi
                       fi
                       rm -f conftest.{c,S}
                       ])
        if test "$ac_cv_have_visibility_builtin_bug" = "no" -a \
                "$ac_cv_have_visibility_class_bug" = "no"; then
          VISIBILITY_FLAGS='-I$(DIST)/system_wrappers_js -include $(topsrcdir)/config/gcc_hidden.h'
          WRAP_SYSTEM_INCLUDES=1
        else
          VISIBILITY_FLAGS='-fvisibility=hidden'
        fi # have visibility pragma bug
      fi   # have visibility pragma
    fi     # have visibility(default) attribute
  fi       # have visibility(hidden) attribute
fi         # GNU_CC

# visibility hidden flag for Sun Studio on Solaris
if test "$SOLARIS_SUNPRO_CC"; then
VISIBILITY_FLAGS='-xldscope=hidden'
fi         # Sun Studio on Solaris

AC_SUBST(WRAP_SYSTEM_INCLUDES)
AC_SUBST(VISIBILITY_FLAGS)

MOZ_GCC_PR49911
MOZ_GCC_PR39608
MOZ_LLVM_PR8927

dnl Checks for header files.
dnl ========================================================
AC_HEADER_DIRENT
case "$target_os" in
freebsd*)
# for stuff like -lXshm
    CPPFLAGS="${CPPFLAGS} ${X_CFLAGS}"
    ;;
esac
MOZ_CHECK_COMMON_HEADERS

dnl These are all the places some variant of statfs can be hiding.
MOZ_CHECK_HEADERS(sys/statvfs.h sys/statfs.h sys/vfs.h sys/mount.h)

dnl Quota support
MOZ_CHECK_HEADERS(sys/quota.h)
MOZ_CHECK_HEADERS(linux/quota.h)

dnl Check whether the compiler supports the new-style C++ standard
dnl library headers (i.e. <new>) or needs the old "new.h"
AC_LANG_CPLUSPLUS
NEW_H=new.h
MOZ_CHECK_HEADER(new, [NEW_H=new])
AC_DEFINE_UNQUOTED(NEW_H, <$NEW_H>)
AC_LANG_C

AC_ARG_ENABLE(dtrace,
              [  --enable-dtrace         build with dtrace support if available (default=no)],
              [enable_dtrace="yes"],)
if test "x$enable_dtrace" = "xyes"; then
  MOZ_CHECK_HEADER(sys/sdt.h, HAVE_DTRACE=1)
  if test -n "$HAVE_DTRACE"; then
      AC_DEFINE(INCLUDE_MOZILLA_DTRACE)
  else
      AC_MSG_ERROR([dtrace enabled but sys/sdt.h not found]);
  fi
fi
AC_SUBST(HAVE_DTRACE)

case $target in
*-aix4.3*|*-aix5*)
	;;
*)
    MOZ_CHECK_HEADERS(sys/cdefs.h)
	;;
esac

MOZ_LINUX_PERF_EVENT

dnl Checks for libraries.
dnl ========================================================
case $target in
*-hpux11.*)
	;;
*)
	AC_CHECK_LIB(c_r, gethostbyname_r)
	;;
esac

dnl We don't want to link with libdl even if it's present on OS X, since
dnl it's not used and not part of the default installation. OS/2 has dlfcn
dnl in libc.
dnl We don't want to link against libm or libpthread on Darwin since
dnl they both are just symlinks to libSystem and explicitly linking
dnl against libSystem causes issues when debugging (see bug 299601).
case $target in
*-darwin*)
    ;;
*-os2*)
    ;;
*)
    AC_SEARCH_LIBS(dlopen, dl,
        MOZ_CHECK_HEADER(dlfcn.h,
        AC_DEFINE(HAVE_DLOPEN)))
    ;;
esac

_SAVE_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -D_GNU_SOURCE"
AC_CHECK_FUNCS(dladdr)
CFLAGS="$_SAVE_CFLAGS"

if test ! "$GNU_CXX"; then

    case $target in
    *-aix*)
	AC_CHECK_LIB(C_r, demangle)
	;;
     *)
	AC_CHECK_LIB(C, demangle)
	;;
     esac
fi

dnl OS/2 has socket in libc.
case $target in
*-os2*)
    ;;
*)
    AC_CHECK_LIB(socket, socket)
esac

dnl ========================================================
dnl = pthread support
dnl = Start by checking whether the system support pthreads
dnl ========================================================
case "$target_os" in
darwin*)
    USE_PTHREADS=1
    ;;
*)
    MOZ_CHECK_PTHREADS(pthreads,
        USE_PTHREADS=1 _PTHREAD_LDFLAGS="-lpthreads",
        MOZ_CHECK_PTHREADS(pthread,
            USE_PTHREADS=1 _PTHREAD_LDFLAGS="-lpthread",
            MOZ_CHECK_PTHREADS(c_r,
                USE_PTHREADS=1 _PTHREAD_LDFLAGS="-lc_r",
                MOZ_CHECK_PTHREADS(c,
                    USE_PTHREADS=1
                )
            )
        )
    )
    ;;
esac

dnl ========================================================
dnl Check the command line for --with-pthreads
dnl ========================================================
MOZ_ARG_WITH_BOOL(pthreads,
[  --with-pthreads         Force use of system pthread library with NSPR ],
[ if test "$USE_PTHREADS"x = x; then
    AC_MSG_ERROR([ --with-pthreads specified for a system without pthread support ]);
fi],
    USE_PTHREADS=
    _PTHREAD_LDFLAGS=
)

dnl ========================================================
dnl Do the platform specific pthread hackery
dnl ========================================================
if test "$USE_PTHREADS"x != x
then
	dnl
	dnl See if -pthread is supported.
	dnl
	rm -f conftest*
	ac_cv_have_dash_pthread=no
	AC_MSG_CHECKING(whether ${CC-cc} accepts -pthread)
	echo 'int main() { return 0; }' | cat > conftest.c
	${CC-cc} -pthread -o conftest conftest.c > conftest.out 2>&1
	if test $? -eq 0; then
		if test -z "`egrep -i '(unrecognize|unknown)' conftest.out | grep pthread`" -a -z "`egrep -i '(error|incorrect)' conftest.out`" ; then
			ac_cv_have_dash_pthread=yes
	        case "$target_os" in
	        freebsd*)
# Freebsd doesn't use -pthread for compiles, it uses them for linking
                ;;
	        *)
			    CFLAGS="$CFLAGS -pthread"
			    CXXFLAGS="$CXXFLAGS -pthread"
                ;;
	        esac
		fi
	fi
	rm -f conftest*
    AC_MSG_RESULT($ac_cv_have_dash_pthread)

	dnl
	dnl See if -pthreads is supported.
	dnl
    ac_cv_have_dash_pthreads=no
    if test "$ac_cv_have_dash_pthread" = "no"; then
	    AC_MSG_CHECKING(whether ${CC-cc} accepts -pthreads)
    	echo 'int main() { return 0; }' | cat > conftest.c
	    ${CC-cc} -pthreads -o conftest conftest.c > conftest.out 2>&1
    	if test $? -eq 0; then
	    	if test -z "`egrep -i '(unrecognize|unknown)' conftest.out | grep pthreads`" -a -z "`egrep -i '(error|incorrect)' conftest.out`" ; then
			    ac_cv_have_dash_pthreads=yes
			    CFLAGS="$CFLAGS -pthreads"
			    CXXFLAGS="$CXXFLAGS -pthreads"
		    fi
	    fi
	    rm -f conftest*
    	AC_MSG_RESULT($ac_cv_have_dash_pthreads)
    fi

	case "$target" in
	    *-*-freebsd*)
			AC_DEFINE(_REENTRANT)
			AC_DEFINE(_THREAD_SAFE)
			dnl -pthread links in -lpthread, so don't specify it explicitly.
			if test "$ac_cv_have_dash_pthread" = "yes"; then
				_PTHREAD_LDFLAGS="-pthread"
			fi
			;;

	    *-*-openbsd*|*-*-bsdi*)
			AC_DEFINE(_REENTRANT)
			AC_DEFINE(_THREAD_SAFE)
			dnl -pthread links in -lc_r, so don't specify it explicitly.
			if test "$ac_cv_have_dash_pthread" = "yes"; then
                _PTHREAD_LDFLAGS="-pthread"
			fi
			;;

	    *-*-linux*|*-*-kfreebsd*-gnu|*-*-gnu*)
			AC_DEFINE(_REENTRANT)
			;;

	    *-aix4.3*|*-aix5*)
			AC_DEFINE(_REENTRANT)
			;;

	    *-hpux11.*)
			AC_DEFINE(_REENTRANT)
			;;

	    *-*-solaris*)
			AC_DEFINE(_REENTRANT)
			if test "$SOLARIS_SUNPRO_CC"; then
				CFLAGS="$CFLAGS -mt"
				CXXFLAGS="$CXXFLAGS -mt"
			fi
			;;
	esac
    LDFLAGS="${_PTHREAD_LDFLAGS} ${LDFLAGS}"
fi


dnl Checks for library functions.
dnl ========================================================
AC_PROG_GCC_TRADITIONAL
AC_FUNC_MEMCMP
AC_CHECK_FUNCS([fchmod flockfile getc_unlocked _getc_nolock getpagesize \
                lchown localtime_r lstat64 memmove random rint sbrk snprintf \
                stat64 statvfs statvfs64 strerror strtok_r truncate64])

dnl check for wcrtomb/mbrtowc
dnl =======================================================================
if test -z "$MACOS_DEPLOYMENT_TARGET" || test "$MACOS_DEPLOYMENT_TARGET" -ge "100300"; then
AC_LANG_SAVE
AC_LANG_CPLUSPLUS
AC_CACHE_CHECK(for wcrtomb,
    ac_cv_have_wcrtomb,
    [AC_TRY_LINK([#include <wchar.h>],
                 [mbstate_t ps={0};wcrtomb(0,'f',&ps);],
                 ac_cv_have_wcrtomb="yes",
                 ac_cv_have_wcrtomb="no")])
if test "$ac_cv_have_wcrtomb" = "yes"; then
    AC_DEFINE(HAVE_WCRTOMB)
fi
AC_CACHE_CHECK(for mbrtowc,
    ac_cv_have_mbrtowc,
    [AC_TRY_LINK([#include <wchar.h>],
                 [mbstate_t ps={0};mbrtowc(0,0,0,&ps);],
                 ac_cv_have_mbrtowc="yes",
                 ac_cv_have_mbrtowc="no")])
if test "$ac_cv_have_mbrtowc" = "yes"; then
    AC_DEFINE(HAVE_MBRTOWC)
fi
AC_LANG_RESTORE
fi

AC_CACHE_CHECK(
    [for res_ninit()],
    ac_cv_func_res_ninit,
    [AC_TRY_LINK([
        #ifdef linux
        #define _BSD_SOURCE 1
        #endif
        #include <resolv.h>
        ],
        [int foo = res_ninit(&_res);],
        [ac_cv_func_res_ninit=yes],
        [ac_cv_func_res_ninit=no])
    ])

if test "$ac_cv_func_res_ninit" = "yes"; then
    AC_DEFINE(HAVE_RES_NINIT)
dnl must add the link line we do something as foolish as this... dougt
dnl else
dnl    AC_CHECK_LIB(bind, res_ninit, AC_DEFINE(HAVE_RES_NINIT),
dnl        AC_CHECK_LIB(resolv, res_ninit, AC_DEFINE(HAVE_RES_NINIT)))
fi

AC_LANG_CPLUSPLUS
AC_CACHE_CHECK(
    [for gnu_get_libc_version()],
    ac_cv_func_gnu_get_libc_version,
    [AC_TRY_LINK([
        #ifdef HAVE_GNU_LIBC_VERSION_H
        #include <gnu/libc-version.h>
        #endif
        ],
        [const char *glibc_version = gnu_get_libc_version();],
        [ac_cv_func_gnu_get_libc_version=yes],
        [ac_cv_func_gnu_get_libc_version=no]
        )]
    )

if test "$ac_cv_func_gnu_get_libc_version" = "yes"; then
    AC_DEFINE(HAVE_GNU_GET_LIBC_VERSION)
fi
AC_LANG_C

dnl **********************
dnl *** va_copy checks ***
dnl **********************
dnl we currently check for all three va_copy possibilities, so we get
dnl all results in config.log for bug reports.
AC_MSG_CHECKING(for an implementation of va_copy())
AC_CACHE_VAL(ac_cv_va_copy,[
    AC_TRY_RUN([
        #include <stdarg.h>
        void f (int i, ...) {
            va_list args1, args2;
            va_start (args1, i);
            va_copy (args2, args1);
            if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
                exit (1);
            va_end (args1); va_end (args2);
        }
        int main() { f (0, 42); return 0; }],
        ac_cv_va_copy=yes,
        ac_cv_va_copy=no,
        ac_cv_va_copy=no
    )
])
AC_MSG_RESULT($ac_cv_va_copy)
AC_MSG_CHECKING(for an implementation of __va_copy())
AC_CACHE_VAL(ac_cv___va_copy,[
    AC_TRY_RUN([
        #include <stdarg.h>
        void f (int i, ...) {
            va_list args1, args2;
            va_start (args1, i);
            __va_copy (args2, args1);
            if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
                exit (1);
            va_end (args1); va_end (args2);
        }
        int main() { f (0, 42); return 0; }],
        ac_cv___va_copy=yes,
        ac_cv___va_copy=no,
        ac_cv___va_copy=no
    )
])
AC_MSG_RESULT($ac_cv___va_copy)
AC_MSG_CHECKING(whether va_lists can be copied by value)
AC_CACHE_VAL(ac_cv_va_val_copy,[
    AC_TRY_RUN([
        #include <stdarg.h>
        void f (int i, ...) {
            va_list args1, args2;
            va_start (args1, i);
            args2 = args1;
            if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
                exit (1);
            va_end (args1); va_end (args2);
        }
        int main() { f (0, 42); return 0; }],
        ac_cv_va_val_copy=yes,
        ac_cv_va_val_copy=no,
        ac_cv_va_val_copy=yes
    )
])
if test "x$ac_cv_va_copy" = "xyes"; then
    AC_DEFINE(VA_COPY, va_copy)
    AC_DEFINE(HAVE_VA_COPY)
elif test "x$ac_cv___va_copy" = "xyes"; then
    AC_DEFINE(VA_COPY, __va_copy)
    AC_DEFINE(HAVE_VA_COPY)
fi

if test "x$ac_cv_va_val_copy" = "xno"; then
   AC_DEFINE(HAVE_VA_LIST_AS_ARRAY)
fi
AC_MSG_RESULT($ac_cv_va_val_copy)

dnl ===================================================================
dnl ========================================================
dnl Put your C++ language/feature checks below
dnl ========================================================
AC_LANG_CPLUSPLUS

ARM_ABI_PREFIX=
if test "$GNU_CC"; then
  if test "$CPU_ARCH" = "arm" ; then
    AC_CACHE_CHECK(for ARM EABI,
        ac_cv_gcc_arm_eabi,
        [AC_TRY_COMPILE([],
                        [
#if defined(__ARM_EABI__)
  return 0;
#else
#error Not ARM EABI.
#endif
                        ],
                        ac_cv_gcc_arm_eabi="yes",
                        ac_cv_gcc_arm_eabi="no")])
    if test "$ac_cv_gcc_arm_eabi" = "yes"; then
        HAVE_ARM_EABI=1
        ARM_ABI_PREFIX=eabi-
    else
        ARM_ABI_PREFIX=oabi-
    fi
  fi

  TARGET_COMPILER_ABI="${TARGET_COMPILER_ABI-${ARM_ABI_PREFIX}gcc3}"
fi

dnl Check for support of modern template specialization syntax
dnl Test code and requirement from scc@netscape.com.
dnl Autoconf cut-and-paste job by waterson@netscape.com
AC_CACHE_CHECK(for modern C++ template specialization syntax support,
               ac_cv_cpp_modern_specialize_template_syntax,
               [AC_TRY_COMPILE(template <class T> struct X { int a; };
                               class Y {};
                               template <> struct X<Y> { double a; };,
                               X<int> int_x;
                               X<Y> y_x;,
                               ac_cv_cpp_modern_specialize_template_syntax=yes,
                               ac_cv_cpp_modern_specialize_template_syntax=no)])
if test "$ac_cv_cpp_modern_specialize_template_syntax" = no ; then
  AC_MSG_ERROR([The C++ compiler does not support template specialization])
fi

dnl Some compilers support only full specialization, and some don't.
AC_CACHE_CHECK(whether partial template specialization works,
               ac_cv_cpp_partial_specialization,
               [AC_TRY_COMPILE(template <class T> class Foo {};
                               template <class T> class Foo<T*> {};,
                               return 0;,
                               ac_cv_cpp_partial_specialization=yes,
                               ac_cv_cpp_partial_specialization=no)])
if test "$ac_cv_cpp_partial_specialization" = yes ; then
  AC_DEFINE(HAVE_CPP_PARTIAL_SPECIALIZATION)
fi

dnl Check to see if we can resolve ambiguity with |using|.
AC_CACHE_CHECK(whether the C++ \"using\" keyword resolves ambiguity,
               ac_cv_cpp_ambiguity_resolving_using,
               [AC_TRY_COMPILE(class X {
                                 public: int go(const X&) {return 3;}
                                         int jo(const X&) {return 3;}
                               };
                               class Y : public X {
                                 public:  int go(int) {return 2;}
                                          int jo(int) {return 2;}
                                          using X::jo;
                                 private: using X::go;
                               };,
                               X x; Y y; y.jo(x);,
                               ac_cv_cpp_ambiguity_resolving_using=yes,
                               ac_cv_cpp_ambiguity_resolving_using=no)])
if test "$ac_cv_cpp_ambiguity_resolving_using" = yes ; then
   AC_DEFINE(HAVE_CPP_AMBIGUITY_RESOLVING_USING)
fi

dnl See if a dynamic_cast to void* gives the most derived object.
AC_CACHE_CHECK(for C++ dynamic_cast to void*,
               ac_cv_cpp_dynamic_cast_void_ptr,
               [AC_TRY_RUN([class X { int i; public: virtual ~X() { } };
                            class Y { int j; public: virtual ~Y() { } };
                            class Z : public X, public Y { int k; };

                            int main() {
                                 Z mdo;
                                 X *subx = (X*)&mdo;
                                 Y *suby = (Y*)&mdo;
                                 return !((((void*)&mdo != (void*)subx) &&
                                           ((void*)&mdo == dynamic_cast<void*>(subx))) ||
                                          (((void*)&mdo != (void*)suby) &&
                                           ((void*)&mdo == dynamic_cast<void*>(suby))));
                            }],
                           ac_cv_cpp_dynamic_cast_void_ptr=yes,
                           ac_cv_cpp_dynamic_cast_void_ptr=no,
                           ac_cv_cpp_dynamic_cast_void_ptr=no)])
if test "$ac_cv_cpp_dynamic_cast_void_ptr" = yes ; then
   AC_DEFINE(HAVE_CPP_DYNAMIC_CAST_TO_VOID_PTR)
fi


dnl note that this one is reversed - if the test fails, then
dnl we require implementations of unused virtual methods. Which
dnl really blows because it means we'll have useless vtable
dnl bloat.
AC_CACHE_CHECK(whether C++ requires implementation of unused virtual methods,
               ac_cv_cpp_unused_required,
               [AC_TRY_LINK(class X {private: virtual void never_called();};,
                               X x;,
                               ac_cv_cpp_unused_required=no,
                               ac_cv_cpp_unused_required=yes)])
if test "$ac_cv_cpp_unused_required" = yes ; then
   AC_DEFINE(NEED_CPP_UNUSED_IMPLEMENTATIONS)
fi


dnl Some compilers have trouble comparing a constant reference to a templatized
dnl class to zero, and require an explicit operator==() to be defined that takes
dnl an int. This test separates the strong from the weak.

AC_CACHE_CHECK(for trouble comparing to zero near std::operator!=(),
               ac_cv_trouble_comparing_to_zero,
               [AC_TRY_COMPILE([#include <algorithm>
                                template <class T> class Foo {};
                                class T2;
                                template <class T> int operator==(const T2*, const T&) { return 0; }
                                template <class T> int operator!=(const T2*, const T&) { return 0; }],
                               [Foo<int> f; return (0 != f);],
                               ac_cv_trouble_comparing_to_zero=no,
                               ac_cv_trouble_comparing_to_zero=yes)])
if test "$ac_cv_trouble_comparing_to_zero" = yes ; then
  AC_DEFINE(HAVE_CPP_TROUBLE_COMPARING_TO_ZERO)
fi

# try harder, when checking for __thread support, see bug 521750 comment #33 and below
# We pass MOZ_OPTIMIZE_LDFLAGS to the linker because if dead_strip is
# enabled, the linker in xcode 4.1 will crash. Without this it would crash when
# linking XUL.
_SAVE_LDFLAGS=$LDFLAGS
LDFLAGS="$LDFLAGS $DSO_PIC_CFLAGS $DSO_LDOPTS $MOZ_OPTIMIZE_LDFLAGS"
AC_CACHE_CHECK(for __thread keyword for TLS variables,
               ac_cv_thread_keyword,
               [AC_TRY_LINK([__thread bool tlsIsMainThread = false;],
                            [return tlsIsMainThread;],
                            ac_cv_thread_keyword=yes,
                            ac_cv_thread_keyword=no)])
LDFLAGS=$_SAVE_LDFLAGS
if test "$ac_cv_thread_keyword" = yes; then
  # mips builds fail with TLS variables because of a binutils bug.
  # See bug 528687
  case "${target}" in
    mips*-*)
      :
      ;;
    *-android*|*-linuxandroid*)
      :
      ;;
    *)
      AC_DEFINE(HAVE_THREAD_TLS_KEYWORD)
      ;;
  esac
fi

dnl See if compiler supports some gcc-style attributes

AC_CACHE_CHECK(for __attribute__((always_inline)),
               ac_cv_attribute_always_inline,
               [AC_TRY_COMPILE([inline void f(void) __attribute__((always_inline));],
                               [],
                               ac_cv_attribute_always_inline=yes,
                               ac_cv_attribute_always_inline=no)])

AC_CACHE_CHECK(for __attribute__((malloc)),
               ac_cv_attribute_malloc,
               [AC_TRY_COMPILE([void* f(int) __attribute__((malloc));],
                               [],
                               ac_cv_attribute_malloc=yes,
                               ac_cv_attribute_malloc=no)])

AC_CACHE_CHECK(for __attribute__((warn_unused_result)),
               ac_cv_attribute_warn_unused,
               [AC_TRY_COMPILE([int f(void) __attribute__((warn_unused_result));],
                               [],
                               ac_cv_attribute_warn_unused=yes,
                               ac_cv_attribute_warn_unused=no)])

dnl End of C++ language/feature checks
AC_LANG_C

dnl ========================================================
dnl =  Internationalization checks
dnl ========================================================
dnl
dnl Internationalization and Locale support is different
dnl on various UNIX platforms.  Checks for specific i18n
dnl features go here.

dnl check for LC_MESSAGES
AC_CACHE_CHECK(for LC_MESSAGES,
		ac_cv_i18n_lc_messages,
		[AC_TRY_COMPILE([#include <locale.h>],
				[int category = LC_MESSAGES;],
				ac_cv_i18n_lc_messages=yes,
				ac_cv_i18n_lc_messages=no)])
if test "$ac_cv_i18n_lc_messages" = yes; then
   AC_DEFINE(HAVE_I18N_LC_MESSAGES)
fi

AC_HAVE_FUNCS(localeconv)
fi # ! SKIP_COMPILER_CHECKS

TARGET_XPCOM_ABI=
if test -n "${CPU_ARCH}" -a -n "${TARGET_COMPILER_ABI}"; then
    TARGET_XPCOM_ABI="${CPU_ARCH}-${TARGET_COMPILER_ABI}"
fi

dnl Mozilla specific options
dnl ========================================================
dnl The macros used for command line options
dnl are defined in build/autoconf/altoptions.m4.

dnl If the compiler supports these attributes, define them as
dnl convenience macros.
if test "$ac_cv_attribute_malloc" = yes ; then
  AC_DEFINE(NS_ATTR_MALLOC, [__attribute__((malloc))])
else
  AC_DEFINE(NS_ATTR_MALLOC,)
fi

if test "$ac_cv_attribute_warn_unused" = yes ; then
  AC_DEFINE(NS_WARN_UNUSED_RESULT, [__attribute__((warn_unused_result))])
else
  AC_DEFINE(NS_WARN_UNUSED_RESULT,)
fi

dnl We can't run TRY_COMPILE tests on Windows, so hard-code some
dnl features that Windows actually does support.

if test -n "$SKIP_COMPILER_CHECKS"; then
   dnl Windows has malloc.h
   AC_DEFINE(MALLOC_H, [<malloc.h>])
   AC_DEFINE(HAVE_FORCEINLINE)
   AC_DEFINE(HAVE_LOCALECONV)
fi # SKIP_COMPILER_CHECKS

dnl ========================================================
dnl = Mozilla update channel, used for disabling features
dnl = not wanted for release.
dnl ========================================================

# app update channel is 'default' when not supplied.
MOZ_ARG_ENABLE_STRING([update-channel],
[  --enable-update-channel=CHANNEL
                          Select application update channel (default=default)],
    MOZ_UPDATE_CHANNEL=`echo $enableval | tr A-Z a-z`)

if test -z "$MOZ_UPDATE_CHANNEL"; then
    MOZ_UPDATE_CHANNEL=default
fi
AC_DEFINE_UNQUOTED(MOZ_UPDATE_CHANNEL, $MOZ_UPDATE_CHANNEL)
AC_SUBST(MOZ_UPDATE_CHANNEL)

dnl ========================================================
dnl =
dnl = Check for external package dependencies
dnl =
dnl ========================================================
MOZ_ARG_HEADER(External Packages)

dnl ========================================================
dnl = Find the right NSPR to use.
dnl ========================================================
MOZ_ARG_WITH_BOOL(system-nspr,
[  --with-system-nspr      Use an NSPR that is already built and installed.
                          Use the 'nspr-config' script in the current path,
                          or look for the script in the directories given with
                          --with-nspr-exec-prefix or --with-nspr-prefix.
                          (Those flags are only checked if you specify
                          --with-system-nspr.)],
    _USE_SYSTEM_NSPR=1 )

MOZ_ARG_WITH_STRING(nspr-cflags,
[  --with-nspr-cflags=FLAGS
                          Pass FLAGS to CC when building code that uses NSPR.
                          Use this when there's no accurate nspr-config
                          script available.  This is the case when building
                          SpiderMonkey as part of the Mozilla tree: the
                          top-level configure script computes NSPR flags
                          that accomodate the quirks of that environment.],
    NSPR_CFLAGS=$withval)
MOZ_ARG_WITH_STRING(nspr-libs,
[  --with-nspr-libs=LIBS   Pass LIBS to LD when linking code that uses NSPR.
                          See --with-nspr-cflags for more details.],
    NSPR_LIBS=$withval)
AC_SUBST(NSPR_CFLAGS)
AC_SUBST(NSPR_LIBS)

dnl Pass either --with-system-nspr or (--with-nspr-cflags and
dnl --with-nspr-libs), but not both.
if test "$_USE_SYSTEM_NSPR" && (test "$NSPR_CFLAGS" -o "$NSPR_LIBS"); then
    AC_MSG_ERROR([--with-system-nspr and --with-nspr-libs/cflags are mutually exclusive.
See 'configure --help'.])
fi

dnl Top-level Mozilla switched to requiring NSPR 4.8.6 (bug 560582), but we don't need it in JS.
if test -n "$_USE_SYSTEM_NSPR"; then
    MOZ_NATIVE_NSPR=
    AM_PATH_NSPR(4.9.2, [MOZ_NATIVE_NSPR=1], [AC_MSG_ERROR([your don't have NSPR installed or your version is too old])])
fi

if test -n "$MOZ_NATIVE_NSPR"; then
    _SAVE_CFLAGS=$CFLAGS
    CFLAGS="$CFLAGS $NSPR_CFLAGS"
    AC_TRY_COMPILE([#include "prlog.h"],
                [#ifndef PR_STATIC_ASSERT
                 #error PR_STATIC_ASSERT not defined
                 #endif],
                [MOZ_NATIVE_NSPR=1],
                AC_MSG_ERROR([system NSPR does not support PR_STATIC_ASSERT]))
    CFLAGS=$_SAVE_CFLAGS
fi

dnl ========================================================
dnl system zlib Support
dnl ========================================================
dnl Standalone js defaults to system zlib
ZLIB_DIR=yes

MOZ_ZLIB_CHECK([1.2.3])

dnl ========================================================
dnl system libffi Support
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(system-ffi,
[  --enable-system-ffi       Use system libffi (located with pkgconfig)],
    MOZ_NATIVE_FFI=1 )

if test -n "$MOZ_NATIVE_FFI"; then
    # Vanilla libffi 3.0.9 needs a few patches from upcoming version 3.0.10
    # for non-GCC compilers.
    if test -z "$GNU_CC"; then
        PKG_CHECK_MODULES(MOZ_FFI, libffi > 3.0.9)
    else
        PKG_CHECK_MODULES(MOZ_FFI, libffi >= 3.0.9)
    fi
fi

AC_SUBST(MOZ_NATIVE_FFI)

dnl ========================================================
dnl =
dnl = Application
dnl =
dnl ========================================================

MOZ_ARG_HEADER(Application)

ENABLE_TESTS=1

USE_ARM_KUSER=

case "${target}" in
    arm*-android*|arm*-linuxandroid*)
        USE_ARM_KUSER=1
        ;;
esac

dnl ========================================================
dnl Use ARM userspace kernel helpers; tell NSPR to enable
dnl their usage and use them in spidermonkey.
dnl ========================================================
MOZ_ARG_WITH_BOOL(arm-kuser,
[  --with-arm-kuser         Use kuser helpers (Linux/ARM only -- requires kernel 2.6.13 or later)],
    USE_ARM_KUSER=1,)
if test -n "$USE_ARM_KUSER"; then
   AC_DEFINE(USE_ARM_KUSER)
fi

dnl ========================================================
dnl =
dnl = Components & Features
dnl =
dnl ========================================================
MOZ_ARG_HEADER(Components and Features)

dnl ========================================================
dnl = Localization
dnl ========================================================
MOZ_ARG_ENABLE_STRING(ui-locale,
[  --enable-ui-locale=ab-CD
                          Select the user interface locale (default: en-US)],
    MOZ_UI_LOCALE=$enableval )
AC_SUBST(MOZ_UI_LOCALE)

dnl ========================================================
dnl build the tests by default
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(tests,
[  --disable-tests         Do not build test libraries & programs],
    ENABLE_TESTS=,
    ENABLE_TESTS=1 )

dnl ========================================================
dnl =
dnl = Module specific options
dnl =
dnl ========================================================
MOZ_ARG_HEADER(Individual module options)

dnl ========================================================
dnl =
dnl = Debugging Options
dnl =
dnl ========================================================
MOZ_ARG_HEADER(Debugging and Optimizations)

dnl ========================================================
dnl = Disable building with debug info.
dnl = Debugging is OFF by default
dnl ========================================================
if test -z "$MOZ_DEBUG_FLAGS"; then
  MOZ_DEBUG_FLAGS="-g"
fi

MOZ_ARG_ENABLE_STRING(debug,
[  --enable-debug[=DBG]    Enable building with developer debug info
                           (using compiler flags DBG)],
[ if test "$enableval" != "no"; then
    MOZ_DEBUG=1
    if test "$ENABLE_METHODJIT"; then
         # needs MethodJIT or YarrJIT
         ENABLE_METHODJIT_SPEW=1
    fi
    if test -n "$enableval" -a "$enableval" != "yes"; then
        MOZ_DEBUG_FLAGS=`echo $enableval | sed -e 's|\\\ | |g'`
        _MOZ_DEBUG_FLAGS_SET=1
    fi
  else
    MOZ_DEBUG=
  fi ],
  MOZ_DEBUG=)

MOZ_DEBUG_ENABLE_DEFS="-DDEBUG -D_DEBUG -DTRACING"
MOZ_ARG_WITH_STRING(debug-label,
[  --with-debug-label=LABELS
                          Define DEBUG_<value> for each comma-separated
                          value given.],
[ for option in `echo $withval | sed 's/,/ /g'`; do
    MOZ_DEBUG_ENABLE_DEFS="$MOZ_DEBUG_ENABLE_DEFS -DDEBUG_${option}"
done])

MOZ_DEBUG_DISABLE_DEFS="-DNDEBUG -DTRIMMED"

if test -n "$MOZ_DEBUG"; then
    AC_MSG_CHECKING([for valid debug flags])
    _SAVE_CFLAGS=$CFLAGS
    CFLAGS="$CFLAGS $MOZ_DEBUG_FLAGS"
    AC_TRY_COMPILE([#include <stdio.h>],
        [printf("Hello World\n");],
        _results=yes,
        _results=no)
    AC_MSG_RESULT([$_results])
    if test "$_results" = "no"; then
        AC_MSG_ERROR([These compiler flags are invalid: $MOZ_DEBUG_FLAGS])
    fi
    CFLAGS=$_SAVE_CFLAGS
fi

if test "$ENABLE_METHODJIT_SPEW"; then
    AC_DEFINE(JS_METHODJIT_SPEW)
fi

dnl ========================================================
dnl = Enable code optimization. ON by default.
dnl ========================================================
if test -z "$MOZ_OPTIMIZE_FLAGS"; then
	MOZ_OPTIMIZE_FLAGS="-O"
fi

MOZ_ARG_ENABLE_STRING(optimize,
[  --disable-optimize      Disable compiler optimization
  --enable-optimize=[OPT] Specify compiler optimization flags [OPT=-O]],
[ if test "$enableval" != "no"; then
    MOZ_OPTIMIZE=1
    if test -n "$enableval" -a "$enableval" != "yes"; then
        MOZ_OPTIMIZE_FLAGS=`echo "$enableval" | sed -e 's|\\\ | |g'`
        MOZ_OPTIMIZE=2
    fi
else
    MOZ_OPTIMIZE=
fi ], MOZ_OPTIMIZE=1)

MOZ_SET_FRAMEPTR_FLAGS

if test "$COMPILE_ENVIRONMENT"; then
if test -n "$MOZ_OPTIMIZE"; then
    AC_MSG_CHECKING([for valid optimization flags])
    _SAVE_CFLAGS=$CFLAGS
    CFLAGS="$CFLAGS $MOZ_OPTIMIZE_FLAGS"
    AC_TRY_COMPILE([#include <stdio.h>],
        [printf("Hello World\n");],
        _results=yes,
        _results=no)
    AC_MSG_RESULT([$_results])
    if test "$_results" = "no"; then
        AC_MSG_ERROR([These compiler flags are invalid: $MOZ_OPTIMIZE_FLAGS])
    fi
    CFLAGS=$_SAVE_CFLAGS
fi
fi # COMPILE_ENVIRONMENT

AC_SUBST(MOZ_OPTIMIZE)
AC_SUBST(MOZ_FRAMEPTR_FLAGS)
AC_SUBST(MOZ_OPTIMIZE_FLAGS)
AC_SUBST(MOZ_OPTIMIZE_LDFLAGS)
AC_SUBST(MOZ_OPTIMIZE_SIZE_TWEAK)
AC_SUBST(MOZ_PGO_OPTIMIZE_FLAGS)

dnl ========================================================
dnl = Enable generation of debug symbols
dnl ========================================================
MOZ_ARG_ENABLE_STRING(debug-symbols,
[  --enable-debug-symbols[=DBG]
                          Enable debugging symbols (using compiler flags DBG)],
[ if test "$enableval" != "no"; then
      MOZ_DEBUG_SYMBOLS=1
      if test -n "$enableval" -a "$enableval" != "yes"; then
          if test -z "$_MOZ_DEBUG_FLAGS_SET"; then
              MOZ_DEBUG_FLAGS=`echo $enableval | sed -e 's|\\\ | |g'`
          else
              AC_MSG_ERROR([--enable-debug-symbols flags cannot be used with --enable-debug flags])
          fi
      fi
  else
      MOZ_DEBUG_SYMBOLS=
  fi ],
  MOZ_DEBUG_SYMBOLS=1)

if test -n "$MOZ_DEBUG" -o -n "$MOZ_DEBUG_SYMBOLS"; then
    AC_DEFINE(MOZ_DEBUG_SYMBOLS)
    export MOZ_DEBUG_SYMBOLS
fi

dnl ========================================================
dnl = Enable trace logging
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(trace-logging,
[  --enable-trace-logging   Enable trace logging],
    ENABLE_TRACE_LOGGING=1,
    ENABLE_TRACE_LOGGING= )

AC_SUBST(ENABLE_TRACE_LOGGING)

if test "$ENABLE_TRACE_LOGGING"; then
    AC_DEFINE(JS_TRACE_LOGGING)
fi

dnl ========================================================
dnl = Enable any treating of compile warnings as errors
dnl ========================================================
MOZ_ARG_DISABLE_BOOL(warnings-as-errors,
[  --enable-warnings-as-errors
                          Enable treating of warnings as errors],
    MOZ_ENABLE_WARNINGS_AS_ERRORS=1,
    MOZ_ENABLE_WARNINGS_AS_ERRORS=)
if test -z "$MOZ_ENABLE_WARNINGS_AS_ERRORS"; then
   WARNINGS_AS_ERRORS=''
fi

dnl ========================================================
dnl = Enable treating compile warnings as errors
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(sm-fail-on-warnings,
[  --enable-sm-fail-on-warnings
                          Enable warnings as errors],
    FAIL_ON_WARNINGS=1,
    FAIL_ON_WARNINGS= )

AC_SUBST(FAIL_ON_WARNINGS)

dnl ========================================================
dnl = Enable trace malloc
dnl ========================================================
NS_TRACE_MALLOC=${MOZ_TRACE_MALLOC}
MOZ_ARG_ENABLE_BOOL(trace-malloc,
[  --enable-trace-malloc   Enable malloc tracing],
    NS_TRACE_MALLOC=1,
    NS_TRACE_MALLOC= )
if test "$NS_TRACE_MALLOC"; then
  # Please, Mr. Linker Man, don't take away our symbol names
  MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS=
  AC_DEFINE(NS_TRACE_MALLOC)
fi
AC_SUBST(NS_TRACE_MALLOC)

dnl ========================================================
dnl = Enable DMD
dnl ========================================================

MOZ_ARG_ENABLE_BOOL(dmd,
[  --enable-dmd            Enable DMD; also enables jemalloc and replace-malloc],
    MOZ_DMD=1,
    MOZ_DMD= )

if test "$NS_TRACE_MALLOC"; then        # trace-malloc disables DMD
    MOZ_DMD=
fi
if test "$MOZ_DMD"; then
    AC_DEFINE(MOZ_DMD)

    if test "${CPU_ARCH}" = "arm"; then
        CFLAGS="$CFLAGS -funwind-tables"
        CXXFLAGS="$CXXFLAGS -funwind-tables"
    fi
fi

dnl ========================================================
dnl = Enable jemalloc
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(jemalloc,
[  --enable-jemalloc       Replace memory allocator with jemalloc],
    MOZ_MEMORY=1,
    MOZ_MEMORY=)

if test "$NS_TRACE_MALLOC"; then
    MOZ_MEMORY=
fi

if test "$MOZ_MEMORY"; then

  dnl Don't try to run compiler tests on Windows
  if test "$OS_ARCH" = "WINNT"; then
    if test -z "$HAVE_64BIT_OS"; then
      AC_DEFINE_UNQUOTED([MOZ_MEMORY_SIZEOF_PTR_2POW], 2)
    else
      AC_DEFINE_UNQUOTED([MOZ_MEMORY_SIZEOF_PTR_2POW], 3)
    fi
  else
    AC_CHECK_SIZEOF([int *], [4])
    case "${ac_cv_sizeof_int_p}" in
    4)
      AC_DEFINE_UNQUOTED([MOZ_MEMORY_SIZEOF_PTR_2POW], 2)
      ;;
    8)
      AC_DEFINE_UNQUOTED([MOZ_MEMORY_SIZEOF_PTR_2POW], 3)
      ;;
    *)
      AC_MSG_ERROR([Unexpected pointer size])
      ;;
    esac
  fi

  AC_DEFINE(MOZ_MEMORY)
  if test "x$MOZ_DEBUG" = "x1"; then
    AC_DEFINE(MOZ_MEMORY_DEBUG)
  fi
  dnl The generic feature tests that determine how to compute ncpus are long and
  dnl complicated.  Therefore, simply define special cpp variables for the
  dnl platforms we have special knowledge of.
  case "${target}" in
  *-darwin*)
    AC_DEFINE(MOZ_MEMORY_DARWIN)
    ;;
  *-*freebsd*)
    AC_DEFINE(MOZ_MEMORY_BSD)
    ;;
  *-android*|*-linuxandroid*)
    AC_DEFINE(MOZ_MEMORY_LINUX)
    AC_DEFINE(MOZ_MEMORY_ANDROID)
    ;;
  *-*linux*)
    AC_DEFINE(MOZ_MEMORY_LINUX)
    ;;
  *-netbsd*)
    AC_DEFINE(MOZ_MEMORY_BSD)
    ;;
  *-solaris*)
    AC_DEFINE(MOZ_MEMORY_SOLARIS)
    ;;
  *-mingw*)
    AC_DEFINE(MOZ_MEMORY_WINDOWS)
    # the interesting bits will get passed down in MOZ_GLUE_LDFLAGS
    ;;
  *)
    AC_MSG_ERROR([--enable-jemalloc not supported on ${target}])
    ;;
  esac
fi
AC_SUBST(MOZ_MEMORY)
AC_SUBST(MOZ_GLUE_LDFLAGS)
AC_SUBST(MOZ_GLUE_PROGRAM_LDFLAGS)

dnl ========================================================
dnl = Use malloc wrapper lib
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(wrap-malloc,
[  --enable-wrap-malloc    Wrap malloc calls (gnu linker only)],
    _WRAP_MALLOC=1,
    _WRAP_MALLOC= )

if test -n "$_WRAP_MALLOC"; then
    if test "$GNU_CC"; then
        WRAP_LDFLAGS="${WRAP_LDFLAGS} -Wl,--wrap=malloc,--wrap=calloc,--wrap=valloc,--wrap=free,--wrap=realloc,--wrap=memalign"
        WRAP_LDFLAGS="${WRAP_LDFLAGS} -Wl,--wrap=__builtin_new,--wrap=__builtin_vec_new,--wrap=__builtin_delete,--wrap=__builtin_vec_delete"
        WRAP_LDFLAGS="${WRAP_LDFLAGS} -Wl,--wrap=strdup,--wrap=strndup"
        WRAP_LDFLAGS="${WRAP_LDFLAGS} -Wl,--wrap=posix_memalign,--wrap=malloc_usable_size"
        dnl Wrap operator new and operator delete on Android.
        if test "$OS_TARGET" = "Android"; then
            WRAP_LDFLAGS="${WRAP_LDFLAGS} -Wl,--wrap=_Znwj,--wrap=_Znaj,--wrap=_ZdlPv,--wrap=_ZdaPv"
        fi
    else
        AC_MSG_ERROR([--enable-wrap-malloc is not supported for non-GNU toolchains])
    fi
fi

dnl ========================================================
dnl = Location of malloc wrapper lib
dnl ========================================================
MOZ_ARG_WITH_STRING(wrap-malloc,
[  --with-wrap-malloc=DIR  Location of malloc wrapper library],
    WRAP_LDFLAGS="${WRAP_LDFLAGS} $withval")

dnl ========================================================
dnl = Use JS Call tracing
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(trace-jscalls,
[  --enable-trace-jscalls  Enable JS call enter/exit callback (default=no)],
    MOZ_TRACE_JSCALLS=1,
    MOZ_TRACE_JSCALLS= )
if test -n "$MOZ_TRACE_JSCALLS"; then
    AC_DEFINE(MOZ_TRACE_JSCALLS)
fi

dnl ========================================================
dnl = Use incremental GC
dnl ========================================================
JSGC_INCREMENTAL=1
MOZ_ARG_DISABLE_BOOL(gcincremental,
[  --disable-gcincremental Disable incremental GC],
    JSGC_INCREMENTAL= )
if test -n "$JSGC_INCREMENTAL"; then
    AC_DEFINE(JSGC_INCREMENTAL)
fi

dnl ========================================================
dnl = Use generational GC
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(gcgenerational,
[  --enable-gcgenerational Enable generational GC],
    JSGC_GENERATIONAL=1,
    JSGC_GENERATIONAL= )
if test -n "$JSGC_GENERATIONAL"; then
    AC_DEFINE(JSGC_GENERATIONAL)
fi

dnl ========================================================
dnl = Perform moving GC stack rooting analysis
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(root-analysis,
[  --enable-root-analysis  Enable moving GC stack root analysis],
    JSGC_ROOT_ANALYSIS=1,
    JSGC_ROOT_ANALYSIS= )
if test -n "$JSGC_ROOT_ANALYSIS"; then
    AC_DEFINE(JSGC_ROOT_ANALYSIS)
fi

dnl ========================================================
dnl = Use exact stack rooting for GC
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(exact-rooting,
[  --enable-exact-rooting  Enable use of exact stack roots for GC],
    JSGC_USE_EXACT_ROOTING=1,
    JSGC_USE_EXACT_ROOTING= )
if test -n "$JSGC_USE_EXACT_ROOTING"; then
    AC_DEFINE(JSGC_USE_EXACT_ROOTING)
fi

dnl ========================================================
dnl = Use Valgrind
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(valgrind,
[  --enable-valgrind       Enable Valgrind integration hooks (default=no)],
    MOZ_VALGRIND=1,
    MOZ_VALGRIND= )
if test -n "$MOZ_VALGRIND"; then
    MOZ_CHECK_HEADER([valgrind/valgrind.h], [],
        AC_MSG_ERROR(
            [--enable-valgrind specified but Valgrind is not installed]))
    AC_DEFINE(MOZ_VALGRIND)
    MOZ_VALGRIND=1
fi
AC_SUBST(MOZ_VALGRIND)

dnl ========================================================
dnl jprof
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(jprof,
[  --enable-jprof          Enable jprof profiling tool (needs mozilla/tools/jprof). Implies --enable-profiling.],
    MOZ_JPROF=1,
    MOZ_JPROF= )
if test -n "$MOZ_JPROF"; then
    MOZ_PROFILING=1
    AC_DEFINE(MOZ_JPROF)
fi

dnl ========================================================
dnl shark
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(shark,
[  --enable-shark          Enable shark remote profiling. Implies --enable-profiling.],
    MOZ_SHARK=1,
    MOZ_SHARK= )
if test -n "$MOZ_SHARK"; then
    MOZ_PROFILING=1
    AC_DEFINE(MOZ_SHARK)
fi

dnl ========================================================
dnl callgrind
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(callgrind,
[  --enable-callgrind      Enable callgrind profiling. Implies --enable-profiling.],
    MOZ_CALLGRIND=1,
    MOZ_CALLGRIND= )
if test -n "$MOZ_CALLGRIND"; then
    MOZ_PROFILING=1
    AC_DEFINE(MOZ_CALLGRIND)
fi

dnl ========================================================
dnl vtune
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(vtune,
[  --enable-vtune          Enable vtune profiling. Implies --enable-profiling.],
    MOZ_VTUNE=1,
    MOZ_VTUNE= )
if test -n "$MOZ_VTUNE"; then
    MOZ_PROFILING=1
    AC_DEFINE(MOZ_VTUNE)
fi

dnl ========================================================
dnl ETW - Event Tracing for Windows
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(ETW,
[  --enable-ETW            Enable ETW (Event Tracing for Windows) event reporting],
    MOZ_ETW=1,
    MOZ_ETW= )
if test -n "$MOZ_ETW"; then
    AC_DEFINE(MOZ_ETW)
    WINVER=600
fi

if test -n "$MOZ_ETW"; then
    if test -z "$MOZ_WINSDK_TARGETVER"; then
        AC_MSG_ERROR([--enable-ETW is only valid on Windows])
    fi
fi

dnl ========================================================
dnl Profiling
dnl ========================================================
if test -n "$MOZ_PROFILING"; then
    AC_DEFINE(MOZ_PROFILING)
fi

dnl ========================================================
dnl Zealous JavaScript GC
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(gczeal,
[  --enable-gczeal         Enable zealous GCing],
    JS_GC_ZEAL=1,
    JS_GC_ZEAL= )
if test -n "$JS_GC_ZEAL" -o -n "$MOZ_DEBUG"; then
    AC_DEFINE(JS_GC_ZEAL)
fi

dnl ========================================================
dnl JS opt-mode assertions and minidump instrumentation
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(js-diagnostics,
[  --enable-js-diagnostics
                          Enable JS diagnostic assertions and breakpad data],
    JS_CRASH_DIAGNOSTICS=1,
    JS_CRASH_DIAGNOSTICS= )
if test -n "$JS_CRASH_DIAGNOSTICS"; then
    AC_DEFINE(JS_CRASH_DIAGNOSTICS)
fi

dnl ========================================================
dnl Enable changes that make the shell more deterministic
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(more-deterministic,
[  --enable-more-deterministic
                          Enable changes that make the shell more deterministic],
    JS_MORE_DETERMINISTIC=1,
    JS_MORE_DETERMINISTIC= )
if test -n "$JS_MORE_DETERMINISTIC"; then
    AC_DEFINE(JS_MORE_DETERMINISTIC)
fi

dnl ========================================================
dnl Enable output of backtraces on artificial OOMs
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(oom-backtrace,
[  --enable-oom-backtrace
                          Enable output of backtraces on artificial OOMs (-A)],
    JS_OOM_DO_BACKTRACES=1,
    JS_OOM_DO_BACKTRACES= )
if test -n "$JS_OOM_DO_BACKTRACES"; then
    AC_DEFINE(JS_OOM_DO_BACKTRACES)
fi

MOZ_CHECK_CCACHE

dnl ========================================================
dnl = Enable static checking using gcc-dehydra
dnl ========================================================

MOZ_ARG_WITH_STRING(static-checking,
[  --with-static-checking=path/to/gcc_dehydra.so
                          Enable static checking of code using GCC-dehydra],
    DEHYDRA_PATH=$withval,
    DEHYDRA_PATH= )

if test -n "$DEHYDRA_PATH"; then
    if test ! -f "$DEHYDRA_PATH"; then
        AC_MSG_ERROR([The dehydra plugin is not at the specified path.])
    fi
    AC_DEFINE(NS_STATIC_CHECKING)
fi
AC_SUBST(DEHYDRA_PATH)

dnl ========================================================
dnl = Enable stripping of libs & executables
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(strip,
[  --enable-strip          Enable stripping of libs & executables ],
    ENABLE_STRIP=1,
    ENABLE_STRIP= )

dnl ========================================================
dnl = Enable stripping of libs & executables when packaging
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(install-strip,
[  --enable-install-strip  Enable stripping of libs & executables when packaging ],
    PKG_SKIP_STRIP= ,
    PKG_SKIP_STRIP=1)

dnl ========================================================
dnl =
dnl = Profiling and Instrumenting
dnl =
dnl ========================================================
MOZ_ARG_HEADER(Profiling and Instrumenting)

dnl ========================================================
dnl = Support for demangling undefined symbols
dnl ========================================================
if test -z "$SKIP_LIBRARY_CHECKS"; then
    AC_LANG_SAVE
    AC_LANG_CPLUSPLUS
    AC_CHECK_FUNCS(__cxa_demangle, HAVE_DEMANGLE=1, HAVE_DEMANGLE=)
    AC_LANG_RESTORE
fi

# Demangle only for debug or trace-malloc or DMD builds
MOZ_DEMANGLE_SYMBOLS=
if test "$HAVE_DEMANGLE" && test "$MOZ_DEBUG" -o "$NS_TRACE_MALLOC" -o "$MOZ_DMD"; then
    MOZ_DEMANGLE_SYMBOLS=1
    AC_DEFINE(MOZ_DEMANGLE_SYMBOLS)
fi
AC_SUBST(MOZ_DEMANGLE_SYMBOLS)

dnl ========================================================
dnl = Support for gcc stack unwinding (from gcc 3.3)
dnl ========================================================
if test -z "$SKIP_LIBRARY_CHECKS"; then
    MOZ_CHECK_HEADER(unwind.h, AC_CHECK_FUNCS(_Unwind_Backtrace))
fi

dnl ========================================================
dnl JIT observers
dnl ========================================================

MOZ_ARG_WITH_STRING(jitreport-granularity,
[  --jitreport-granularity=N
                           Default granularity at which to report JIT code
                           to external tools
                             0 - no info
                             1 - code ranges for whole functions only
                             2 - per-line information
                             3 - per-op information],
  JITREPORT_GRANULARITY=$withval,
  JITREPORT_GRANULARITY=3)

AC_DEFINE_UNQUOTED(JS_DEFAULT_JITREPORT_GRANULARITY, $JITREPORT_GRANULARITY)

dnl ========================================================
dnl =
dnl = Misc. Options
dnl =
dnl ========================================================
MOZ_ARG_HEADER(Misc. Options)

dnl ========================================================
dnl update xterm title
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(xterm-updates,
[  --enable-xterm-updates  Update XTERM titles with current command.],
    MOZ_UPDATE_XTERM=1,
    MOZ_UPDATE_XTERM= )

if test -z "$SKIP_COMPILER_CHECKS"; then
dnl ========================================================
dnl =
dnl = Compiler Options
dnl =
dnl ========================================================
MOZ_ARG_HEADER(Compiler Options)

dnl ========================================================
dnl Check for gcc -pipe support
dnl ========================================================
AC_MSG_CHECKING([for -pipe support])
if test -n "$GNU_CC" -a -n "$GNU_CXX"; then
    dnl Any gcc that supports firefox supports -pipe.
    CFLAGS="$CFLAGS -pipe"
    CXXFLAGS="$CXXFLAGS -pipe"
    AC_MSG_RESULT([yes])
else
    AC_MSG_RESULT([no])
fi

dnl ========================================================
dnl Profile guided optimization (gcc checks)
dnl ========================================================
dnl Test for profiling options
dnl Under gcc 3.4+, use -fprofile-generate/-fprofile-use

_SAVE_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -fprofile-generate -fprofile-correction"

AC_MSG_CHECKING([whether C compiler supports -fprofile-generate])
AC_TRY_COMPILE([], [return 0;],
               [ PROFILE_GEN_CFLAGS="-fprofile-generate"
                 result="yes" ], result="no")
AC_MSG_RESULT([$result])

if test $result = "yes"; then
  PROFILE_GEN_LDFLAGS="-fprofile-generate"
  PROFILE_USE_CFLAGS="-fprofile-use -fprofile-correction -Wcoverage-mismatch"
  PROFILE_USE_LDFLAGS="-fprofile-use"
fi

CFLAGS="$_SAVE_CFLAGS"

if test -n "$INTEL_CC"; then
  PROFILE_GEN_CFLAGS="-prof-gen -prof-dir ."
  PROFILE_GEN_LDFLAGS=
  PROFILE_USE_CFLAGS="-prof-use -prof-dir ."
  PROFILE_USE_LDFLAGS=
fi

dnl Sun Studio on Solaris
if test "$SOLARIS_SUNPRO_CC"; then
  PROFILE_GEN_CFLAGS="-xprofile=collect:$_objdir/$enable_application"
  PROFILE_GEN_LDFLAGS="-xprofile=collect:$_objdir/$enable_application"
  PROFILE_USE_CFLAGS="-xprofile=use:$_objdir/$enable_application"
  PROFILE_USE_LDFLAGS="-xprofile=use:$_objdir/$enable_application"
fi

AC_SUBST(PROFILE_GEN_CFLAGS)
AC_SUBST(PROFILE_GEN_LDFLAGS)
AC_SUBST(PROFILE_USE_CFLAGS)
AC_SUBST(PROFILE_USE_LDFLAGS)

AC_LANG_CPLUSPLUS

dnl ========================================================
dnl Autoconf test for gcc 2.7.2.x (and maybe others?) so that we don't
dnl provide non-const forms of the operator== for comparing nsCOMPtrs to
dnl raw pointers in nsCOMPtr.h.  (VC++ has the same bug.)
dnl ========================================================
_SAVE_CXXFLAGS=$CXXFLAGS
CXXFLAGS="$CXXFLAGS ${_WARNINGS_CXXFLAGS}"
AC_CACHE_CHECK(for correct overload resolution with const and templates,
    ac_nscap_nonconst_opeq_bug,
    [AC_TRY_COMPILE([
                      template <class T>
                      class Pointer
                        {
                        public:
                          T* myPtr;
                        };

                      template <class T, class U>
                      int operator==(const Pointer<T>& rhs, U* lhs)
                        {
                          return rhs.myPtr == lhs;
                        }

                      template <class T, class U>
                      int operator==(const Pointer<T>& rhs, const U* lhs)
                        {
                          return rhs.myPtr == lhs;
                        }
                    ],
                    [
                      Pointer<int> foo;
                      const int* bar;
                      return foo == bar;
                    ],
                    ac_nscap_nonconst_opeq_bug="no",
                    ac_nscap_nonconst_opeq_bug="yes")])
CXXFLAGS="$_SAVE_CXXFLAGS"

if test "$ac_nscap_nonconst_opeq_bug" = "yes" ; then
    AC_DEFINE(NSCAP_DONT_PROVIDE_NONCONST_OPEQ)
fi

dnl ========================================================
dnl Check for tm_zone, tm_gmtoff in struct tm
dnl ========================================================
AC_CACHE_CHECK(for tm_zone tm_gmtoff in struct tm,
    ac_cv_struct_tm_zone_tm_gmtoff,
    [AC_TRY_COMPILE([#include <time.h>],
                    [struct tm tm; tm.tm_zone = 0; tm.tm_gmtoff = 1;],
                    [ac_cv_struct_tm_zone_tm_gmtoff="yes"],
                    [ac_cv_struct_tm_zone_tm_gmtoff="no"])])
if test "$ac_cv_struct_tm_zone_tm_gmtoff" = "yes" ; then
    AC_DEFINE(HAVE_TM_ZONE_TM_GMTOFF)
fi
fi # ! SKIP_COMPILER_CHECKS

AC_DEFINE(CPP_THROW_NEW, [throw()])
AC_LANG_C

MOZ_EXPAND_LIBS

dnl ========================================================
dnl =
dnl = Build depencency options
dnl =
dnl ========================================================
MOZ_ARG_HEADER(Build dependencies)

if test "$GNU_CC" -a "$GNU_CXX"; then
  _DEPEND_CFLAGS='$(filter-out %/.pp,-MD -MF $(MDDEPDIR)/$(@F).pp)'
dnl Sun Studio on Solaris use -xM instead of -MD, see config/rules.mk
elif test "$SOLARIS_SUNPRO_CC"; then
  _DEPEND_CFLAGS=
else
  dnl Don't override this for MSVC
  if test -z "$_WIN32_MSVC"; then
    _USE_CPP_INCLUDE_FLAG=
    _DEFINES_CFLAGS='$(ACDEFINES) -D_JS_CONFDEFS_H_ -DMOZILLA_CLIENT'
    _DEFINES_CXXFLAGS='$(ACDEFINES) -D_JS_CONFDEFS_H_ -DMOZILLA_CLIENT'
  else
    echo '#include <stdio.h>' > dummy-hello.c
    changequote(,)
    CL_INCLUDES_PREFIX=`${CC} -showIncludes -c -Fonul dummy-hello.c 2>&1 | sed -ne 's/^\([^:]*:[^:]*:\).*stdio.h$/\1/p'`
    changequote([,])
    if test -z "$CL_INCLUDES_PREFIX"; then
        AC_MSG_ERROR([Cannot find cl -showIncludes prefix.])
    fi
    AC_SUBST(CL_INCLUDES_PREFIX)
    rm -f dummy-hello.c
  fi
fi

dnl ========================================================
dnl = Disable -fstrict-aliasing with GCC 4.4 and earlier.
dnl = See bugs 821502 and 832623.
dnl ========================================================
if test -n "$GNU_CC" -a -z "$CLANG_CC"; then
    dnl GCC 3.x isn't supported, so we don't need to check for that.
    if test "$GCC_MAJOR_VERSION" -eq "4" -a "$GCC_MINOR_VERSION" -lt "5" ; then
        CFLAGS="$CFLAGS -fno-strict-aliasing"
        CXXFLAGS="$CXXFLAGS -fno-strict-aliasing"
    fi
fi

dnl ========================================================
dnl = Link js shell to system readline
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(readline,
[  --enable-readline       Link js shell to system readline library],
    JS_WANT_READLINE=1,
    JS_WANT_READLINE= )

JS_NATIVE_EDITLINE=
EDITLINE_LIBS=
JS_DISABLE_SHELL=

case "$target" in
*-mingw*)
    NO_EDITLINE=1
    ;;
*)
    ;;
esac

if test -z "$SKIP_LIBRARY_CHECKS" -a -z "$NO_EDITLINE"; then
  if test -n "$JS_WANT_READLINE"; then
    AC_CHECK_LIB(readline, readline,
                 EDITLINE_LIBS="-lreadline",
                 AC_MSG_ERROR([No system readline library found.]))
  else
    dnl By default, we use editline
    JS_NATIVE_EDITLINE=1
    EDITLINE_LIBS='$(DEPTH)/editline/$(LIB_PREFIX)editline.$(LIB_SUFFIX)'
  fi

  dnl Either way, we want to build with line editing support.
  AC_DEFINE(EDITLINE)
fi
AC_SUBST(JS_NATIVE_EDITLINE)
AC_SUBST(JS_DISABLE_SHELL)
AC_SUBST(EDITLINE_LIBS)

dnl ========================================================
dnl =
dnl = Standalone module options
dnl =
dnl ========================================================
MOZ_ARG_HEADER(Standalone module options (Not for building Mozilla))

dnl ========================================================
dnl = Build jsctypes if it's enabled
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(ctypes,
[  --enable-ctypes         Enable js-ctypes (default=no)],
    JS_HAS_CTYPES=1,
    JS_HAS_CTYPES= )
AC_SUBST(JS_HAS_CTYPES)
if test "$JS_HAS_CTYPES"; then
  dnl Error out if we're on MSVC and MASM is unavailable.
  if test -n "$_MSC_VER" -a \( "$AS" != "ml.exe" -a "$AS" != "ml64.exe" \); then
    AC_MSG_ERROR([\"$AS\" is not a suitable assembler to build js-ctypes. If you are building with MS Visual Studio 8 Express, you may download the MASM 8.0 package, upgrade to Visual Studio 9 Express, or install the Vista SDK. Or do not use --enable-ctypes.])
  fi
  AC_DEFINE(JS_HAS_CTYPES)
fi

if test "$MOZ_DEBUG" -o "$NS_TRACE_MALLOC" -o "$MOZ_DMD"; then
    MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS=
fi

dnl ========================================================
dnl =
dnl = Options for generating the shell as a script
dnl =
dnl ========================================================

MOZ_ARG_WITH_STRING(qemu-exe,
[  --with-qemu-exe=path   Use path as an arm emulator on host platforms],
    QEMU_EXE=$withval)
AC_SUBST(QEMU_EXE)
MOZ_ARG_WITH_STRING(cross-lib,
[  --with-cross-lib=dir   Use dir as the location for arm libraries],
    CROSS_LIB=$withval,
    CROSS_LIB=/usr/$target)
AC_SUBST(CROSS_LIB)
dnl ========================================================
dnl =
dnl = Maintainer debug option (no --enable equivalent)
dnl =
dnl ========================================================

AC_SUBST(AR)
AC_SUBST(AR_FLAGS)
AC_SUBST(AR_LIST)
AC_SUBST(AR_EXTRACT)
AC_SUBST(AR_DELETE)
AC_SUBST(AS)
AC_SUBST(ASFLAGS)
AC_SUBST(AS_DASH_C_FLAG)
AC_SUBST(LD)
AC_SUBST(RC)
AC_SUBST(RCFLAGS)
AC_SUBST(MC)
AC_SUBST(WINDRES)
AC_SUBST(IMPLIB)
AC_SUBST(FILTER)
AC_SUBST(BIN_FLAGS)
AC_SUBST(MOZ_JS_LIBS)
AC_SUBST(MOZ_DEBUG)
AC_SUBST(MOZ_DEBUG_SYMBOLS)
AC_SUBST(MOZ_DEBUG_ENABLE_DEFS)
AC_SUBST(MOZ_DEBUG_DISABLE_DEFS)
AC_SUBST(MOZ_DEBUG_FLAGS)
AC_SUBST(MOZ_DEBUG_LDFLAGS)
AC_SUBST(WARNINGS_AS_ERRORS)
AC_SUBST(MOZ_JPROF)
AC_SUBST(MOZ_SHARK)
AC_SUBST(MOZ_CALLGRIND)
AC_SUBST(MOZ_VTUNE)
AC_SUBST(MOZ_ETW)
AC_SUBST(MOZ_PROFILING)
AC_SUBST(LIBICONV)

AC_SUBST(ENABLE_TESTS)

AC_SUBST(ENABLE_STRIP)
AC_SUBST(PKG_SKIP_STRIP)
AC_SUBST(INCREMENTAL_LINKER)
AC_SUBST(MOZ_COMPONENTS_VERSION_SCRIPT_LDFLAGS)
AC_SUBST(MOZ_COMPONENT_NSPR_LIBS)

AC_SUBST(MOZ_FIX_LINK_PATHS)

AC_SUBST(USE_DEPENDENT_LIBS)

AC_SUBST(MOZ_BUILD_ROOT)
AC_SUBST(MOZ_OS2_TOOLS)

AC_SUBST(MOZ_POST_DSO_LIB_COMMAND)
AC_SUBST(MOZ_POST_PROGRAM_COMMAND)

AC_SUBST(MOZ_APP_NAME)
AC_SUBST(MOZ_APP_DISPLAYNAME)
AC_SUBST(MOZ_APP_VERSION)

AC_SUBST(MOZ_PKG_SPECIAL)

AC_SUBST(MOZILLA_OFFICIAL)

dnl win32 options
AC_SUBST(MOZ_MAPINFO)
AC_SUBST(MOZ_BROWSE_INFO)
AC_SUBST(MOZ_TOOLS_DIR)

dnl Echo the CFLAGS to remove extra whitespace.
CFLAGS=`echo \
	$_WARNINGS_CFLAGS \
	$CFLAGS`

CXXFLAGS=`echo \
	$_WARNINGS_CXXFLAGS \
	$CXXFLAGS`

COMPILE_CFLAGS=`echo \
    $_DEFINES_CFLAGS \
	$_DEPEND_CFLAGS \
    $COMPILE_CFLAGS`

COMPILE_CXXFLAGS=`echo \
    $_DEFINES_CXXFLAGS \
	$_DEPEND_CFLAGS \
    $COMPILE_CXXFLAGS`

AC_SUBST(NSPR_CFLAGS)
AC_SUBST(NSPR_LIBS)
AC_SUBST(MOZ_NATIVE_NSPR)

OS_CFLAGS="$CFLAGS"
OS_CXXFLAGS="$CXXFLAGS"
OS_CPPFLAGS="$CPPFLAGS"
OS_COMPILE_CFLAGS="$COMPILE_CFLAGS"
OS_COMPILE_CXXFLAGS="$COMPILE_CXXFLAGS"
OS_LDFLAGS="$LDFLAGS"
OS_LIBS="$LIBS"
AC_SUBST(OS_CFLAGS)
AC_SUBST(OS_CXXFLAGS)
AC_SUBST(OS_CPPFLAGS)
AC_SUBST(OS_COMPILE_CFLAGS)
AC_SUBST(OS_COMPILE_CXXFLAGS)
AC_SUBST(OS_LDFLAGS)
AC_SUBST(OS_LIBS)
AC_SUBST(CROSS_COMPILE)
AC_SUBST(MOZ_METRO)

AC_SUBST(HOST_CC)
AC_SUBST(HOST_CXX)
AC_SUBST(HOST_CFLAGS)
AC_SUBST(HOST_CXXFLAGS)
AC_SUBST(HOST_LDFLAGS)
AC_SUBST(HOST_OPTIMIZE_FLAGS)
AC_SUBST(HOST_AR)
AC_SUBST(HOST_AR_FLAGS)
AC_SUBST(HOST_LD)
AC_SUBST(HOST_RANLIB)
AC_SUBST(HOST_NSPR_MDCPUCFG)
AC_SUBST(HOST_BIN_SUFFIX)
AC_SUBST(HOST_OS_ARCH)

AC_SUBST(TARGET_CPU)
AC_SUBST(TARGET_VENDOR)
AC_SUBST(TARGET_OS)
AC_SUBST(TARGET_NSPR_MDCPUCFG)
AC_SUBST(TARGET_MD_ARCH)
AC_SUBST(TARGET_XPCOM_ABI)
AC_SUBST(OS_TARGET)
AC_SUBST(OS_ARCH)
AC_SUBST(OS_RELEASE)
AC_SUBST(OS_TEST)
AC_SUBST(CPU_ARCH)
AC_SUBST(INTEL_ARCHITECTURE)

AC_SUBST(WRAP_LDFLAGS)
AC_SUBST(MKSHLIB)
AC_SUBST(MKCSHLIB)
AC_SUBST(MKSHLIB_FORCE_ALL)
AC_SUBST(MKSHLIB_UNFORCE_ALL)
AC_SUBST(DSO_CFLAGS)
AC_SUBST(DSO_PIC_CFLAGS)
AC_SUBST(DSO_LDOPTS)
AC_SUBST(LIB_PREFIX)
AC_SUBST(DLL_PREFIX)
AC_SUBST(DLL_SUFFIX)
AC_DEFINE_UNQUOTED(MOZ_DLL_SUFFIX, "$DLL_SUFFIX")
AC_SUBST(LIB_SUFFIX)
AC_SUBST(OBJ_SUFFIX)
AC_SUBST(BIN_SUFFIX)
AC_SUBST(ASM_SUFFIX)
AC_SUBST(IMPORT_LIB_SUFFIX)
AC_SUBST(USE_N32)
AC_SUBST(CC_VERSION)
AC_SUBST(CXX_VERSION)
AC_SUBST(MSMANIFEST_TOOL)

AC_MSG_CHECKING([for posix_fallocate])
AC_TRY_LINK([#define _XOPEN_SOURCE 600
  #include <fcntl.h>],
                 [posix_fallocate(0, 0, 0);],
                 [ac_cv___posix_fallocate=true],
                 [ac_cv___posix_fallocate=false])

if test "$ac_cv___posix_fallocate" = true ; then
  AC_DEFINE(HAVE_POSIX_FALLOCATE)
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
fi

dnl Check for missing components
if test "$COMPILE_ENVIRONMENT"; then
if test "$MOZ_X11"; then
    dnl ====================================================
    dnl = Check if X headers exist
    dnl ====================================================
    _SAVE_CFLAGS=$CFLAGS
    CFLAGS="$CFLAGS $XCFLAGS"
    AC_TRY_COMPILE([
        #include <stdio.h>
        #include <stdlib.h>
        #include <X11/Xlib.h>
        #include <X11/Intrinsic.h>
    ],
    [
        Display *dpy = 0;
        if ((dpy = XOpenDisplay(NULL)) == NULL) {
            fprintf(stderr, ": can't open %s\n", XDisplayName(NULL));
            exit(1);
        }
    ], [],
    [ AC_MSG_ERROR([Could not compile basic X program.]) ])
    CFLAGS="$_SAVE_CFLAGS"

    if test -n "$MISSING_X"; then
        AC_MSG_ERROR([ Could not find the following X libraries: $MISSING_X ]);
    fi

fi # MOZ_X11
fi # COMPILE_ENVIRONMENT

dnl Set various defines and substitutions
dnl ========================================================

if test "$OS_ARCH" = "Darwin"; then
  AC_DEFINE(XP_MACOSX)
  AC_DEFINE(XP_UNIX)
elif test "$OS_ARCH" != "WINNT" -a "$OS_ARCH" != "OS2"; then
  AC_DEFINE(XP_UNIX)
fi

AC_ARG_ENABLE(threadsafe,
    [  --enable-threadsafe     Enable support for multiple threads.],
    [if test "x$enableval" = "xyes"; then
        AC_DEFINE(JS_THREADSAFE)
    fi],)

if test "$MOZ_DEBUG"; then
    AC_DEFINE(MOZ_REFLOW_PERF)
    AC_DEFINE(MOZ_REFLOW_PERF_DSP)
fi

if test "$ACCESSIBILITY" -a "$MOZ_ENABLE_GTK2" ; then
    AC_DEFINE(MOZ_ACCESSIBILITY_ATK)
    ATK_FULL_VERSION=`$PKG_CONFIG --modversion atk`
    ATK_MAJOR_VERSION=`echo ${ATK_FULL_VERSION} | $AWK -F\. '{ print $1 }'`
    ATK_MINOR_VERSION=`echo ${ATK_FULL_VERSION} | $AWK -F\. '{ print $2 }'`
    ATK_REV_VERSION=`echo ${ATK_FULL_VERSION} | $AWK -F\. '{ print $3 }'`
    AC_DEFINE_UNQUOTED(ATK_MAJOR_VERSION, $ATK_MAJOR_VERSION)
    AC_DEFINE_UNQUOTED(ATK_MINOR_VERSION, $ATK_MINOR_VERSION)
    AC_DEFINE_UNQUOTED(ATK_REV_VERSION, $ATK_REV_VERSION)
fi

dnl ========================================================
dnl JavaScript shell
dnl ========================================================

AC_HAVE_FUNCS(setlocale)
AC_HAVE_FUNCS(localeconv)

AC_SUBST(MOZILLA_VERSION)

AC_SUBST(ac_configure_args)

dnl Spit out some output
dnl ========================================================

AC_OUTPUT([js-confdefs.h Makefile config/autoconf.mk])

# Produce the js-config script at configure time; see the comments for
# 'js-config' in Makefile.in.
AC_MSG_RESULT(invoking $MAKE to create js-config script)
$MAKE js-config

# Build jsctypes if it's enabled.
if test "$JS_HAS_CTYPES" -a -z "$MOZ_NATIVE_FFI"; then
  # Run the libffi 'configure' script.
  ac_configure_args="--disable-shared --enable-static --disable-raw-api"
  if test "$MOZ_DEBUG"; then
    ac_configure_args="$ac_configure_args --enable-debug"
  fi
  if test "$DSO_PIC_CFLAGS"; then
    ac_configure_args="$ac_configure_args --with-pic"
  fi
  if test "$CROSS_COMPILE"; then
    case "$target" in
    *-android*|*-linuxandroid*)
      export AS CC CXX CPP LD AR RANLIB STRIP CPPFLAGS CFLAGS LDFLAGS

      ac_configure_args="$ac_configure_args --build=$build --host=$target HOST_CC=\"$HOST_CC\""
      ;;
    *)
      ac_configure_args="$ac_configure_args --build=$build --host=$target HOST_CC=\"$HOST_CC\" CC=\"$CC\""
      ;;
    esac
  fi
  if test "$_MSC_VER"; then
    # Use a wrapper script for cl and ml that looks more like gcc.
    # autotools can't quite handle an MSVC build environment yet.
    LDFLAGS=
    CFLAGS=
    ac_configure_args="$ac_configure_args LD=link CPP=\"cl -nologo -EP\" SHELL=sh.exe"
    case "${target_cpu}" in
    x86_64)
      # Need target since MSYS tools into mozilla-build may be 32bit
      ac_configure_args="$ac_configure_args CC=\"$_topsrcdir/ctypes/libffi/msvcc.sh -m64\" --build=$build --host=$target"
      ;;
    *)
      ac_configure_args="$ac_configure_args CC=$_topsrcdir/ctypes/libffi/msvcc.sh"
      ;;
    esac
  fi
  if test "$SOLARIS_SUNPRO_CC"; then
    # Always use gcc for libffi on Solaris
    if test ! "$HAVE_64BIT_OS"; then
      ac_configure_args="$ac_configure_args CC=gcc CFLAGS=-m32 LD= LDFLAGS="
    else
      ac_configure_args="$ac_configure_args CC=gcc CFLAGS=-m64 LD= LDFLAGS="
    fi
  fi
  if test "$AIX_IBM_XLC"; then
    # Always use gcc for libffi on IBM AIX5/AIX6
    if test ! "$HAVE_64BIT_OS"; then
      ac_configure_args="$ac_configure_args CC=gcc CFLAGS=-maix32"
    else
      ac_configure_args="$ac_configure_args CC=gcc CFLAGS=-maix64"
    fi
  fi
  if test "$OS_ARCH" = "OS2"; then
    ac_configure_args="$ac_configure_args CFLAGS=-Zomf AR=emxomfar"
  fi

  # Use a separate cache file for libffi, since it does things differently
  # from our configure.
  mkdir -p $_objdir/ctypes/libffi
  old_cache_file=$cache_file
  cache_file=$_objdir/ctypes/libffi/config.cache
  old_config_files=$CONFIG_FILES
  unset CONFIG_FILES
  AC_OUTPUT_SUBDIRS(ctypes/libffi)
  cache_file=$old_cache_file
  ac_configure_args="$_SUBDIR_CONFIG_ARGS"
  CONFIG_FILES=$old_config_files
fi