dnl -- configure.am - Automake based configuration --------------------------===
dnl
dnl                   The LLVM Compiler Infrastructure
dnl
dnl This file was developed by Reid Spencer and is distributed under the 
dnl University of Illinois Open Source License. See LICENSE.TXT for details.
dnl 
dnl ===----------------------------------------------------------------------===
dnl

dnl ===----------------------------------------------------------------------===
dnl --
dnl -- SECTION 1: Initialization & Setup
dnl --
dnl ===----------------------------------------------------------------------===

dnl Initialize autoconf
AC_INIT([[LLVM]],[[1.4]],[llvmbugs@cs.uiuc.edu])

dnl Place all of the extra autoconf files into the config subdirectory
dnl Tell various tools where the m4 autoconf macros are
dnl Have configure verify that the source directory is valid.
AC_CONFIG_AUX_DIR([autoconf])

dnl AC_CONFIG_MACRO_DIR(autoconf/m4)
dnl Verify that the source directory is valid
AC_CONFIG_SRCDIR(["lib/VMCore/Module.cpp"])

dnl Check which host/target for which we're compiling.  This will tell us which 
dnl LLVM compiler will be used for compiling SSA into object code.
AC_CANONICAL_TARGET

dnl Quit if the source directory has already been configured.
dnl NOTE: This relies upon undocumented autoconf behavior.
if test ${srcdir} != "." ; then
	if test -f ${srcdir}/include/llvm/Config/config.h ; then
		AC_MSG_ERROR([Already configured in ${srcdir}])
	fi
fi

dnl Initialize automake
AM_INIT_AUTOMAKE([foreign dejagnu dist-zip nostdinc -Wnone -Wunsupported -Wsyntax -Wobsolete])

dnl Make sure we are using the right version of autoconf
AC_PREREQ(2.59)

dnl ===----------------------------------------------------------------------===
dnl --
dnl -- SECTION 2: Setup The Command Line Arguments For "configure"
dnl --
dnl ===----------------------------------------------------------------------===

dnl Specify where to find the llvm-gcc install directory
AC_ARG_WITH(llvmgccdir,
  AS_HELP_STRING([--with-llvmgccdir],[Location of LLVM GCC front-end]),
  [case "${withval}" in
    /*|*/*) LLVMGCCDIR=$withval ;;
    *) AC_MSG_ERROR([bad value ${withval} for --with-llvmgccdir]) ;;
  esac],
  [LLVMGCCDIR=/usr/local/llvm-gcc])
AC_SUBST(LLVMGCCDIR)

dnl Specify whether to build optimized or not
AC_ARG_ENABLE(optimized,
  AS_HELP_STRING([--enable-optimized],[Build an optimized version of LLVM
  (default=no)]),
  [case "${withval}" in
    yes) ENABLE_OPTIMIZED=1 ;;
    no)  ENABLE_OPTIMIZED=0 ;;
    "")  ENABLE_OPTIMIZED=0 ;;
    *)   AC_MSG_ERROR([bad value ${withval} for --enable-optimized]) ;;
  esac],
  [ENABLE_OPTIMIZED=0])
AC_SUBST(ENABLE_OPTIMIZED)
AM_CONDITIONAL(ENABLE_OPTIMIZED,test $ENABLE_OPTIMIZED = 1)

dnl Specify whether to build profiled or not
AC_ARG_ENABLE(profiled,
  AS_HELP_STRING([--enable-profiled],[Build a profiled version of LLVM
  (default=no)]),
  [case "${withval}" in
    yes) ENABLE_PROFILED=1 ;;
    no)  ENABLE_PROFILED=0 ;;
    "")  ENABLE_PROFILED=0 ;;
    *)   AC_MSG_ERROR([bad value ${withval} for --enable-profiled]) ;;
  esac],
  [ENABLE_PROFILED=0])
AC_SUBST(ENABLE_PROFILED,$ENABLE_PROFILED)
AM_CONDITIONAL(ENABLE_PROFILED,test $ENABLE_PROFILED = 1)

dnl JIT Option
AC_ARG_ENABLE(jit,
  AS_HELP_STRING([--enable-jit],
    [Enable Just In Time Compiling (default is YES)]),,
  enableval=default)

if test ${enableval} = "no"
then
  AC_SUBST(JIT,[[]])
else
  case $target in
    *i*86*) AC_SUBST(JIT,[[TARGET_HAS_JIT=1]]) ;;
    *sparc*) AC_SUBST(JIT,[[TARGET_HAS_JIT=1]]) ;;
          *) AC_SUBST(JIT,[[]]) ;;
  esac
fi

dnl ===----------------------------------------------------------------------===
dnl --
dnl -- SECTION 3: Platform/Architecture Configuration
dnl --
dnl ===----------------------------------------------------------------------===

dnl Set the "OS" Makefile variable based on the system we are building on.
AC_MSG_CHECKING([support for generic build operating system])
case $build in
  *-*-aix*)      llvm_platform_type="AIX" ;;
  *-*-cygwin*)   llvm_platform_type="Cygwin" ;;
  *-*-darwin*)   llvm_platform_type="Darwin" ;;
  *-*-freebsd*)  llvm_platform_type="FreeBSD" ;;
  *-*-interix*)  llvm_platform_type="Interix" ;;
  *-*-linux*)    llvm_platform_type="Linux" ;;
  *-*-solaris*)  llvm_platform_type="SunOS" ;;
  *-*-win32*)    llvm_platform_type="Win32" ;;
  *-*-mingw*)    llvm_platform_type="Win32" ;;
  *)   
    AC_MSG_ERROR([Platform is unknown, configure can't continue])
    llvm_platform_type="Unknown"
    ;;
esac
AC_SUBST(OS,$llvm_platform_type)
AC_MSG_RESULT($llvm_platform_type)

AC_MSG_CHECKING(target architecture)
dnl If we are targetting a Sparc machine running Solaris, pretend that it is
dnl V9, since that is all that we support at the moment, and autoconf will only
dnl tell us we're a sparc.
case $target in
  sparc*-*-solaris*)  AC_SUBST(target,[[sparcv9-sun-solaris2.8]]) ;;
esac

dnl Determine what our target architecture is and configure accordingly.
dnl This will allow Makefiles to make a distinction between the hardware and
dnl the OS.
case $target in
  i*86-*)      ARCH="x86" ;;
  sparc*-*)    ARCH="Sparc" ;;
  powerpc*-*)  ARCH="PowerPC" ;;
	*)     ARCH="Unknown";;
esac
AM_CONDITIONAL(ARCH_X86,test $ARCH = "x86")
AM_CONDITIONAL(ARCH_SPARC,test $ARCH = "Sparc")
AM_CONDITIONAL(ARCH_PPC,test $ARCH = "PowerPC")
AM_CONDITIONAL(ARCH_UNKNOWN,test $ARCH = "Unknown")
AC_SUBST(ARCH,$ARCH)
AC_MSG_RESULT($ARCH)

dnl Check for the endianness of the target
AC_C_BIGENDIAN(AC_SUBST([ENDIAN],[big]),AC_SUBST([ENDIAN],[little]))

dnl ===----------------------------------------------------------------------===
dnl --
dnl -- SECTION 4: Check For Programs We Need
dnl --
dnl ===----------------------------------------------------------------------===

dnl Find the install program (needs to be done before canonical stuff)
AC_PROG_INSTALL

dnl Check for compilation tools
AC_PROG_CXX
AC_PROG_CC(gcc)
AC_PROG_CPP

dnl Checks for other build tools
AC_PROG_FLEX
AC_PROG_BISON
AC_PROG_LIBTOOL

dnl Checks for tools we can get away with not having:
AC_PATH_PROG(DOT,[dot],[true dot])
AC_PATH_PROG(ETAGS,[etags],[true etags])
AC_PATH_PROG(PYTHON,[python],[true python])
AC_PATH_PROG(QMTEST,[qmtest],[true qmtest])

dnl ===----------------------------------------------------------------------===
dnl --
dnl -- SECTION 5: Basic sanity checks on dependent programs we need
dnl --
dnl ===----------------------------------------------------------------------===

dnl Ensure that compilation tools are GCC; we use GCC specific extensions
if test "$GCC" != "yes"
then
  AC_MSG_ERROR([gcc required but not found])
fi

dnl Ensure that compilation tools are GCC; we use GCC specific extensions
if test "$GXX" != "yes"
then
  AC_MSG_ERROR([g++ required but not found])
fi

dnl Verify that GCC is version 3.0 or higher
gccmajor=`$CC --version | head -n 1 | awk '{print $NF;}' | cut -d. -f1`
if test "$gccmajor" -lt "3"
then
  AC_MSG_ERROR([gcc 3.x required, but you have a lower version])
fi

dnl Check for GNU Make.  We use its extensions too, so don't build without it
AC_CHECK_GNU_MAKE
if test -z "$_cv_gnu_make_command"
then
  AC_MSG_ERROR([GNU Make required but not found])
fi

dnl Find the LLVM GCC-based C/C++ front end
AC_MSG_CHECKING([for llvm-gcc])
LLVM_GCC_CHECK=no
if test -d "$LLVMGCCDIR"
then
  if test -x "$LLVMGCCDIR/bin/gcc"
  then
    LLVM_GCC_CHECK="$LLVMGCCDIR/bin/gcc"
  fi
fi
llvmgccwarn=no
AC_MSG_RESULT($LLVM_GCC_CHECK)
if test "$LLVM_GCC_CHECK" = "no"
then
    llvmgccwarn=yes
fi

dnl Determine if the "gcc" found produces LLVM assembly. If so its "sane"
AC_MSG_CHECKING([whether llvm-gcc is sane])
LLVM_GCC_SANE=no
if test -x "$LLVM_GCC_CHECK"
then
  cp /dev/null conftest.c
  "$LLVM_GCC_CHECK" -S -o - conftest.c | grep implementation > /dev/null 2>&1
  if test $? -eq 0
  then
    LLVM_GCC_SANE=yes
  fi
  rm conftest.c
  llvmcc1path=`"$LLVM_GCC_CHECK" --print-prog-name=cc1`
  AC_SUBST(LLVMCC1,$llvmcc1path)
  llvmcc1pluspath=`"$LLVM_GCC_CHECK" --print-prog-name=cc1plus`
  AC_SUBST(LLVMCC1PLUS,$llvmcc1pluspath)
fi
AC_MSG_RESULT($LLVM_GCC_SANE)
if test "$LLVM_GCC_SANE" = "no"
then
  llvmgccwarn=yes
fi

dnl Check if we know how to tell etags we are using C++:
etags_version=`$ETAGS --version 2>&1`
case "$etags_version" in
  *[Ee]xuberant*) ETAGSFLAGS="--language-force=c++" ;;
  *GNU\ Emacs*) ETAGSFLAGS="-l c++" ;;
  *) ETAGSFLAGS="" ;;
esac
AC_SUBST(ETAGSFLAGS,$ETAGSFLAGS)

if test "$PYTHON" = "false"
then
  AC_MSG_WARN([Python is required for the test suite, but it was not found])
fi
if test "$QMTEST" = "false"
then
  AC_MSG_WARN([QMTest is required for the test suite, but it was not found])
fi

dnl Verify that the version of python available is high enough for qmtest
pyversion=`$PYTHON -V 2>&1 | cut -d\  -f2`
pymajor=`echo $pyversion | cut -d. -f1`
pyminor=`echo $pyversion | cut -d. -f2`

if test "$pymajor" -ge "2"
then
  if test "$pymajor" -eq "2"
  then
    if test "$pyminor" -lt "2"
    then
      AC_MSG_WARN([QMTest requires Python 2.2 or later])
    fi
  fi
else
  AC_MSG_WARN([QMTest requires Python 2.2 or later])
fi

dnl ===----------------------------------------------------------------------===
dnl --
dnl -- SECTION 6: Check For Needed Libraries
dnl --
dnl ===----------------------------------------------------------------------===

dnl libelf is for sparc only; we can ignore it if we don't have it
AC_CHECK_LIB(elf, elf_begin)

dnl Check for bzip2 and zlib compression libraries needed for archive 
dnl reading/writing
AC_CHECK_LIB(bz2,BZ2_bzCompressInit,[bzip2_found=1],[bzip2_found=0])
AC_CHECK_LIB(z,gzopen,[zlib_found=1],[zlib_found=0])

dnl dlopen() is required for plugin support.
AC_SEARCH_LIBS(dlopen,dl,
  AC_DEFINE([HAVE_DLOPEN],[1],
            [Define if dlopen() is available on this platform.]),
    AC_MSG_WARN([dlopen() not found - disabling plugin support]))

dnl mallinfo is optional; the code can compile (minus features) without it
AC_SEARCH_LIBS(mallinfo,malloc,
  AC_DEFINE([HAVE_MALLINFO],[1],
    [Define if mallinfo() is available on this platform.]))

dnl pthread locking functions are optional - but llvm will not be thread-safe
dnl without locks.
AC_SEARCH_LIBS(pthread_mutex_lock,pthread,
  AC_DEFINE([HAVE_PTHREAD_MUTEX_LOCK],[1],[Have pthread_mutex_lock]))


dnl ===----------------------------------------------------------------------===
dnl --
dnl -- SECTION 7: Check For Needed Header Files
dnl --
dnl ===----------------------------------------------------------------------===

dnl We don't check for ancient stuff or things that are guaranteed to be there
dnl by the C++ standard. We always use the <cfoo> versions of <foo.h> C headers.
AC_HEADER_STDC
AC_HEADER_SYS_WAIT
AC_HEADER_TIME
AC_HEADER_MMAP_ANONYMOUS

dnl Checks for POSIX and other various system-specific header files
AC_CHECK_HEADERS(fcntl.h limits.h sys/time.h unistd.h malloc.h sys/mman.h)
AC_CHECK_HEADERS(sys/resource.h dlfcn.h link.h execinfo.h windows.h)

dnl Check for things that need to be included in public headers, and so
dnl for which we may not have access to a HAVE_* preprocessor #define.
dnl (primarily used in DataTypes.h)
AC_CHECK_HEADER([sys/types.h])
AC_CHECK_HEADER([inttypes.h])
AC_CHECK_HEADER([stdint.h])

dnl Checks for compression headers:
AC_CHECK_HEADERS([bzlib.h],[bzlib_h_found=1],[bzlib_h_found=0],[])
AC_CHECK_HEADERS([zlib.h],[zlib_h_found=1],[zlib_h_found=0],[])

dnl ===----------------------------------------------------------------------===
dnl --
dnl -- SECTION 8: Check for specific features (types/functions/options/etc)
dnl --
dnl ===----------------------------------------------------------------------===

dnl Check for types
AC_TYPE_PID_T
AC_TYPE_SIZE_T
AC_TYPE_SIGNAL
AC_STRUCT_TM
AC_CHECK_TYPES([int64_t],,AC_MSG_ERROR([Type int64_t required but not found]))
AC_CHECK_TYPES([uint64_t],,
  AC_CHECK_TYPES([u_int64_t],,
    AC_MSG_ERROR([Type uint64_t or u_int64_t required but not found])))

dnl Check for various C features
AC_C_PRINTF_A
AC_FUNC_ISNAN
AC_FUNC_ISINF
AC_FUNC_ALLOCA
AC_FUNC_MMAP
if test "$ac_cv_func_mmap_fixed_mapped" = "no"
then
  AC_MSG_WARN([mmap() required but not found])
fi
AC_FUNC_MMAP_FILE
if test "$ac_cv_func_mmap_file" = "no"
then
  AC_MSG_WARN([mmap() of files required but not found])
fi
AC_CHECK_FUNCS(getcwd gettimeofday strdup strtoq strtoll backtrace isatty)
AC_CHECK_FUNCS(mkstemp getrusage)
AC_CHECK_FUNC(mprotect,,
  AC_MSG_ERROR([Function mprotect() required but not found]))

dnl Check for C++ extensions
AC_CXX_HAVE_HASH_MAP
AC_CXX_HAVE_HASH_SET
AC_CXX_HAVE_STD_ITERATOR
AC_CXX_HAVE_BI_ITERATOR
AC_CXX_HAVE_FWD_ITERATOR

dnl Determine if the linker supports the -R option.
AC_LINK_USE_R

dnl ===----------------------------------------------------------------------===
dnl --
dnl -- SECTION 9: Remaining LLVM specific configuration items
dnl --
dnl ===----------------------------------------------------------------------===

dnl Set up substitutions for compression libraries 
if test $zlib_found -eq 1 -a $zlib_h_found -eq 1; then
  AC_DEFINE([HAVE_ZLIB],[1],
    [Define if zlib library is available on this platform.])
  AC_SUBST([HAVE_ZLIB],[1])
else
  AC_SUBST([HAVE_ZLIB],[0])
fi
if test $bzip2_found -eq 1 -a $bzlib_h_found -eq 1 ; then
  AC_DEFINE([HAVE_BZIP2],[1],
    [Define if bzip2 library is available on this platform.])
  AC_SUBST([HAVE_BZIP2],[1])
else
  AC_SUBST([HAVE_BZIP2],[0])
fi

dnl Get libtool's idea of what the shared library suffix is.
dnl This is a hack; it relies on undocumented behavior.
AC_MSG_CHECKING([for shared library suffix])
eval "SHLIBEXT=$shrext_cmds"
AC_MSG_RESULT($SHLIBEXT)

dnl Propagate it to the Makefiles and config.h (for gccld & bugpoint).
AC_SUBST(SHLIBEXT,$SHLIBEXT)
AC_DEFINE_UNQUOTED(SHLIBEXT,"$SHLIBEXT",
  [Extension that shared libraries have, e.g., ".so".])

# Translate the various configuration directories and other basic
# information into substitutions that will end up in config.h.in so
# that these configured values can be hard-wired into a program.
eval LLVM_PREFIX="${prefix}";
eval LLVM_BINDIR="${prefix}/bin";
eval LLVM_LIBDIR="${prefix}/lib";
eval LLVM_DATADIR="${prefix}/data";
eval LLVM_DOCSDIR="${prefix}/docs";
eval LLVM_ETCDIR="${prefix}/etc";
eval LLVM_INCLUDEDIR="${prefix}/include";
eval LLVM_INFODIR="${prefix}/info";
eval LLVM_MANDIR="${prefix}/man";
LLVM_CONFIGTIME=`date`

AC_SUBST(LLVM_PREFIX)
AC_SUBST(LLVM_BINDIR)
AC_SUBST(LLVM_LIBDIR)
AC_SUBST(LLVM_DATADIR)
AC_SUBST(LLVM_DOCSDIR)
AC_SUBST(LLVM_ETCDIR)
AC_SUBST(LLVM_INCLUDEDIR)
AC_SUBST(LLVM_INFODIR)
AC_SUBST(LLVM_MANDIR)
AC_SUBST(LLVM_CONFIGTIME)

AC_DEFINE_UNQUOTED(LLVM_PREFIX,"$LLVM_PREFIX", 
  [Installation prefix directory])
AC_DEFINE_UNQUOTED(LLVM_BINDIR, "$LLVM_BINDIR", 
  [Installation directory for binary executables])
AC_DEFINE_UNQUOTED(LLVM_LIBDIR, "$LLVM_LIBDIR", 
  [Installation directory for libraries])
AC_DEFINE_UNQUOTED(LLVM_DATADIR, "$LLVM_DATADIR", 
  [Installation directory for data files])
AC_DEFINE_UNQUOTED(LLVM_DATADIR, "$LLVM_DOCSDIR", 
  [Installation directory for documentation])
AC_DEFINE_UNQUOTED(LLVM_ETCDIR, "$LLVM_ETCDIR", 
  [Installation directory for config files])
AC_DEFINE_UNQUOTED(LLVM_INCLUDEDIR, "$LLVM_INCLUDEDIR", 
  [Installation directory for include files])
AC_DEFINE_UNQUOTED(LLVM_INFODIR, "$LLVM_INFODIR", 
  [Installation directory for .info files])
AC_DEFINE_UNQUOTED(LLVM_MANDIR, "$LLVM_MANDIR", 
  [Installation directory for man pages])
AC_DEFINE_UNQUOTED(LLVM_CONFIGTIME, "$LLVM_CONFIGTIME", 
  [Time at which LLVM was configured])

dnl ===----------------------------------------------------------------------===
dnl -- SECTION 10: Define the output and put it out
dnl ===----------------------------------------------------------------------===

dnl Configure header files
AC_CONFIG_HEADERS([include/llvm/Config/config.h])
AC_CONFIG_HEADERS([include/llvm/Support/DataTypes.h])
AC_CONFIG_HEADERS([include/llvm/ADT/hash_map])
AC_CONFIG_HEADERS([include/llvm/ADT/hash_set])
AC_CONFIG_HEADERS([include/llvm/Support/ThreadSupport.h])
AC_CONFIG_HEADERS([include/llvm/ADT/iterator])

dnl Configure makefiles
AC_CONFIG_FILES([Makefile])
AC_CONFIG_FILES([lib/Makefile])
AC_CONFIG_FILES([lib/Analysis/IPA/Makefile])
AC_CONFIG_FILES([lib/Analysis/Makefile])
AC_CONFIG_FILES([lib/Analysis/DataStructure/Makefile])
AC_CONFIG_FILES([lib/AsmParser/Makefile])
AC_CONFIG_FILES([lib/System/Makefile])
AC_CONFIG_FILES([lib/Bytecode/Reader/Makefile])
AC_CONFIG_FILES([lib/Bytecode/Makefile])
AC_CONFIG_FILES([lib/Bytecode/Writer/Makefile])
AC_CONFIG_FILES([lib/Bytecode/Archive/Makefile])
AC_CONFIG_FILES([lib/CodeGen/InstrSched/Makefile])
AC_CONFIG_FILES([lib/CodeGen/Makefile])
AC_CONFIG_FILES([lib/CodeGen/ModuloScheduling/Makefile])
AC_CONFIG_FILES([lib/CodeGen/SelectionDAG/Makefile])
AC_CONFIG_FILES([lib/Debugger/Makefile])
AC_CONFIG_FILES([lib/ExecutionEngine/Interpreter/Makefile])
AC_CONFIG_FILES([lib/ExecutionEngine/Makefile])
AC_CONFIG_FILES([lib/ExecutionEngine/JIT/Makefile])
AC_CONFIG_FILES([lib/Support/Makefile])
AC_CONFIG_FILES([lib/Target/CBackend/Makefile])
AC_CONFIG_FILES([lib/Target/Makefile])
AC_CONFIG_FILES([lib/Target/Skeleton/Makefile])
AC_CONFIG_FILES([lib/Target/PowerPC/Makefile])
AC_CONFIG_FILES([lib/Target/SparcV9/Makefile])
AC_CONFIG_FILES([lib/Target/SparcV9/LiveVar/Makefile])
AC_CONFIG_FILES([lib/Target/SparcV9/RegAlloc/Makefile])
AC_CONFIG_FILES([lib/Target/X86/Makefile])
AC_CONFIG_FILES([lib/Transforms/Hello/Makefile])
AC_CONFIG_FILES([lib/Transforms/Makefile])
AC_CONFIG_FILES([lib/Transforms/IPO/Makefile])
AC_CONFIG_FILES([lib/Transforms/Instrumentation/ProfilePaths/Makefile])
AC_CONFIG_FILES([lib/Transforms/Instrumentation/Makefile])
AC_CONFIG_FILES([lib/Transforms/Scalar/Makefile])
AC_CONFIG_FILES([lib/Transforms/Utils/Makefile])
AC_CONFIG_FILES([lib/VMCore/Makefile])
AC_CONFIG_FILES([utils/Makefile])
AC_CONFIG_FILES([utils/Burg/Makefile])
AC_CONFIG_FILES([utils/fpcmp/Makefile])
AC_CONFIG_FILES([utils/TableGen/Makefile])
AC_CONFIG_FILES([tools/Makefile])
AC_CONFIG_FILES([tools/analyze/Makefile])
AC_CONFIG_FILES([tools/llvmc/Makefile])
AC_CONFIG_FILES([tools/bugpoint/Makefile])
AC_CONFIG_FILES([tools/extract/Makefile])
AC_CONFIG_FILES([tools/gccas/Makefile])
AC_CONFIG_FILES([tools/gccld/Makefile])
AC_CONFIG_FILES([tools/llvm-bcanalyzer/Makefile])
AC_CONFIG_FILES([tools/llc/Makefile])
AC_CONFIG_FILES([tools/llee/Makefile])
AC_CONFIG_FILES([tools/lli/Makefile])
AC_CONFIG_FILES([tools/llvm-ar/Makefile])
AC_CONFIG_FILES([tools/llvm-as/Makefile])
AC_CONFIG_FILES([tools/llvm-db/Makefile])
AC_CONFIG_FILES([tools/llvm-dis/Makefile])
AC_CONFIG_FILES([tools/llvm-link/Makefile])
AC_CONFIG_FILES([tools/llvm-nm/Makefile])
AC_CONFIG_FILES([tools/llvm-prof/Makefile])
AC_CONFIG_FILES([tools/opt/Makefile])
AC_CONFIG_FILES([tools/llvm-ld/Makefile])
AC_CONFIG_FILES([tools/llvm-stub/Makefile])

dnl Make a link from lib/System/platform to lib/System/$llvm_platform_type
dnl This helps the #inclusion of the system specific include files
dnl for the operating system abstraction library
AC_CONFIG_LINKS(lib/System/platform:lib/System/$llvm_platform_type)

dnl Configure all of the projects present in our source tree.
for i in `ls ${srcdir}/projects`
do
  if test -d ${srcdir}/projects/${i} ; then
    case ${i} in
      "CVS") ;;
      "sample")       AC_CONFIG_SUBDIRS([projects/sample])    ;;
      "Stacker")      AC_CONFIG_SUBDIRS([projects/Stacker])   ;;
      "llvm-test")    AC_CONFIG_SUBDIRS([projects/llvm-test]) ;;
      "llvm-reopt")   AC_CONFIG_SUBDIRS([projects/llvm-reopt]);;
      "llvm-gcc")     AC_CONFIG_SUBDIRS([projects/llvm-gcc])  ;;
      "Java")         AC_CONFIG_SUBDIRS([projects/Java])      ;;
      "llvm-tv")      AC_CONFIG_SUBDIRS([projects/llvm-tv])   ;;
      "llvm-fefw")    AC_CONFIG_SUBDIRS([projects/llvm-fefw]) ;;
      *)              
        AC_MSG_WARN([Unknown project (${i}) won't be configured automatically])
        ;;
    esac
  fi
done
dnl Create the output files
AC_OUTPUT

dnl ===----------------------------------------------------------------------===
dnl -- SECTION 11: Output warnings to user (always last so they see it)
dnl ===----------------------------------------------------------------------===

dnl Warn if we don't have a compression library
if test $bzip2_found -ne 1 ; then
  if test $zlib_found -ne 1 ; then
    AC_MSG_WARN([*** Neither zlib nor bzip2 compression libraries were found.])
    AC_MSG_WARN([*** Bytecode archives will not support compression!])
    AC_MSG_WARN([*** To correct, install the libraries and re-run configure.])
  fi
fi

dnl Warn loudly if llvm-gcc was not obviously working
if test $llvmgccwarn = yes
then
  AC_MSG_WARN([***** llvm C/C++ front end was not found, or does not])
  AC_MSG_WARN([***** appear to be working.])
  AC_MSG_WARN([***** ])
  AC_MSG_WARN([***** Please check configure's --with-llvmgccdir option.])
  AC_MSG_WARN([***** Runtime libraries (in llvm/runtime) will not be built,])
  AC_MSG_WARN([***** but you should be able to build the llvm tools.])
fi