mirror of https://github.com/ademakov/libjit
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
438 lines
13 KiB
438 lines
13 KiB
dnl Process this file with autoconf to produce a configure script.
|
|
AC_INIT(include/jit/jit.h)
|
|
|
|
dnl Determine the build, host, and target system types.
|
|
AC_CANONICAL_SYSTEM
|
|
|
|
dnl Initialize automake.
|
|
AM_INIT_AUTOMAKE(libjit, 0.0.5)
|
|
AM_CONFIG_HEADER(config.h)
|
|
|
|
dnl Set the version number for the shared libraries.
|
|
AC_SUBST(LIBJIT_VERSION)
|
|
LIBJIT_VERSION=0:0:0
|
|
|
|
dnl Turn off the cygwin library if building for Win32.
|
|
dnl Note: We have to include <stdlib.h> if we will be using "__int64"
|
|
dnl because otherwise the mingw32 compiler won't define it correctly.
|
|
AC_MSG_CHECKING([if building for some Win32 platform])
|
|
AC_SUBST(JIT_INT64_INCLUDE)
|
|
case "$host" in
|
|
*-*-cygwin*)
|
|
platform_win32=yes
|
|
if test "x$CC" = "x" ; then
|
|
CC="gcc -mno-cygwin"
|
|
fi
|
|
if test "x$CXX" = "x" ; then
|
|
if test "x$CC" = "xcl" ; then
|
|
CXX="cl"
|
|
else
|
|
CXX="g++ -mno-cygwin"
|
|
fi
|
|
fi
|
|
suppress_libm=yes
|
|
JIT_INT64_INCLUDE='#include <stdlib.h>'
|
|
;;
|
|
*-*-mingw*)
|
|
platform_win32=yes
|
|
if test "x$CC" = "xcl" ; then
|
|
if test "x$CXX" = "x" ; then
|
|
CXX="cl"
|
|
fi
|
|
fi
|
|
suppress_libm=yes
|
|
JIT_INT64_INCLUDE='#include <stdlib.h>'
|
|
;;
|
|
*)
|
|
platform_win32=no
|
|
suppress_libm=no
|
|
JIT_INT64_INCLUDE=
|
|
;;
|
|
esac
|
|
AC_MSG_RESULT($platform_win32)
|
|
|
|
dnl The "--enable-interpreter" option forces the use of the interpreter.
|
|
AC_ARG_ENABLE(interpreter,
|
|
[ --enable-interpreter Enable the libjit interpreter],
|
|
[case "${enableval}" in
|
|
yes) interp=true ;;
|
|
no) interp=false ;;
|
|
*) AC_MSG_ERROR(bad value ${enableval} for --enable-interpreter) ;;
|
|
esac],[interp=false])
|
|
if test x$interp = xtrue; then
|
|
AC_DEFINE(USE_LIBJIT_INTERPRETER, 1, [Define if you want to use the libjit interpreter])
|
|
fi
|
|
|
|
dnl Checks for programs.
|
|
AC_PROG_AWK
|
|
AC_PROG_CC
|
|
AC_PROG_CXX
|
|
AC_PROG_INSTALL
|
|
AC_PROG_LN_S
|
|
AC_PROG_MAKE_SET
|
|
AC_PROG_YACC
|
|
AM_PROG_LEX
|
|
AC_LIBTOOL_WIN32_DLL
|
|
AM_PROG_LIBTOOL
|
|
|
|
dnl Set the correct flags for compiling with MSVC. "/QIfist" is needed
|
|
dnl on systems with both VC 6.0 and VC 7.0 installed: sometimes VC 7.0
|
|
dnl picks up the wrong intrinsic libraries (particularly for __ftol2).
|
|
dnl The "/EHs" option is required to enable exception handling in C++.
|
|
if test "x$CC" = "xcl" ; then
|
|
CFLAGS="/nologo /QIfist"
|
|
CXXFLAGS="/nologo /QIfist /EHs"
|
|
fi
|
|
|
|
dnl Check for file extensions.
|
|
AC_EXEEXT
|
|
AC_OBJEXT
|
|
|
|
dnl Checks for header files.
|
|
AC_HEADER_STDC
|
|
AC_CHECK_HEADERS(string.h strings.h memory.h stdlib.h stdarg.h varargs.h)
|
|
AC_CHECK_HEADERS(tgmath.h math.h ieeefp.h pthread.h unistd.h sys/types.h)
|
|
AC_CHECK_HEADERS(sys/mman.h fcntl.h dlfcn.h sys/cygwin.h sys/stat.h)
|
|
AC_CHECK_HEADERS(time.h sys/time.h)
|
|
|
|
dnl A macro that helps detect the size of types in a cross-compile environment.
|
|
AC_DEFUN([AC_COMPILE_CHECK_SIZEOF],
|
|
[changequote(<<, >>)dnl
|
|
dnl The name to #define.
|
|
define(<<AC_TYPE_NAME>>, translit(sizeof_$1, [a-z *], [A-Z_P]))dnl
|
|
dnl The cache variable name.
|
|
define(<<AC_CV_NAME>>, translit(ac_cv_sizeof_$1, [ *], [_p]))dnl
|
|
changequote([, ])dnl
|
|
AC_MSG_CHECKING(size of $1)
|
|
AC_CACHE_VAL(AC_CV_NAME,
|
|
[for ac_size in 4 8 1 2 12 16 $2 ; do # List sizes in rough order of prevalence.
|
|
AC_TRY_COMPILE([#include "confdefs.h"
|
|
#include <sys/types.h>
|
|
], [switch (0) case 0: case (sizeof ($1) == $ac_size):;], AC_CV_NAME=$ac_size)
|
|
if test x$AC_CV_NAME != x ; then break; fi
|
|
done
|
|
])
|
|
if test x$AC_CV_NAME = x ; then
|
|
AC_CV_NAME=0
|
|
fi
|
|
AC_MSG_RESULT($AC_CV_NAME)
|
|
AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME, [The number of bytes in type $1])
|
|
undefine([AC_TYPE_NAME])dnl
|
|
undefine([AC_CV_NAME])dnl
|
|
])
|
|
|
|
dnl A macro that detects if "char" is unsigned in a cross-compile environment.
|
|
AC_DEFUN([AC_COMPILE_CHAR_UNSIGNED],
|
|
[AC_MSG_CHECKING(if char is unsigned)
|
|
AC_CACHE_VAL(ac_cv_c_char_unsigned,
|
|
AC_TRY_COMPILE([#include "confdefs.h"
|
|
], [switch (-1) case -1: case (char)255:;], ac_cv_c_char_unsigned=yes))
|
|
if test x$ac_cv_c_char_unsigned = x ; then
|
|
ac_cv_c_char_unsigned=no
|
|
fi
|
|
AC_MSG_RESULT($ac_cv_c_char_unsigned)
|
|
if test $ac_cv_c_char_unsigned = yes && test "$GCC" != yes; then
|
|
AC_DEFINE(__CHAR_UNSIGNED__, 1, [Define to 1 if "char" is unsigned])
|
|
fi
|
|
])
|
|
|
|
dnl Checks for typedefs, structures, and compiler characteristics.
|
|
AC_C_CONST
|
|
AC_COMPILE_CHAR_UNSIGNED
|
|
AC_COMPILE_CHECK_SIZEOF(char, 1)
|
|
AC_COMPILE_CHECK_SIZEOF(short, 2)
|
|
AC_COMPILE_CHECK_SIZEOF(int, 4)
|
|
AC_COMPILE_CHECK_SIZEOF(long, 4)
|
|
AC_COMPILE_CHECK_SIZEOF(long long, 8)
|
|
AC_COMPILE_CHECK_SIZEOF(__int64, 8)
|
|
AC_COMPILE_CHECK_SIZEOF(float, 4)
|
|
AC_COMPILE_CHECK_SIZEOF(double, 8)
|
|
AC_COMPILE_CHECK_SIZEOF(long double, 12)
|
|
AC_COMPILE_CHECK_SIZEOF(void *, 4)
|
|
|
|
dnl Determine the types to use for specific sizes of integers and floats.
|
|
AC_SUBST(JITINT8)
|
|
AC_SUBST(JITUINT8)
|
|
AC_SUBST(JITINT16)
|
|
AC_SUBST(JITINT32)
|
|
AC_SUBST(JITINT64)
|
|
AC_SUBST(JITINT64CXX)
|
|
AC_SUBST(JITNATIVEINT)
|
|
AC_SUBST(JITFLOAT32)
|
|
AC_SUBST(JITFLOAT64)
|
|
AC_SUBST(JITNATIVEFLOAT)
|
|
AC_SUBST(JITNATIVEINTDEFINE)
|
|
AC_SUBST(JITNFLOATISDOUBLE)
|
|
AC_MSG_CHECKING(for the 8-bit integer types)
|
|
if test "$ac_cv_sizeof_char" = 1 ; then
|
|
if test "x$ac_cv_c_char_unsigned" = "xyes" ; then
|
|
JITINT8="signed char"
|
|
else
|
|
JITINT8=char
|
|
fi
|
|
JITUINT8="unsigned char"
|
|
elif test "$ac_cv_sizeof_short" = 1 ; then
|
|
JITINT8=short
|
|
JITUINT8="unsigned short"
|
|
elif test "$ac_cv_sizeof_int" = 1 ; then
|
|
JITINT8=int
|
|
JITUINT8="unsigned int"
|
|
elif test "$ac_cv_sizeof_long" = 1 ; then
|
|
JITINT8=long
|
|
JITUINT8="unsigned long"
|
|
else
|
|
AC_MSG_ERROR(unknown)
|
|
fi
|
|
AC_MSG_RESULT([$JITINT8, $JITUINT8])
|
|
AC_MSG_CHECKING(for the 16-bit integer types)
|
|
if test "$ac_cv_sizeof_short" = 2 ; then
|
|
JITINT16=short
|
|
elif test "$ac_cv_sizeof_int" = 2 ; then
|
|
JITINT16=int
|
|
elif test "$ac_cv_sizeof_long" = 2 ; then
|
|
JITINT16=long
|
|
else
|
|
AC_MSG_ERROR(unknown)
|
|
fi
|
|
AC_MSG_RESULT([$JITINT16, unsigned $JITINT16])
|
|
AC_MSG_CHECKING(for the 32-bit integer types)
|
|
if test "$ac_cv_sizeof_int" = 4 ; then
|
|
JITINT32=int
|
|
elif test "$ac_cv_sizeof_long" = 4 ; then
|
|
JITINT32=long
|
|
elif test "$ac_cv_sizeof_short" = 4 ; then
|
|
JITINT32=short
|
|
else
|
|
AC_MSG_ERROR(unknown)
|
|
fi
|
|
AC_MSG_RESULT([$JITINT32, unsigned $JITINT32])
|
|
AC_MSG_CHECKING(for the 64-bit integer types)
|
|
JITINT64CXX=
|
|
if test "$ac_cv_sizeof___int64" = 8 ; then
|
|
if test "x$JIT_INT64_INCLUDE" = "x" ; then
|
|
JITINT64='long long'
|
|
else
|
|
dnl __int64 doesn't work with g++, although it does with gcc.
|
|
JITINT64='__int64'
|
|
JITINT64CXX='long long'
|
|
fi
|
|
elif test "$ac_cv_sizeof_int" = 8 ; then
|
|
JITINT64=int
|
|
elif test "$ac_cv_sizeof_long" = 8 ; then
|
|
JITINT64=long
|
|
elif test "$ac_cv_sizeof_long_long" = 8 ; then
|
|
JITINT64='long long'
|
|
else
|
|
AC_MSG_ERROR(unknown)
|
|
fi
|
|
if test "x$JITINT64CXX" = "x" ; then
|
|
JITINT64CXX="$JITINT64"
|
|
fi
|
|
AC_MSG_RESULT([$JITINT64, unsigned $JITINT64])
|
|
AC_MSG_CHECKING(for the native integer types)
|
|
if test "$ac_cv_sizeof_void_p" = 4 ; then
|
|
JITNATIVEINT="$JITINT32"
|
|
JITNATIVEINTDEFINE="JIT_NATIVE_INT32"
|
|
elif test "$ac_cv_sizeof_void_p" = 8 ; then
|
|
JITNATIVEINT="$JITINT64"
|
|
JITNATIVEINTDEFINE="JIT_NATIVE_INT64"
|
|
else
|
|
AC_MSG_ERROR(unknown)
|
|
fi
|
|
AC_MSG_RESULT([$JITNATIVEINT, unsigned $JITNATIVEINT])
|
|
AC_MSG_CHECKING(for the 32-bit floating-point type)
|
|
if test "$ac_cv_sizeof_float" = 4 ; then
|
|
JITFLOAT32=float
|
|
elif test "$ac_cv_sizeof_double" = 4 ; then
|
|
JITFLOAT32=double
|
|
else
|
|
AC_MSG_ERROR(unknown)
|
|
fi
|
|
AC_MSG_RESULT($JITFLOAT32)
|
|
AC_MSG_CHECKING(for the 64-bit floating-point type)
|
|
if test "$ac_cv_sizeof_float" = 8 ; then
|
|
JITFLOAT64=float
|
|
elif test "$ac_cv_sizeof_double" = 8 ; then
|
|
JITFLOAT64=double
|
|
else
|
|
AC_MSG_ERROR(unknown)
|
|
fi
|
|
AC_MSG_RESULT($JITFLOAT64)
|
|
AC_MSG_CHECKING(for the native floating-point type)
|
|
JITNFLOATISDOUBLE=''
|
|
if test "x$platform_win32" = "xyes" ; then
|
|
dnl MSVC's "long double" is the same as "double", so we make sure
|
|
dnl to preserve compatibility between MSVC and gcc.
|
|
JITNATIVEFLOAT='double'
|
|
JITNFLOATISDOUBLE='#define JIT_NFLOAT_IS_DOUBLE 1'
|
|
elif test "$ac_cv_sizeof_long_double" != 0 ; then
|
|
if test "$ac_cv_sizeof_long_double" = "$ac_cv_sizeof_double" ; then
|
|
JITNATIVEFLOAT='double'
|
|
JITNFLOATISDOUBLE='#define JIT_NFLOAT_IS_DOUBLE 1'
|
|
else
|
|
JITNATIVEFLOAT='long double'
|
|
fi
|
|
elif test "$ac_cv_sizeof_double" != 0 ; then
|
|
JITNATIVEFLOAT=double
|
|
JITNFLOATISDOUBLE='#define JIT_NFLOAT_IS_DOUBLE 1'
|
|
elif test "$ac_cv_sizeof_float" != 0 ; then
|
|
JITNATIVEFLOAT=float
|
|
else
|
|
AC_MSG_ERROR(unknown)
|
|
fi
|
|
AC_MSG_RESULT($JITNATIVEFLOAT)
|
|
|
|
dnl Check to see if we are using gcc or not.
|
|
if test x$GCC = xyes ; then
|
|
CFLAGS="$CFLAGS -Wall"
|
|
fi
|
|
if test x$GXX = xyes ; then
|
|
CXXFLAGS="$CXXFLAGS -Wall"
|
|
fi
|
|
|
|
dnl If CFLAGS contains "-fomit-frame-pointer", then remove it.
|
|
dnl We need to have frame pointers to perform stack walking.
|
|
case "x$CFLAGS" in
|
|
*-fomit-frame-pointer*)
|
|
CFLAGS=`echo "$CFLAGS" | sed 's/-fomit-frame-pointer//'` ;;
|
|
*) ;;
|
|
esac
|
|
case "x$CXXFLAGS" in
|
|
*-fomit-frame-pointer*)
|
|
CXXFLAGS=`echo "$CXXFLAGS" | sed 's/-fomit-frame-pointer//'` ;;
|
|
*) ;;
|
|
esac
|
|
|
|
dnl Find the option to use to turn on C++ exception handling.
|
|
AC_CACHE_CHECK(for C++ exception handling option, ac_cv_prog_cxx_exceptions,
|
|
[echo 'int main(int argc, char **argv){try { throw 1; } catch(int i) { return i; } return 0;}' > conftest.c
|
|
if test -z "`${CXX-c++} -o conftest conftest.c 2>&1`"; then
|
|
ac_cv_prog_cxx_exceptions='none needed'
|
|
else
|
|
if test -z "`${CXX-c++} -fexceptions -o conftest conftest.c 2>&1`"; then
|
|
ac_cv_prog_cxx_exceptions=-fexceptions
|
|
else
|
|
if test -z "`${CXX-c++} -fhandle-exceptions -o conftest conftest.c 2>&1`"; then
|
|
ac_cv_prog_cxx_exceptions=-fhandle-exceptions
|
|
else
|
|
ac_cv_prog_cxx_exceptions='none needed'
|
|
fi
|
|
fi
|
|
fi
|
|
rm -f conftest*
|
|
])
|
|
if test "x$ac_cv_prog_cxx_exceptions" != "xnone needed" ; then
|
|
CXXFLAGS="$ac_cv_prog_cxx_exceptions $CXXFLAGS"
|
|
fi
|
|
|
|
dnl Determine if the C++ compiler understands the "throw()" idiom.
|
|
AC_CACHE_CHECK(for C++ throw() idiom, ac_cv_prog_cxx_throw_idiom,
|
|
[echo 'extern "C" void func(void) throw(); int main(int argc, char **argv){return 0;}' > conftest.c
|
|
if test -z "`${CXX-c++} -o conftest conftest.c 2>&1`"; then
|
|
ac_cv_prog_cxx_throw_idiom=yes
|
|
else
|
|
ac_cv_prog_cxx_throw_idiom=no
|
|
fi
|
|
rm -f conftest*
|
|
])
|
|
AC_SUBST(JITTHROWIDIOM)
|
|
if test "x$ac_cv_prog_cxx_throw_idiom" = "xyes" ; then
|
|
JITTHROWIDIOM='throw()'
|
|
else
|
|
JITTHROWIDIOM=''
|
|
fi
|
|
|
|
dnl Determine if the C compiler understands the "-fno-gcse" option.
|
|
dnl We will get better code in the interpreter if we use this option.
|
|
AC_CACHE_CHECK(for -fno-gcse option, ac_cv_prog_no_gcse,
|
|
[echo 'int main(int argc, char **argv){ return 0;}' > conftest.c
|
|
if test -z "`${CC-cc} -fno-gcse -o conftest conftest.c 2>&1`"; then
|
|
ac_cv_prog_no_gcse=yes
|
|
else
|
|
ac_cv_prog_no_gcse=no
|
|
fi
|
|
rm -f conftest*
|
|
])
|
|
if test "x$ac_cv_prog_no_gcse" = "xyes" ; then
|
|
CFLAGS="-fno-gcse $CFLAGS"
|
|
fi
|
|
|
|
dnl Determine if the C++ compiler understands the "-lstdc++" option.
|
|
dnl Needed to force the shared libraries to link in the C++ code.
|
|
AC_CACHE_CHECK(for -lstdc++ option, ac_cv_prog_stdcpp,
|
|
[echo 'int main(int argc, char **argv){ return 0;}' > conftest.c
|
|
if test -z "`${CXX-c++} -o conftest conftest.c -lstdc++ 2>&1`"; then
|
|
ac_cv_prog_stdcpp=yes
|
|
else
|
|
ac_cv_prog_stdcpp=no
|
|
fi
|
|
rm -f conftest*
|
|
])
|
|
AC_SUBST(LIB_STDCPP)
|
|
if test "x$ac_cv_prog_stdcpp" = "xyes" ; then
|
|
LIB_STDCPP="-lstdc++"
|
|
else
|
|
LIB_STDCPP=""
|
|
fi
|
|
|
|
dnl Check for computed goto support in the compiler.
|
|
AC_MSG_CHECKING(for computed goto support)
|
|
AC_TRY_COMPILE([], [
|
|
static void *labels[] = {&&label0, &&label1, &&label2};
|
|
unsigned char *pc = 0;
|
|
goto *labels[*pc];
|
|
label0: ;
|
|
label1: ;
|
|
label2: ;
|
|
], AC_DEFINE(HAVE_COMPUTED_GOTO, 1, [Define if you have support for computed gotos]) compgoto=yes, compgoto=no)
|
|
AC_MSG_RESULT($compgoto)
|
|
AC_MSG_CHECKING(for pic computed goto support)
|
|
AC_TRY_COMPILE([], [
|
|
static int labelOffsets[] =
|
|
{&&label0 - &&label0, &&label1 - &&label0, &&label2 - &&label0};
|
|
unsigned char *pc = 0;
|
|
goto *(&&label0 + labelOffsets[*pc]);
|
|
label0: ;
|
|
label1: ;
|
|
label2: ;
|
|
], AC_DEFINE(HAVE_PIC_COMPUTED_GOTO, 1, [Define if you have PIC support for computed gotos]) piccompgoto=yes, piccompgoto=no)
|
|
AC_MSG_RESULT($piccompgoto)
|
|
|
|
dnl Checks for library functions.
|
|
if test "x$suppress_libm" = "xno" ; then
|
|
AC_CHECK_LIB(m, sin)
|
|
fi
|
|
if test "x$platform_win32" = "xno" ; then
|
|
AC_CHECK_LIB(dl, dlopen)
|
|
AC_CHECK_LIB(pthread, pthread_create)
|
|
fi
|
|
AC_FUNC_MEMCMP
|
|
AC_CHECK_FUNCS(memset memcmp memchr memcpy memmove bcopy bzero bcmp)
|
|
AC_CHECK_FUNCS(strlen strcpy strcat strncpy strcmp strncmp)
|
|
AC_CHECK_FUNCS(strchr strrchr vsprintf vsnprintf _vsnprintf getpagesize)
|
|
AC_CHECK_FUNCS(isnan isinf finite fmod remainder drem ceil floor)
|
|
AC_CHECK_FUNCS(acos asin atan atan2 cos cosh exp log log10 pow)
|
|
AC_CHECK_FUNCS(sin sinh sqrt tan tanh)
|
|
AC_CHECK_FUNCS(isnanf isinff finitef fmodf remainderf dremf ceilf floorf)
|
|
AC_CHECK_FUNCS(acosf asinf atanf atan2f cosf coshf expf logf log10f powf)
|
|
AC_CHECK_FUNCS(sinf sinhf sqrtf tanf tanhf)
|
|
AC_CHECK_FUNCS(isnanl isinfl finitel fmodl remainderl dreml ceill floorl)
|
|
AC_CHECK_FUNCS(acosl asinl atanl atan2l cosl coshl expl logl log10l powl)
|
|
AC_CHECK_FUNCS(sinl sinhl sqrtl tanl tanhl)
|
|
AC_CHECK_FUNCS(dlopen cygwin_conv_to_win32_path mmap munmap mprotect)
|
|
AC_CHECK_FUNCS(sigsetjmp __sigsetjmp _setjmp)
|
|
AC_FUNC_ALLOCA
|
|
|
|
AC_OUTPUT([
|
|
Makefile
|
|
include/Makefile
|
|
include/jit/Makefile
|
|
include/jit/jit-defs.h
|
|
tools/Makefile
|
|
jit/Makefile
|
|
jitdynamic/Makefile
|
|
jitplus/Makefile
|
|
dpas/Makefile
|
|
tutorial/Makefile
|
|
tests/Makefile
|
|
doc/Makefile])
|
|
|