configure.ac

##                            -*- Autoconf -*-
## --------------------------------------------------------------------------
##
##   Copyright 2014
##   Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V.
##   All Rights Reserved Worldwide
##
##   Licensed under the Apache License, Version 2.0 (the "License");
##   you may not use this file except in compliance with the License.
##   You may obtain a copy of the License at
##
##       http://www.apache.org/licenses/LICENSE-2.0
##
##   Unless required by applicable law or agreed to in writing, software
##   distributed under the License is distributed on an "AS IS" BASIS,
##   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
##   See the License for the specific language governing permissions and
##   limitations under the License.
##
## --------------------------------------------------------------------------
##
##   configure.ac --
##   Process this file with autoconf to produce a configure script.
##
##   Original Author: Thomas Uhle, Fraunhofer IIS / EAS Dresden
##   Created on: 2014-03-10
##
## --------------------------------------------------------------------------
##
##   SVN Version       :  $Revision: 2333 $
##   SVN last checkin  :  $Date: 2023-06-15 11:43:16 +0000 (Thu, 15 Jun 2023) $
##   SVN checkin by    :  $Author: pehrlich $
##   SVN Id            :  $Id: configure.ac 2333 2023-06-15 11:43:16Z pehrlich $
##
## ---------------------------------------------------------------------------
 
AC_PREREQ(2.61)

AC_INIT([SystemC AMS],
        [2.3.4],
        [https://www.coseda-tech.com],
        [systemc-ams],
        [https://www.coseda-tech.com],
)

AC_CONFIG_AUX_DIR([config])
AC_CONFIG_MACRO_DIR([config])
AC_CONFIG_SRCDIR([src/systemc-ams.h])
AC_CONFIG_HEADERS([src/config.h])

AC_DEFINE_UNQUOTED(CONFIGURE_DATE, "`sh -c date`", [Date of configure])
AC_SUBST(CONFIGURE_DATE)

REVISION="\$Revision: 2333 $"
AC_REVISION($Revision: 2333 $)
AC_DEFINE_UNQUOTED(REVISION, "$REVISION", [SVN Revision])
AC_SUBST(REVISION)

AC_CANONICAL_SYSTEM
AM_INIT_AUTOMAKE([1.9.4 tar-pax -Werror -Wno-portability no-define subdir-objects])
m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES(yes)])

# ignore GNU defaults for CFLAGS and CXXFLAGS
: ${CFLAGS=""}
: ${CXXFLAGS=""}

AC_PROG_CC
AC_PROG_CXX
AC_PROG_INSTALL
AC_PROG_LN_S


# figure out architecture dependent variables

CXX_COMP=`set $CXX; basename $1`
CC_COMP=`set $CC; basename $1`

EXTRA_CXXFLAGS="-Wall -pedantic -Wno-long-long"
DEBUG_CXXFLAGS="-g -DDEBUG"
DEBUG_LDFLAGS="-g"
OPT_CXXFLAGS="-O3"
LDFLAG_RPATH="-Wl,-rpath="

case "$depmode" in
    gcc3)
        EXTRA_CXXFLAGS="${EXTRA_CXXFLAGS} -fmessage-length=0"
        ;;
    *)
        ;;
esac


case "$target" in
    *-apple-*)
        case "$target_cpu" in
            x86_64)
                TARGET_ARCH="macosx64"
                CPU_ARCH="x86_64"
                ;;
            x386 | i386)
                TARGET_ARCH="macosx"
                CPU_ARCH="i386"
                ;;
            powerpc)
                TARGET_ARCH="macosxppc"
                CPU_ARCH="ppc"
                ;;
            powerpc64)
                TARGET_ARCH="macosxppc64"
                CPU_ARCH="ppc64"
                ;;
            *)
                AC_MSG_ERROR("sorry... architecture not supported.")
                ;;
        esac
        if test "$GXX" = "yes"; then
                EXTRA_CXXFLAGS="${EXTRA_CXXFLAGS} -arch ${CPU_ARCH}"
                LDFLAG_RPATH="-Wl,-rpath -Wl,"
        else
                AC_MSG_ERROR("sorry... compiler not supported.")
        fi
        ;;
    sparc-sun-solaris*)
        if test "$GXX" = "yes"; then
                TARGET_ARCH="gccsparcOS5"
                LDFLAG_RPATH="-Wl,-R"
        else
            if test "$CXX_COMP" = "CC"; then
                EXTRA_CXXFLAGS=""
                OPT_CXXFLAGS="-fast -xO4 -xnolibmil -mc"
                TARGET_ARCH="sparcOS5"
                LDFLAG_RPATH="-Wl,-R"
            else
                AC_MSG_ERROR("sorry... compiler not supported.")
            fi
        fi
        ;;
    *linux*)
        case "$target_cpu" in
            x86_64 | amd64)
                TARGET_ARCH="linux64"
                CPU_ARCH=64
                ;;
            i*86)
                TARGET_ARCH="linux"
                CPU_ARCH=32
                ;;
            *)
                AC_MSG_ERROR("sorry... architecture not supported.")
            ;;
        esac
        if test "$GXX" = "yes"; then
                EXTRA_CXXFLAGS="${EXTRA_CXXFLAGS} -m${CPU_ARCH}"
        else
                AC_MSG_ERROR("sorry... compiler not supported.")
        fi
        ;;
    *freebsd* | dragonfly* | *netbsd* | openbsd*)
        case "$target_cpu" in
            x86_64 | amd64)
                TARGET_ARCH="bsd64"
                CPU_ARCH=64
                ;;
            i*86)
                TARGET_ARCH="bsd"
                CPU_ARCH=32
                ;;
            *)
                AC_MSG_ERROR("sorry... architecture not supported.")
            ;;
        esac
        if test "$GXX" = "yes"; then
                EXTRA_CXXFLAGS="${EXTRA_CXXFLAGS} -m${CPU_ARCH}"
        else
                AC_MSG_ERROR("sorry... compiler not supported.")
        fi
        ;;
    *cygwin*)
        case "$target_cpu" in
            x86_64 | amd64)
                TARGET_ARCH="cygwin64"
                CPU_ARCH=64
                ;;
            i*86)
                TARGET_ARCH="cygwin"
                CPU_ARCH=32
                ;;
            *)
                AC_MSG_ERROR("sorry... architecture not supported.")
            ;;
        esac
        if test "$GXX" = "yes"; then
                EXTRA_CXXFLAGS="${EXTRA_CXXFLAGS} -m${CPU_ARCH}"
        else
                AC_MSG_ERROR("sorry... compiler not supported.")
        fi
        ;;
    *mingw*)
        case "$target_cpu" in
            x86_64 | amd64)
                TARGET_ARCH="mingw-w64"
                CPU_ARCH=64
                ;;
            i*86)
                TARGET_ARCH="mingw"
                CPU_ARCH=32
                ;;
            *)
                AC_MSG_ERROR("sorry... architecture not supported.")
            ;;
        esac
        if test "$GXX" = "yes"; then
                EXTRA_CXXFLAGS="${EXTRA_CXXFLAGS} -m${CPU_ARCH}"
        else
                AC_MSG_ERROR("sorry... compiler not supported.")
        fi
        ;;
esac

AC_SUBST(LDFLAG_RPATH)
AC_SUBST(TARGET_ARCH)


# append additional flags to configure script

AC_MSG_CHECKING(whether to include debug symbols)
AC_ARG_ENABLE([debug],
  AS_HELP_STRING([--enable-debug],
                 [include debug symbols]),
  [case "$enableval" in
    "no" | "yes")  enable_debug=$enableval;;
    *)             AC_MSG_ERROR(bad value "$enableval" for --enable-debug);;
  esac],
  [enable_debug="not defined"])
AC_MSG_RESULT($enable_debug)


AC_MSG_CHECKING(whether to enable code profiling)
AC_ARG_ENABLE([profiling],
  [AS_HELP_STRING([--enable-profiling@<:@=PROGRAM@:>@],
                  [generate instrumentation calls for code
                   profiling, supported profilers: prof,
                   gprof, instrument (-finstrument-functions)
                   @<:@default=no@:>@])],
  [case "$enableval" in
    "no" | "prof" | "gprof" | "instrument")  enable_profiling=$enableval;;
    "yes")  AC_MSG_ERROR(no profiler defined with --enable-profiling);;
    *)      AC_MSG_ERROR(bad value "$enableval" for --enable-profiling);;
  esac],
  [enable_profiling="no"]
)
AC_MSG_RESULT($enable_profiling)

if test "$enable_profiling" = "no"; then
  if test "$enable_debug" = "not defined"; then
    enable_debug="no"
  fi
else
  case "$enable_debug" in
    "not defined")  enable_debug="yes";;
    "no")           AC_MSG_ERROR(contradicting options: 
           Cannot have --disable-debug with --enable-profiling.
           Please re-run configure with only one of these options 
           at the same time.);;
  esac
  case "$enable_profiling" in
    "prof")        DEBUG_CXXFLAGS="${DEBUG_CXXFLAGS} -p";
                   DEBUG_LDFLAGS="${DEBUG_LDFLAGS} -p";;
    "gprof")       DEBUG_CXXFLAGS="${DEBUG_CXXFLAGS} -pg";
                   DEBUG_LDFLAGS="${DEBUG_LDFLAGS} -pg";;
    "instrument")  DEBUG_CXXFLAGS="${DEBUG_CXXFLAGS} -finstrument-functions";;
  esac
fi
AM_CONDITIONAL([WANT_DEBUG], [test "$enable_debug" = "yes"])


AC_MSG_CHECKING(whether to enable compiler optimizations deprecated)
AC_ARG_ENABLE([optimized],
  AS_HELP_STRING([--disable-optimized],
                 [disable compiler optimizations]),
  [case "$enableval" in
    "no" | "yes")  enable_optimized=$enableval;;
    *)             AC_MSG_ERROR(bad value "$enableval" for --enable-optimized);;
  esac],
  [enable_optimized="yes"])
AC_MSG_RESULT($enable_optimized)
#AM_CONDITIONAL([WANT_OPTIMIZE], [test "$enable_optimized" = "yes"])

AC_MSG_CHECKING(whether to enable compiler optimizations)
AC_ARG_ENABLE([optimize],
  AS_HELP_STRING([--disable-optimize],
                 [disable compiler optimizations]),
  [case "$enableval" in
    "no" | "yes")  enable_optimize=$enableval;;
    *)             AC_MSG_ERROR(bad value "$enableval" for --enable-optimize);;
  esac],
  [enable_optimize="yes"])
AC_MSG_RESULT($enable_optimize)
AM_CONDITIONAL([WANT_OPTIMIZE], [test "$enable_optimize" = "yes" && test "$enable_optimized" = "yes"])

AC_MSG_CHECKING(whether to enable parallel tracing)
AC_ARG_ENABLE([parallel_tracing],
  AS_HELP_STRING([--enable-parallel_tracing],
                 [enable parallel tracing and thus add a pthread dependency]),
  [case "$enableval" in
    "no" | "yes")  enable_parallel_tracing=$enableval;;
    *)             AC_MSG_ERROR(bad value "$enableval" for --enable-parallel_tracing);;
  esac],
  [enable_parallel_tracing="no"])
AC_MSG_RESULT($enable_parallel_tracing)
AM_CONDITIONAL([WANT_PARALLEL_TRACING], [test "$enable_parallel_tracing" = "yes"])


if test "$enable_parallel_tracing" = "no"; then
    EXTRA_CXXFLAGS="${EXTRA_CXXFLAGS} -DDISABLE_PARALLEL_TRACING";
fi


AC_MSG_CHECKING(whether to disable reference node clustering)
AC_ARG_ENABLE([reference_node_clustering],
  AS_HELP_STRING([--disable-reference_node_clustering],
                 [disables clustering for refrence nodes - reference nodes ignored for clustering]),
  [case "$enableval" in
    "no" | "yes")  enable_reference_node_clustering=$enableval;;
    *)             AC_MSG_ERROR(bad value "$enableval" for --disable-reference_node_clustering);;
  esac],
  [enable_reference_node_clustering="yes"])
AC_MSG_RESULT($enable_reference_node_clustering)
AM_CONDITIONAL([WANT_REFERENCE_NODE_CLUSTERING], [test "$enable_reference_node_clustering" = "yes"])


if test "$enable_reference_node_clustering" = "no"; then
    EXTRA_CXXFLAGS="${EXTRA_CXXFLAGS} -DDISABLE_REFERENCE_NODE_CLUSTERING";
fi


AC_MSG_CHECKING(whether to disable performance data collection)
AC_ARG_ENABLE([performance_statistics],
  AS_HELP_STRING([--disable-performance_statistics],
                 [disables performance data collection and removes dependency from high precision counter and chrono]),
  [case "$enableval" in
    "no" | "yes")  enable_performance_statistics=$enableval;;
    *)             AC_MSG_ERROR(bad value "$enableval" for --enable-performance_statistics);;
  esac],
  [enable_performance_statistics="yes"])
AC_MSG_RESULT($enable_performance_statistics)
AM_CONDITIONAL([WANT_PERFORMACE_STATISTICS], [test "$enable_performance_statistics" = "yes"])


if test "$enable_performance_statistics" = "no"; then
    EXTRA_CXXFLAGS="${EXTRA_CXXFLAGS} -DDISABLE_PERFORMANCE_STATISTICS";
fi




AC_SUBST(EXTRA_CXXFLAGS)
AC_SUBST(DEBUG_CXXFLAGS)
AC_SUBST(DEBUG_LDFLAGS)
AC_SUBST(OPT_CXXFLAGS)


AC_MSG_CHECKING(how installed files will be laid out)
AC_ARG_WITH([layout],
  [AS_HELP_STRING([--with-layout@<:@=TYPE@:>@],
                  [sets how installed files will be laid out,
                   possible directory layouts: systemc, unix
                   @<:@default=systemc@:>@])],
  [case "$withval" in
    "systemc")  want_install_layout="SystemC";;
    "unix")     want_install_layout="UNIX";;
    *)          want_install_layout="$withval";;
  esac],
  [want_install_layout="SystemC"]
)

abs_builddir=`pwd`
abs_srcdir=`cd "$srcdir"; pwd`

# set default prefix: $srcdir
# preset SystemC directory layout if installing to $srcdir
if test "$prefix" = "NONE"; then
  prefix="$abs_srcdir"
  want_install_layout="SystemC"
fi
AC_MSG_RESULT($want_install_layout)

# strip trailing slash unless $prefix="/"
if test "$prefix" != "/"; then
  prefix=`echo "$prefix" | $AWK '{sub(/\/$/, "")};1'`
fi

if test "$abs_srcdir" != "$abs_builddir"; then
  if test "$prefix" = "$abs_builddir"; then
    AC_MSG_ERROR(Installation to build directory not supported.)
  fi
fi

case "$want_install_layout" in
  "SystemC")
    if test "$datarootdir" = '${prefix}/share'; then
      datarootdir="$prefix"
    fi
    if test "$docdir" = '${datarootdir}/doc/${PACKAGE_TARNAME}'; then
      docdir="$prefix/docs"
      rootdocdir="$prefix"
    else
      rootdocdir="$docdir"
    fi
    have_arch_suffix="default";
    LIB_ARCH_SUFFIX="-${TARGET_ARCH}"
    ;;
  "UNIX")
    # keep Automake/GNU/UNIX defaults
    rootdocdir="$docdir"
    have_arch_suffix="ignored";
    LIB_ARCH_SUFFIX=""
    ;;
  *)
    AC_MSG_ERROR(Unknown directory layout requested.)
    ;;
esac


AC_MSG_CHECKING([for SystemC library arch suffix])
AC_ARG_WITH([arch-suffix],
  [AS_HELP_STRING([--with-arch-suffix@<:@=SUFFIX@:>@],
                  [append SUFFIX to library installation directory
                   @<:@default=-$TARGET_ARCH@:>@])],
  [case "$withval" in
     "no" | "")  have_arch_suffix="no";  LIB_ARCH_SUFFIX="";;
     "yes")      have_arch_suffix="yes"; LIB_ARCH_SUFFIX="-${TARGET_ARCH}";;
     *)          have_arch_suffix="yes"; LIB_ARCH_SUFFIX="$withval";;
  esac],
  [ac_dummy=""]
)
AC_MSG_RESULT($have_arch_suffix (TARGET_ARCH=${TARGET_ARCH}))
AC_SUBST(LIB_ARCH_SUFFIX)
AC_SUBST(rootdocdir)
libdir="${libdir}${LIB_ARCH_SUFFIX}"


AC_ARG_WITH([systemc],
  [AS_HELP_STRING([--with-systemc=DIR],
                  [define path to Accellera SystemC library home])],
  [case "$withval" in
    "no")   have_systemc="no";    systemc_home="";;
    "yes")  have_systemc="yes";   systemc_home="";;
    "")     have_systemc="maybe"; systemc_home="";;
    *)      have_systemc="yes";   systemc_home="$withval";;
  esac],
  [have_systemc="maybe"; systemc_home=""]
)

PKG_CHECK_MODULES(SYSTEMC, [systemc >= 2.2.0],
  [have_systemc="yes"],
  [if test -z "$systemc_home"; then
    AC_MSG_CHECKING(for SystemC library home)
    if test -d "${SYSTEMC_HOME}"; then
      builddir=`pwd`;
      systemc_home=`cd ${SYSTEMC_HOME}; pwd`
      AC_MSG_RESULT(found in \$SYSTEMC_HOME)
    elif test -d "`pwd`/systemc-2.3.1"; then
      builddir=`pwd`;
      systemc_home=`cd $builddir/systemc-2.3.1; pwd`
    elif test -d "`pwd`/systemc-2.3.0"; then
      builddir=`pwd`;
      systemc_home=`cd $builddir/systemc-2.3.0; pwd`
    elif test -d "`pwd`/systemc-2.2.0"; then
      builddir=`pwd`;
      systemc_home=`cd $builddir/systemc-2.2.0; pwd`
    elif test -d "`pwd`/../systemc-2.3.1"; then
      builddir=`pwd`;
      systemc_home=`cd $builddir/../systemc-2.3.1; pwd`
    elif test -d "`pwd`/../systemc-2.3.0"; then
      builddir=`pwd`;
      systemc_home=`cd $builddir/../systemc-2.3.0; pwd`
    elif test -d "`pwd`/../systemc-2.2.0"; then
      builddir=`pwd`;
      systemc_home=`cd $builddir/../systemc-2.2.0; pwd`
    fi
    if test -z "$systemc_home"; then
      have_systemc="no"
      AC_MSG_RESULT(not found)
      AC_MSG_ERROR(SystemC library home not found.
           Specify --with-systemc=/path/to/systemc_home pointing to the installed location.)
    else
      have_systemc="yes"
      AC_MSG_RESULT($systemc_home)
    fi
  fi
  if test "$have_systemc" = "yes"; then
    if test -d "$systemc_home"; then
      systemc_home=`cd $systemc_home; pwd`;
    else
      AC_MSG_ERROR(SystemC library home $systemc_home does not exist.
           SystemC might not have been installed correctly.)
    fi
    SYSTEMC_INC_PREFIX="$systemc_home/include"
    SYSTEMC_LIB_PREFIX="$systemc_home/lib${LIB_ARCH_SUFFIX}"
    AC_MSG_CHECKING(for $SYSTEMC_INC_PREFIX/systemc.h)
    if test -r "$SYSTEMC_INC_PREFIX/systemc.h"; then
      AC_MSG_RESULT(yes)
      SYSTEMC_CFLAGS="-I$SYSTEMC_INC_PREFIX"
      SYSTEMC_LIBS="-L$SYSTEMC_LIB_PREFIX -lsystemc"
    else
      AC_MSG_RESULT(no)
      AC_MSG_ERROR(SystemC header files missing.
           SystemC might not have been installed correctly.)
    fi
  fi]
)


# Libtool initialisation (always AFTER all the CC options have been set)
# * explicitly use C++ for libtool initialization since we are always
#   compiling C++ sources
AC_LANG([C++])
# * need to pass EXTRA_CXXFLAGS to Libtool via CXXFLAGS to correctly
#   detect C++ library dependencies, esp. for cross-compilation
stored_CXXFLAGS="${CXXFLAGS}"
CXXFLAGS="${EXTRA_CXXFLAGS} ${CXXFLAGS}"
AC_PROG_LIBTOOL
# * restore CXXFLAGS
CXXFLAGS="${stored_CXXFLAGS}"

#check SystemC Version by building an example program
AC_ARG_ENABLE([systemc_compile_check],
    AS_HELP_STRING([--disable-systemc_compile_check], [Disable SystemC compile option check, which tests that SystemC AMS is configured with compatible compile options]))

AS_IF([test "x$enable_systemc_compile_check" != "xno"], [
  stored_CXXFLAGS="${CXXFLAGS}"
  stored_LIBS="${LIBS}"
  CXXFLAGS="${SYSTEMC_CFLAGS} ${CXXFLAGS}"
  LIBS="${LIBS} ${SYSTEMC_LIBS}"
  AC_MSG_CHECKING( whether SystemC executable can be built)
  AC_RUN_IFELSE( 
      [AC_LANG_SOURCE([[#include <systemc>
      int sc_main(int argc, char* argv[]) {
      return 0;
      }
      ]])]
      ,  
      [AC_MSG_RESULT([SystemC executable successfully built])],
      [AC_MSG_FAILURE([SystemC executable cannot be built. Used CXXFLAGS: ${CXXFLAGS} Used LIBS: ${LIBS} . This check can be disabled with --disable-systemc_compile_check])]
      )
  CXXFLAGS="${stored_CXXFLAGS}"
  LIBS="${stored_LIBS}"
])




AC_OUTPUT( Makefile
           src/Makefile
           src/scams/Makefile
           src/scams/systemc-ams.pc
           src/scams/analysis/Makefile
           src/scams/analysis/ac/Makefile
           src/scams/core/Makefile
           src/scams/impl/Makefile
           src/scams/impl/analysis/Makefile
           src/scams/impl/analysis/ac/Makefile
           src/scams/impl/core/Makefile
           src/scams/impl/predefined_moc/Makefile
           src/scams/impl/predefined_moc/conservative/Makefile
           src/scams/impl/predefined_moc/eln/Makefile
           src/scams/impl/predefined_moc/lsf/Makefile
           src/scams/impl/predefined_moc/tdf/Makefile
           src/scams/impl/solver/Makefile
           src/scams/impl/solver/linear/Makefile
           src/scams/impl/solver/tdf/Makefile
           src/scams/impl/solver/user_solver/Makefile
           src/scams/impl/solver/util/Makefile
           src/scams/impl/solver/util/sparse_library/Makefile
           src/scams/impl/synchronization/Makefile
           src/scams/impl/util/Makefile
           src/scams/impl/util/data_types/Makefile
           src/scams/impl/util/reporting/Makefile
           src/scams/impl/util/tracing/Makefile
           src/scams/predefined_moc/Makefile
           src/scams/predefined_moc/eln/Makefile
           src/scams/predefined_moc/lsf/Makefile
           src/scams/predefined_moc/tdf/Makefile
           src/scams/utility/Makefile
           src/scams/utility/data_types/Makefile
           src/scams/utility/reporting/Makefile
           src/scams/utility/tracing/Makefile
           docs/Makefile )

# resolve path variables
SYSTEMC_AMS_HOME=$prefix
eval "install_prefix=\"${SYSTEMC_AMS_HOME}\""
eval "install_includedir=\"${includedir}\""
eval "install_includedir=\"${install_includedir}\""
eval "install_libdir=\"${libdir}\""
eval "install_libdir=\"${install_libdir}\""
eval "install_docdir=\"${docdir}\""
eval "install_docdir=\"${install_docdir}\""
prefix=$SYSTEMC_AMS_HOME

cat <<EOF | tee -a config.log

------------------------------------------------------------------------------
Configuration summary of $PACKAGE_STRING for $target
------------------------------------------------------------------------------

 Directory setup (based on $want_install_layout layout):
   Installation prefix: ${install_prefix}
   Header files:        ${install_includedir}
   Libraries:           ${install_libdir}
   Documentation:       ${install_docdir}

 Target architecture:   ${TARGET_ARCH}

 Build settings:
   Compiler (flags):    ${CXX}
                        ${CXXFLAGS}
                        ${EXTRA_CXXFLAGS}
   Optimization flags:  ${OPT_CXXFLAGS}
   Debug flags:         ${DEBUG_CXXFLAGS}
   Preprocessor flags:  ${CPPFLAGS}
   SystemC CFLAGS:      ${SYSTEMC_CFLAGS}
   SystemC LIBS:        ${SYSTEMC_LIBS}
   Additional LIBS:     ${LIBS}
   Enable compiler optimizations (deprecated): 
   --enable_optimized                          $enable_optimized
   Enable compiler optimizations:              
   --enable_optimize                           $enable_optimize
   Include debug symbols:                      $enable_debug
   Generate instrumentation calls:             $enable_profiling
   Enable parallel tracing:                    $enable_parallel_tracing
   Enable reference node clustering:           $enable_reference_node_clustering
   Enable performance statistics:              $enable_performance_statistics
   
------------------------------------------------------------------------------
EOF


## Taf!