| m4_define([version_major], [1]) |
| m4_define([version_minor], [8]) |
| |
| AC_INIT([libabigail], |
| [version_major.version_minor], |
| [http://sourceware.org/bugzilla], |
| [libabigail], |
| [http://sourceware.org/libabigail]) |
| |
| AC_PREREQ([2.63]) |
| AC_CONFIG_AUX_DIR([build-aux]) |
| AC_CONFIG_HEADER([config.h]) |
| AC_CONFIG_SRCDIR([README]) |
| AC_CONFIG_MACRO_DIR([m4]) |
| |
| dnl Include some autoconf macros to check for python modules. |
| dnl |
| dnl These macros are coming from the autoconf archive at |
| dnl http://www.gnu.org/software/autoconf-archive |
| |
| dnl This one is for the AX_CHECK_PYTHON_MODULES() macro. |
| m4_include([autoconf-archive/ax_check_python_modules.m4]) |
| |
| dnl These two below are for the AX_PROG_PYTHON_VERSION() module. |
| m4_include([autoconf-archive/ax_compare_version.m4]) |
| m4_include([autoconf-archive/ax_prog_python_version.m4]) |
| |
| dnl This one is to be able to run "make check-valgrind" |
| dnl and have unit tests run under der Valgrind. |
| m4_include([autoconf-archive/ax_valgrind_check.m4]) |
| |
| AM_INIT_AUTOMAKE([1.11.1 foreign subdir-objects tar-ustar parallel-tests]) |
| AM_MAINTAINER_MODE([enable]) |
| |
| AM_SILENT_RULES([yes]) |
| |
| VERSION_MAJOR=version_major |
| VERSION_MINOR=version_minor |
| VERSION_REVISION=0 |
| |
| AC_SUBST(VERSION_MAJOR) |
| AC_SUBST(VERSION_MINOR) |
| AC_SUBST(VERSION_REVISION) |
| |
| dnl This VERSION_SUFFIX environment variable is to allow appending |
| dnl arbitrary text to the libabigail version string representation. |
| dnl That is useful to identify custom versions of the library |
| dnl (e.g. development versions or versions of a particular origin). |
| dnl |
| dnl The feature can be enabled by passing VERSION_SUFFIX to `configure`, |
| dnl e.g. |
| dnl |
| dnl $ configure VERSION_SUFFIX="-dev" |
| AC_SUBST(VERSION_SUFFIX) |
| |
| AC_ARG_ENABLE(rpm, |
| AS_HELP_STRING([--enable-rpm=yes|no|auto], |
| [enable the support of rpm in abipkgdiff (default is auto)]), |
| ENABLE_RPM=$enableval, |
| ENABLE_RPM=auto) |
| |
| AC_ARG_ENABLE(deb, |
| AS_HELP_STRING([--enable-deb=yes|no|auto], |
| [enable the support of deb in abipkgdiff (default is auto)]), |
| ENABLE_DEB=$enableval, |
| ENABLE_DEB=auto) |
| |
| AC_ARG_ENABLE(tar, |
| AS_HELP_STRING([--enable-tar=yes|no|auto], |
| [enable the support of GNU tar archives in abipkgdiff (default is auto)]), |
| ENABLE_TAR=$enableval, |
| ENABLE_TAR=auto) |
| |
| AC_ARG_ENABLE(zip-archive, |
| AS_HELP_STRING([--enable-zip-archive=yes|no|auto], |
| [enable bundling of TUs in zip archives (default is no)]), |
| ENABLE_ZIP_ARCHIVE=$enableval, |
| ENABLE_ZIP_ARCHIVE=no) |
| |
| |
| AC_ARG_ENABLE(cxx11, |
| AS_HELP_STRING([--enable-cxx11=yes|no], |
| [enable features that use the C++11 compiler]), |
| ENABLE_CXX11=$enableval, |
| ENABLE_CXX11=no) |
| |
| AC_ARG_ENABLE(apidoc, |
| AS_HELP_STRING([--enable-apidoc=yes|no|auto], |
| [enable generation of the apidoc in html]), |
| ENABLE_APIDOC=$enableval, |
| ENABLE_APIDOC=auto) |
| |
| AC_ARG_ENABLE(manual, |
| AS_HELP_STRING([--enable-manual=yes|no|auto], |
| [enable generation of the manual in html]), |
| ENABLE_MANUAL=$enableval, |
| ENABLE_MANUAL=auto) |
| |
| AC_ARG_ENABLE([bash-completion], |
| AS_HELP_STRING([--enable-bash-completion=yes|no|auto], |
| [enable using completion files for tools]), |
| ENABLE_BASH_COMPLETION=$enableval, |
| ENABLE_BASH_COMPLETION=auto) |
| |
| AC_ARG_ENABLE([fedabipkgdiff], |
| AS_HELP_STRING([--enable-fedabipkgdiff=yes|no|auto], |
| [enable the fedabipkgdiff tool]), |
| ENABLE_FEDABIPKGDIFF=$enableval, |
| ENABLE_FEDABIPKGDIFF=auto) |
| |
| AC_ARG_ENABLE([python3], |
| AS_HELP_STRING([--enable-python3=yes|no|auto], |
| [enable running abigail tools with python3 (default is auto)]), |
| ENABLE_PYTHON3=$enableval, |
| ENABLE_PYTHON3=auto) |
| |
| AC_ARG_ENABLE(asan, |
| AS_HELP_STRING([--enable-asan=yes|no], |
| [enable the support of building with -fsanitize=address)]), |
| ENABLE_ASAN=$enableval, |
| ENABLE_ASAN=no) |
| |
| AC_ARG_ENABLE(msan, |
| AS_HELP_STRING([--enable-msan=yes|no], |
| [enable the support of building with -fsanitize=memory)]), |
| ENABLE_MSAN=$enableval, |
| ENABLE_MSAN=no) |
| |
| AC_ARG_ENABLE(tsan, |
| AS_HELP_STRING([--enable-tsan=yes|no], |
| [enable the support of building with -fsanitize=thread)]), |
| ENABLE_TSAN=$enableval, |
| ENABLE_TSAN=no) |
| |
| AC_ARG_ENABLE(ubsan, |
| AS_HELP_STRING([--enable-ubsan=yes|no], |
| [enable the support of building with -fsanitize=undefined)]), |
| ENABLE_UBSAN=$enableval, |
| ENABLE_UBSAN=no) |
| |
| dnl ************************************************* |
| dnl check for dependencies |
| dnl ************************************************* |
| |
| AC_PROG_CXX |
| AC_USE_SYSTEM_EXTENSIONS |
| AC_PROG_INSTALL |
| |
| LT_PREREQ([2.2]) |
| LT_INIT |
| |
| AC_LANG([C++]) |
| AC_LANG_COMPILER_REQUIRE |
| |
| dnl |
| dnl check if the c++ compiler has support __attribute__((visibility("hidden"))) |
| dnl |
| AC_MSG_NOTICE([checking for GCC visibility attribute support ...]) |
| AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ |
| struct __attribute__((visibility("hidden"))) Foo |
| { |
| int m0; |
| |
| Foo() |
| : m0() |
| {} |
| }; |
| ]])], |
| [SUPPORTS_GCC_VISIBILITY_ATTRIBUTE=yes], |
| [SUPPORTS_GCC_VISIBILITY_ATTRIBUTE=no] |
| ) |
| |
| if test x$SUPPORTS_GCC_VISIBILITY_ATTRIBUTE = xyes; then |
| AC_MSG_NOTICE([GCC visibility attribute is supported]) |
| AC_DEFINE([HAS_GCC_VISIBILITY_ATTRIBUTE], 1, |
| [Defined if the compiler supports the attribution visibility syntax __attribute__((visibility("hidden")))]) |
| VISIBILITY_FLAGS="-fvisibility=hidden" |
| else |
| AC_MSG_NOTICE([GCC visibility attribute is not supported]) |
| VISIBILITY_FLAGS= |
| fi |
| |
| AC_SUBST(VISIBILITY_FLAGS) |
| |
| dnl Older glibc had a broken fts that didn't work with Large File Systems. |
| dnl We want the version that can handler LFS, but include workaround if we |
| dnl get a bad one. Add define to CFLAGS (not AC_DEFINE it) since we need to |
| dnl check it before including config.h (which might define _FILE_OFFSET_BITS). |
| AC_CACHE_CHECK([whether including fts.h with _FILE_OFFSET_BITS set breaks], ac_cv_bad_fts, |
| [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[ |
| #define _FILE_OFFSET_BITS 64 |
| #include <fts.h> |
| ]])], |
| ac_cv_bad_fts=no, ac_cv_bad_fts=yes)]) |
| AS_IF([test "x$ac_cv_bad_fts" = "xyes"], |
| [CFLAGS="$CFLAGS -DBAD_FTS=1", |
| CXXFLAGS="$CXXFLAGS -DBAD_FTS=1"]) |
| |
| dnl Check for dependency: libelf, libdw, libebl (elfutils) |
| dnl Note that we need to use at least elfutils 0.159 but |
| dnl at that time elfutils didnt have pkgconfig capabilities |
| dnl to easily query for its version. |
| ELF_LIBS= |
| AC_CHECK_LIB([elf], [elf_end], [ELF_LIBS="-lelf"]) |
| AC_CHECK_HEADER([libelf.h], |
| [], |
| [AC_MSG_ERROR([could not find libelf.h])]) |
| |
| DW_LIBS= |
| AC_CHECK_LIB(dw, dwfl_begin, [DW_LIBS=-ldw]) |
| AC_CHECK_LIB(dw, dwarf_getalt, |
| [FOUND_DWARF_GETALT_IN_LIBDW=yes], |
| [FOUND_DWARF_GETALT_IN_LIBDW=no]) |
| |
| AC_CHECK_HEADER(elfutils/libdwfl.h, |
| [], |
| [AC_MSG_ERROR([could not find elfutils/libdwfl.h installed])]) |
| |
| dnl Allow users to compile with the NDEBUG macro defined, |
| dnl meaning they are compiling in a mode where the |
| dnl assert call does nothing. With the directive below, |
| dnl users just need to pass the --disable-assert |
| dnl option to configure. |
| AC_HEADER_ASSERT |
| |
| if test x$ELF_LIBS = x; then |
| AC_MSG_ERROR([could not find elfutils elf library installed]) |
| fi |
| |
| if test x$DW_LIBS = x; then |
| AC_MSG_ERROR([could not find elfutils dwarf library installed]) |
| fi |
| |
| if test x$FOUND_DWARF_GETALT_IN_LIBDW = xyes; then |
| AC_DEFINE([LIBDW_HAS_DWARF_GETALT], 1, |
| [Defined if libdw has the function dwarf_getalt]) |
| fi |
| |
| AC_SUBST(DW_LIBS) |
| AC_SUBST([ELF_LIBS]) |
| |
| dnl Check for dependency: libxml |
| LIBXML2_VERSION=2.6.22 |
| PKG_CHECK_MODULES(XML, libxml-2.0 >= $LIBXML2_VERSION) |
| |
| AC_SUBST(LIBXML2_VERSION) |
| AC_SUBST(XML_LIBS) |
| AC_SUBST(XML_CFLAGS) |
| |
| dnl Check for some programs like rm, mkdir, etc ... |
| AC_CHECK_PROG(HAS_RM, rm, yes, no) |
| if test x$HAS_RM = xno; then |
| AC_MSG_ERROR([could not find the program 'rm' installed]) |
| fi |
| |
| AC_CHECK_PROG(HAS_MKDIR, mkdir, yes, no) |
| if test x$HAS_MKDIR = xno; then |
| AC_MSG_ERROR([could not find the program 'mkdir' installed]) |
| fi |
| |
| dnl Check for the rpm2cpio and cpio programs |
| if test x$ENABLE_RPM = xyes -o x$ENABLE_RPM = xauto; then |
| AC_CHECK_PROG(HAS_RPM2CPIO, rpm2cpio, yes, no) |
| AC_CHECK_PROG(HAS_CPIO, cpio, yes, no) |
| AC_CHECK_PROG(HAS_RPM, rpm, yes, no) |
| |
| if test x$HAS_RPM2CPIO = xyes -a x$HAS_CPIO = xyes -a x$HAS_RPM = xyes; then |
| ENABLE_RPM=yes |
| else |
| if test x$ENABLE_RPM = xyes; then |
| AC_MSG_ERROR([rpm support in abipkgdiff needs 'rpm2cpio', 'cpio' and 'rpm' programs to be installed]) |
| fi |
| ENABLE_RPM=no |
| fi |
| fi |
| |
| if test x$ENABLE_RPM = xyes; then |
| AC_DEFINE([WITH_RPM], 1, [compile the rpm package support in abipkgdiff]) |
| AC_MSG_NOTICE(rpm support in abipkgdiff is enabled); |
| else |
| AC_MSG_NOTICE(rpm support in abipkgdiff is disabled); |
| fi |
| |
| AM_CONDITIONAL(ENABLE_RPM, test x$ENABLE_RPM = xyes) |
| |
| dnl Check for the dpkg program |
| if test x$ENABLE_DEB = xauto -o x$ENABLE_DEB = xyes; then |
| AC_CHECK_PROG(HAS_DPKG, dpkg, yes, no) |
| |
| if test x$ENABLE_DEB = xauto; then |
| if test x$HAS_DPKG = xyes; then |
| ENABLE_DEB=yes |
| else |
| ENABLE_DEB=no |
| fi |
| fi |
| fi |
| |
| if test x$ENABLE_DEB = xyes; then |
| AC_DEFINE([WITH_DEB], 1, [compile the deb package support in abipkgdiff]) |
| AC_MSG_NOTICE(deb support in abipkgdiff is enabled); |
| else |
| AC_MSG_NOTICE(deb support in abipkgdiff is disabled); |
| fi |
| |
| AM_CONDITIONAL(ENABLE_DEB, test x$ENABLE_DEB = xyes) |
| |
| dnl Check for the tar program |
| if test x$ENABLE_TAR = xauto -o x$ENABLE_TAR = xyes; then |
| AC_CHECK_PROG(HAS_TAR, tar, yes, no) |
| |
| if test x$ENABLE_TAR = xauto; then |
| if test x$HAS_TAR = xyes; then |
| ENABLE_TAR=yes |
| fi |
| fi |
| fi |
| |
| if test x$ENABLE_TAR = xyes; then |
| AC_DEFINE([WITH_TAR], 1, [compile the GNU tar archive support in abipkgdiff]) |
| AC_MSG_NOTICE(GNU tar support in abipkgdiff is enabled); |
| else |
| AC_MSG_NOTICE(GNU tar support in abipkgdiff is disabled); |
| fi |
| |
| AM_CONDITIONAL(ENABLE_TAR, test x$ENABLE_TAR = xyes) |
| |
| dnl Check for the bash-completion package |
| if test x$ENABLE_BASH_COMPLETION = xauto -o x$ENABLE_BASH_COMPLETION = xyes; then |
| AC_CHECK_PROG(HAS_BASH_COMPLETION, bash-completion, yes, no) |
| |
| if test x$ENABLE_BASH_COMPLETION = xauto; then |
| if test x$HAS_BASH_COMPLETION = xyes; then |
| ENABLE_BASH_COMPLETION=yes |
| else |
| ENABLE_BASH_COMPLETION=no |
| fi |
| fi |
| fi |
| |
| if test x$ENABLE_BASH_COMPLETION = xyes; then |
| AC_MSG_NOTICE(bash-completion support in libabigail is enabled); |
| else |
| AC_MSG_NOTICE(bash-completion support in libabigail is disabled); |
| fi |
| |
| AM_CONDITIONAL(ENABLE_BASH_COMPLETION, test x$ENABLE_BASH_COMPLETION = xyes) |
| |
| # The minimal python 2 version we want to support is 2.6.6 because EL6 |
| # distributions have that version installed. |
| MINIMAL_PYTHON2_VERSION="2.6.6" |
| |
| AC_PATH_PROG(PYTHON, python, no) |
| AX_PROG_PYTHON_VERSION($MINIMAL_PYTHON2_VERSION, |
| [MINIMAL_PYTHON_VERSION_FOUND=yes], |
| [MINIMAL_PYTHON_VERSION_FOUND=no]) |
| |
| # The minimal python 3 version we want to support is 3.5, which is |
| # available in Fedora releases and in EL7. |
| if test x$ENABLE_PYTHON3 != xno; then |
| AC_CHECK_PROGS(PYTHON3_INTERPRETER, [python3 python3.5 python3.6 python3.7], no) |
| else |
| PYTHON3_INTERPRETER=no |
| fi |
| |
| if test x$ENABLE_PYTHON3 = xauto; then |
| if test x$PYTHON3_INTERPRETER != xno; then |
| ENABLE_PYTHON3=yes |
| else |
| # When enabling python3 is auto, tests only run if the |
| # python3 interpreter was found on the system. Otherwise, |
| # just ignore it. |
| ENABLE_PYTHON3=no |
| AC_MSG_NOTICE([Python 3 was not found. Skip running tests with Python 3.]) |
| fi |
| fi |
| |
| if test x$ENABLE_PYTHON3 = xyes; then |
| if test x$PYTHON3_INTERPRETER != xno; then |
| # We were asked to enable python3 implicitely (auto and |
| # python3 was found) or explicitly. So enable running tests |
| # using python3 then. |
| RUN_TESTS_WITH_PY3=yes |
| else |
| AC_MSG_ERROR([Python 3 was not found]) |
| fi |
| fi |
| |
| if test x$PYTHON3_INTERPRETER = xyes; then |
| MINIMAL_PYTHON_VERSION_FOUND=yes |
| fi |
| |
| if test x$MINIMAL_PYTHON_VERSION_FOUND = xno; then |
| AC_MSG_NOTICE([no minimal version of python found]) |
| if test x$PYTHON = xno; then |
| AC_MSG_NOTICE([python binary wasn't found]) |
| if test x$PYTHON3_INTERPRETER != xno; then |
| AC_MSG_NOTICE([using $PYTHON3_INTERPRETER instead]) |
| PYTHON=$PYTHON3_INTERPRETER |
| MINIMAL_PYTHON_VERSION_FOUND=yes |
| MISSING_FEDABIPKGDIFF_DEP=no |
| fi |
| fi |
| else |
| AC_MSG_NOTICE([a minimal version of python was found ...]) |
| if test x$PYTHON3_INTERPRETER != xno; then |
| # We were instructed to use python3 and it's present on the |
| # system. Let's update the PYTHON variable that points to the |
| # actual python interpreter we are going to be using |
| AC_MSG_NOTICE([... and it was $PYTHON3_INTERPRETER]) |
| PYTHON=$PYTHON3_INTERPRETER |
| fi |
| fi |
| |
| dnl if --enable-fedabipkgdiff has the 'auto' value, then check for the required |
| dnl python modules. If they are present, then enable the fedabipkgdiff program. |
| dnl If they are not then disable the program. |
| dnl |
| dnl If --enable-fedabipkgdiff has the 'yes' value, then check for the required |
| dnl python modules and whatever dependency fedabipkgdiff needs. If they are |
| dnl not present then the configure script will error out. |
| |
| if test x$ENABLE_FEDABIPKGDIFF = xauto -o x$ENABLE_FEDABIPKGDIFF = xyes; then |
| CHECK_DEPS_FOR_FEDABIPKGDIFF=yes |
| else |
| CHECK_DEPS_FOR_FEDABIPKGDIFF=no |
| fi |
| |
| if test x$CHECK_DEPS_FOR_FEDABIPKGDIFF = xyes; then |
| MISSING_FEDABIPKGDIFF_DEP=no |
| |
| if test x$ENABLE_FEDABIPKGDIFF = xyes; then |
| MISSING_FEDABIPKGDIFF_DEP_FATAL=yes |
| else |
| MISSING_FEDABIPKGDIFF_DEP_FATAL=no |
| fi |
| |
| AC_PATH_PROG(WGET, wget, no) |
| |
| if test x$WGET = xno; then |
| ENABLE_FEDABIPKGDIFF=no |
| if test x$MISSING_FEDABIPKGDIFF_DEP_FATAL = xyes; then |
| AC_MSG_ERROR(could not find the wget program) |
| else |
| MISSING_FEDABIPKGDIFF_DEP=yes |
| AC_MSG_NOTICE([could not find the wget program]) |
| AC_MSG_NOTICE([disabling fedabipkgdiff as a result]) |
| fi |
| fi |
| |
| if test x$MINIMAL_PYTHON_VERSION_FOUND = xno; then |
| MISSING_FEDABIPKGDIFF_DEP=yes |
| if test x$MISSING_FEDABIPKGDIFF_DEP_FATAL = xyes; then |
| AC_MSG_ERROR([could not find a python program of version at least $MINIMAL_PYTHON2_VERSION]) |
| fi |
| fi |
| |
| ################################################################### |
| # Now we are going to check the presence of the required python |
| # modules using either python2 or python3 as required until now. |
| ################################################################### |
| |
| # Grrr, the urlparse python2 module got renamed in python3 as |
| # urllib.parse. Oh well. |
| if test x$PYTHON = xpython3; then |
| URLPARSE_MODULE=urllib.parse |
| else |
| URLPARSE_MODULE=urlparse |
| fi |
| |
| REQUIRED_PYTHON_MODULES_FOR_FEDABIPKGDIFF="\ |
| argparse logging os re subprocess sys $URLPARSE_MODULE \ |
| xdg koji mock rpm imp tempfile mimetypes shutil six" |
| |
| if test x$ENABLE_FEDABIPKGDIFF != xno; then |
| AX_CHECK_PYTHON_MODULES([$REQUIRED_PYTHON_MODULES_FOR_FEDABIPKGDIFF], |
| [$PYTHON], |
| [FOUND_ALL_PYTHON_MODULES=yes], |
| [FOUND_ALL_PYTHON_MODULES=no]) |
| |
| if test x$FOUND_ALL_PYTHON_MODULES = xno; then |
| MISSING_FEDABIPKGDIFF_DEP=yes |
| if test x$MISSING_FEDABIPKGDIFF_DEP_FATAL = xyes; then |
| AC_MSG_ERROR([missing python modules: $MISSING_PYTHON_MODULES]); |
| else |
| AC_MSG_NOTICE([missing python modules: $MISSING_PYTHON_MODULES]) |
| AC_MSG_NOTICE([disabling fedabipkgdiff as a result]) |
| fi |
| ENABLE_FEDABIPKGDIFF=no |
| else |
| # On some old platforms, the koji client object doesn't have |
| # the required .read_config method. Alas, that module doesn't |
| # have any __version__ string either. So we do as well as we |
| # can to try and detect that case and disable fedabipkgdiff if |
| # necessary. |
| AC_MSG_CHECKING([checking if koji client is recent enough ...]) |
| $PYTHON -c " |
| import koji |
| koji.read_config('koji')" |
| if test $? -eq 0; then |
| koji_version_check_ok=yes |
| else |
| koji_version_check_ok=no |
| fi |
| |
| if test x$koji_version_check_ok = xno; then |
| AC_MSG_RESULT([no, disabling fedpkgdiff]) |
| MISSING_FEDABIPKGDIFF_DEP=yes |
| else |
| AC_MSG_RESULT(yes) |
| fi |
| if test x$MISSING_FEDABIPKGDIFF_DEP = xno; then |
| ENABLE_FEDABIPKGDIFF=yes |
| fi |
| fi |
| fi |
| fi |
| |
| AM_CONDITIONAL(ENABLE_FEDABIPKGDIFF, test x$ENABLE_FEDABIPKGDIFF = xyes) |
| AM_CONDITIONAL(ENABLE_RUNNING_TESTS_WITH_PY3, test x$RUN_TESTS_WITH_PY3 = xyes) |
| AM_CONDITIONAL(ENABLE_PYTHON3_INTERPRETER, test x$PYTHON3_INTERPRETER != xno) |
| AC_SUBST(PYTHON) |
| |
| dnl Check for dependency: libzip |
| LIBZIP_VERSION=0.10.1 |
| |
| HAS_LIBZIP=no |
| # The below doesn't seem to work on my box for a reason. Let's write |
| # the damn thing by hand: |
| # PKG_CHECK_EXISTS([libzip >= $LIBZIP_VERSION], [HAS_LIBZIP=yes], [HAS_LIBZIP=no]) |
| |
| if $PKG_CONFIG --exists --print-errors "libzip >= $LIBZIP_VERSION"; then |
| AC_MSG_NOTICE(found libzip version $LIBZIP_VERSION) |
| HAS_LIBZIP=yes |
| else |
| AC_MSG_NOTICE(no libzip >= $LIBZIP_VERSION has been found) |
| HAS_LIBZIP=no |
| fi |
| |
| if test x$ENABLE_ZIP_ARCHIVE = xauto; then |
| if test x$HAS_LIBZIP = xyes; then |
| ENABLE_ZIP_ARCHIVE=yes; |
| else |
| ENABLE_ZIP_ARCHIVE=no |
| fi |
| fi |
| |
| if test x$ENABLE_ZIP_ARCHIVE = xyes; then |
| AC_MSG_NOTICE(the zip-archive feature is enabled) |
| else |
| AC_MSG_NOTICE(the zip-archive feature is disabled) |
| fi |
| |
| FOUND_LIBZIP=no |
| if test x$ENABLE_ZIP_ARCHIVE = xyes; then |
| PKG_CHECK_MODULES(LIBZIP, libzip >= $LIBZIP_VERSION) |
| FOUND_LIBZIP=yes |
| AC_SUBST(LIBZIP_VERSION) |
| AC_SUBST(LIBZIP_LIBS) |
| AC_SUBST(LIBZIP_CFLAGS) |
| AC_DEFINE([WITH_ZIP_ARCHIVE], 1, [compile the zip archive support]) |
| AC_DEFINE([HAVE_LIBZIP], 1, [Defined to 1 if the libzip library is available]) |
| fi |
| |
| AM_CONDITIONAL(ENABLE_ZIP_ARCHIVE, test x$ENABLE_ZIP_ARCHIVE = xyes) |
| DEPS_CPPFLAGS="$XML_CFLAGS $LIBZIP_CFLAGS" |
| AC_SUBST(DEPS_CPPFLAGS) |
| |
| dnl Handle conditional use of a C++11 compiler |
| if test x$ENABLE_CXX11 = xyes; then |
| CXXFLAGS="$CXXFLAGS -std=c++11" |
| AC_DEFINE([WITH_CXX11], 1, [Defined to 1 if a C++11 compiler is used]) |
| fi |
| |
| AM_CONDITIONAL(ENABLE_CXX11, test x$ENABLE_CXX11 = xyes) |
| |
| dnl Check for the presence of doxygen program |
| |
| if test x$ENABLE_APIDOC != xno; then |
| AC_CHECK_PROG(FOUND_DOXYGEN, doxygen, yes, no) |
| if test x$ENABLE_APIDOC = xauto; then |
| if test x$FOUND_DOXYGEN = xyes; then |
| ENABLE_APIDOC=yes |
| else |
| ENABLE_APIDOC=no |
| fi |
| fi |
| fi |
| AM_CONDITIONAL(ENABLE_APIDOC, test x$ENABLE_APIDOC = xyes) |
| |
| dnl Check for the presence of the sphinx-build program |
| |
| if test x$ENABLE_MANUAL != xno; then |
| AC_CHECK_PROG(FOUND_SPHINX_BUILD, sphinx-build, yes, no) |
| if test x$ENABLE_MANUAL = xauto; then |
| if test x$FOUND_SPHINX_BUILD = xyes; then |
| ENABLE_MANUAL=yes |
| else |
| ENABLE_MANUAL=no |
| fi |
| fi |
| fi |
| AM_CONDITIONAL(ENABLE_MANUAL, test x$ENABLE_MANUAL = xyes) |
| |
| dnl Check for the presence of Valgrind and do the plumbing to allow |
| dnl the running of "make check-valgrind". |
| AX_VALGRIND_DFLT(memcheck, on) |
| AX_VALGRIND_DFLT(helgrind, on) |
| AX_VALGRIND_DFLT(drd, off) |
| AX_VALGRIND_DFLT(sgcheck, off) |
| |
| AX_VALGRIND_CHECK |
| |
| dnl Set the list of libraries libabigail depends on |
| |
| DEPS_LIBS="$XML_LIBS $LIBZIP_LIBS $ELF_LIBS $DW_LIBS" |
| AC_SUBST(DEPS_LIBS) |
| |
| if test x$ABIGAIL_DEVEL != x; then |
| CFLAGS="-g -Og -Wall -Wextra -Werror -D_FORTIFY_SOURCE=2" |
| CXXFLAGS="-g -Og -Wall -Wextra -Werror -D_FORTIFY_SOURCE=2 -D_GLIBCXX_DEBUG" |
| fi |
| |
| if test x$ABIGAIL_DEBUG != x; then |
| CFLAGS="$CFLAGS -Og -g3 -ggdb" |
| CXXFLAGS="$CXXFLAGS -Og -g3 -ggdb" |
| fi |
| |
| if test x$ENABLE_ASAN = xyes; then |
| CFLAGS="$CFLAGS -fsanitize=address" |
| CXXFLAGS="$CXXFLAGS -fsanitize=address" |
| fi |
| |
| if test x$ENABLE_MSAN = xyes; then |
| CFLAGS="$CFLAGS -fsanitize=memory -fsanitize-memory-track-origins" |
| CXXFLAGS="$CXXFLAGS -fsanitize=memory -fsanitize-memory-track-origins" |
| fi |
| |
| if test x$ENABLE_TSAN = xyes; then |
| CFLAGS="$CFLAGS -fsanitize=thread" |
| CXXFLAGS="$CXXFLAGS -fsanitize=thread" |
| fi |
| |
| if test x$ENABLE_UBSAN = xyes; then |
| CFLAGS="$CFLAGS -fsanitize=undefined" |
| CXXFLAGS="$CXXFLAGS -fsanitize=undefined" |
| fi |
| |
| dnl Check if several decls and constant are defined in dependant |
| dnl libraries |
| HAS_EM_AARCH64=no |
| AC_CHECK_DECL([EM_AARCH64], |
| [HAS_EM_AARCH64=yes], |
| [HAS_EM_AARCH64=no], |
| [[#include <elf.h>]]) |
| |
| if test x$HAS_EM_AARCH64 = xyes; then |
| AC_DEFINE([HAVE_EM_AARCH64_MACRO], |
| 1, |
| [Defined to 1 if elf.h has EM_AARCH64 macro defined]) |
| fi |
| |
| HAS_EM_TILEPRO=no |
| AC_CHECK_DECL([EM_TILEPRO], |
| [HAS_EM_TILEPRO=yes], |
| [HAS_EM_TILEPRO=no], |
| [[#include <elf.h>]]) |
| |
| if test x$HAS_EM_TILEPRO = xyes; then |
| AC_DEFINE([HAVE_EM_TILEPRO_MACRO], |
| 1, |
| [Defined to 1 if elf.h has EM_TILEPR0 macro defined]) |
| fi |
| |
| HAS_EM_TILEGX=no |
| AC_CHECK_DECL([EM_TILEGX], |
| [HAS_EM_TILEGX=yes], |
| [HAS_EM_TILEGX=no], |
| [[#include <elf.h>]]) |
| |
| if test x$HAS_EM_TILEGX = xyes; then |
| AC_DEFINE([HAVE_EM_TILEGX_MACRO], |
| 1, |
| [Defined to 1 if elf.h has EM_TILEGX macro defined]) |
| fi |
| |
| HAS_R_AARCH64_ABS64=no |
| AC_CHECK_DECL([R_AARCH64_ABS64], |
| [HAS_R_AARCH64_ABS64=yes], |
| [HAS_R_AARCH64_ABS64=no], |
| [[#include <elf.h>]]) |
| |
| if test x$HAS_R_AARCH64_ABS64 = xyes; then |
| AC_DEFINE([HAVE_R_AARCH64_ABS64_MACRO], |
| 1, |
| [Defined to 1 if elf.h has R_AARCH64_ABS64 macro defined]) |
| fi |
| |
| HAS_R_AARCH64_PREL32=no |
| AC_CHECK_DECL([R_AARCH64_PREL32], |
| [HAS_R_AARCH64_PREL32=yes], |
| [HAS_R_AARCH64_PREL32=no], |
| [[#include <elf.h>]]) |
| |
| if test x$HAS_R_AARCH64_PREL32 = xyes; then |
| AC_DEFINE([HAVE_R_AARCH64_PREL32_MACRO], |
| 1, |
| [Defined to 1 if elf.h has R_AARCH64_PREL32 macro defined]) |
| fi |
| |
| HAS_DW_LANG_UPC=no |
| AC_CHECK_DECL([DW_LANG_UPC], |
| [HAS_DW_LANG_UPC=yes], |
| [HAS_DW_LANG_UPC=no], |
| [[#include <dwarf.h>]]) |
| if test x$HAS_DW_LANG_UPC = xyes; then |
| AC_DEFINE([HAVE_DW_LANG_UPC_enumerator], |
| 1, |
| [Define to 1 if dwarf.h has the DW_LANG_UPC enumerator]) |
| fi |
| |
| HAS_DW_LANG_D=no |
| AC_CHECK_DECL([DW_LANG_D], |
| [HAS_DW_LANG_D=yes], |
| [HAS_DW_LANG_D=no], |
| [[#include <dwarf.h>]]) |
| if test x$HAS_DW_LANG_D = xyes; then |
| AC_DEFINE([HAVE_DW_LANG_D_enumerator], |
| 1, |
| [Define to 1 if dwarf.h has the DW_LANG_D enumerator]) |
| fi |
| |
| HAS_DW_LANG_Python=no |
| AC_CHECK_DECL([DW_LANG_Python], |
| [HAS_DW_LANG_Python=yes], |
| [HAS_DW_LANG_Python=no], |
| [[#include <dwarf.h>]]) |
| if test x$HAS_DW_LANG_Python = xyes; then |
| AC_DEFINE([HAVE_DW_LANG_Python_enumerator], |
| 1, |
| [Define to 1 if dwarf.h has the DW_LANG_Python enumerator]) |
| fi |
| |
| HAS_DW_LANG_Go=no |
| AC_CHECK_DECL([DW_LANG_Go], |
| [HAS_DW_LANG_Go=yes], |
| [HAS_DW_LANG_Go=no], |
| [[#include <dwarf.h>]]) |
| if test x$HAS_DW_LANG_Go = xyes; then |
| AC_DEFINE([HAVE_DW_LANG_Go_enumerator], |
| 1, |
| [Define to 1 if dwarf.h has the DW_LANG_Go enumerator]) |
| fi |
| |
| HAS_DW_LANG_C11=no |
| AC_CHECK_DECL([DW_LANG_C11], |
| [HAS_DW_LANG_C11=yes], |
| [HAS_DW_LANG_C11=no], |
| [[#include <dwarf.h>]]) |
| if test x$HAS_DW_LANG_C11 = xyes; then |
| AC_DEFINE([HAVE_DW_LANG_C11_enumerator], |
| 1, |
| [Define to 1 if dwarf.h has the DW_LANG_C11 enumerator]) |
| fi |
| |
| HAS_DW_LANG_C_plus_plus_03=no |
| AC_CHECK_DECL([DW_LANG_C_plus_plus_03], |
| [HAS_DW_LANG_C_plus_plus_03=yes], |
| [HAS_DW_LANG_C_plus_plus_03=no], |
| [[#include <dwarf.h>]]) |
| if test x$HAS_DW_LANG_C_plus_plus_03 = xyes; then |
| AC_DEFINE([HAVE_DW_LANG_C_plus_plus_03_enumerator], |
| 1, |
| [Define to 1 if dwarf.h has the DW_LANG_C_plus_plus_03 enumerator]) |
| fi |
| |
| HAS_DW_LANG_C_plus_plus_11=no |
| AC_CHECK_DECL([DW_LANG_C_plus_plus_11], |
| [HAS_DW_LANG_C_plus_plus_11=yes], |
| [HAS_DW_LANG_C_plus_plus_11=no], |
| [[#include <dwarf.h>]]) |
| if test x$HAS_DW_LANG_C_plus_plus_11 = xyes; then |
| AC_DEFINE([HAVE_DW_LANG_C_plus_plus_11_enumerator], |
| 1, |
| [Define to 1 if dwarf.h has the DW_LANG_C_plus_plus_11 enumerator]) |
| fi |
| |
| HAS_DW_LANG_C_plus_plus_14=no |
| AC_CHECK_DECL([DW_LANG_C_plus_plus_14], |
| [HAS_DW_LANG_C_plus_plus_14=yes], |
| [HAS_DW_LANG_C_plus_plus_14=no], |
| [[#include <dwarf.h>]]) |
| if test x$HAS_DW_LANG_C_plus_plus_14 = xyes; then |
| AC_DEFINE([HAVE_DW_LANG_C_plus_plus_14_enumerator], |
| 1, |
| [Define to 1 if dwarf.h has the DW_LANG_C_plus_plus_14 enumerator]) |
| fi |
| |
| HAS_DW_LANG_Mips_Assembler=no |
| AC_CHECK_DECL([DW_LANG_Mips_Assembler], |
| [HAS_DW_LANG_Mips_Assembler=yes], |
| [HAS_DW_LANG_Mips_Assembler=no], |
| [[#include <dwarf.h>]]) |
| if test x$HAS_DW_LANG_Mips_Assembler = xyes; then |
| AC_DEFINE([HAVE_DW_LANG_Mips_Assembler_enumerator], |
| 1, |
| [Define to 1 if dwarf.h has the DW_LANG_Mips_Assembler enumerator]) |
| fi |
| |
| HAS_DW_LANG_Rust=no |
| AC_CHECK_DECL([DW_LANG_Rust], |
| [HAS_DW_LANG_Rust=yes], |
| [HAS_DW_LANG_Rust=no], |
| [[#include <dwarf.h>]]) |
| |
| if test x$HAS_DW_LANG_Rust = xyes; then |
| AC_DEFINE([HAVE_DW_LANG_Rust_enumerator], |
| 1, |
| [Define to 1 if dwarf.h has the DW_LANG_Rust enumerator]) |
| fi |
| |
| HAS_DW_FORM_strx1=no |
| HAS_DW_FORM_strx2=no |
| HAS_DW_FORM_strx3=no |
| HAS_DW_FORM_strx4=no |
| |
| AC_CHECK_DECL([DW_FORM_strx1], |
| [HAS_DW_FORM_strx1=yes], |
| [HAS_DW_FORM_strx1=no], |
| [[#include <dwarf.h>]]) |
| |
| if test x$HAS_DW_FORM_strx1 = xyes; then |
| AC_DEFINE([HAVE_DW_FORM_strx1], |
| 1, |
| [Define to 1 if dwarf.h has the DW_FORM_strx1 enumerator]) |
| fi |
| |
| AC_CHECK_DECL([DW_FORM_strx2], |
| [HAS_DW_FORM_strx2=yes], |
| [HAS_DW_FORM_strx2=no], |
| [[#include <dwarf.h>]]) |
| |
| if test x$HAS_DW_FORM_strx2 = xyes; then |
| AC_DEFINE([HAVE_DW_FORM_strx2], |
| 1, |
| [Define to 1 if dwarf.h has the DW_FORM_strx2 enumerator]) |
| fi |
| |
| AC_CHECK_DECL([DW_FORM_strx3], |
| [HAS_DW_FORM_strx3=yes], |
| [HAS_DW_FORM_strx3=no], |
| [[#include <dwarf.h>]]) |
| |
| if test x$HAS_DW_FORM_strx3 = xyes; then |
| AC_DEFINE([HAVE_DW_FORM_strx3], |
| 1, |
| [Define to 1 if dwarf.h has the DW_FORM_strx3 enumerator]) |
| fi |
| |
| AC_CHECK_DECL([DW_FORM_strx4], |
| [HAS_DW_FORM_strx4=yes], |
| [HAS_DW_FORM_strx4=no], |
| [[#include <dwarf.h>]]) |
| |
| if test x$HAS_DW_FORM_strx4 = xyes; then |
| AC_DEFINE([HAVE_DW_FORM_strx4], |
| 1, |
| [Define to 1 if dwarf.h has the DW_FORM_strx4 enumerator]) |
| fi |
| |
| if test x$HAS_DW_FORM_strx1 = xyes -a \ |
| x$HAS_DW_FORM_strx2 = xyes -a \ |
| x$HAS_DW_FORM_strx3 = xyes -a \ |
| x$HAS_DW_FORM_strx4 = xyes ; then |
| AC_DEFINE([HAVE_DW_FORM_strx], |
| 1, |
| [Define to 1 if dwarf.h has the DW_FORM_strx enumerators]) |
| fi |
| |
| dnl Set large files support |
| AC_SYS_LARGEFILE |
| |
| AC_CONFIG_FILES([Makefile |
| libabigail.pc |
| include/Makefile |
| include/abg-version.h |
| doc/Makefile |
| doc/manuals/Makefile |
| src/Makefile |
| tools/Makefile |
| tests/Makefile |
| tests/data/Makefile |
| bash-completion/Makefile]) |
| |
| dnl Some test scripts are generated by autofoo. |
| AC_CONFIG_FILES([tests/runtestcanonicalizetypes.sh], |
| [chmod +x tests/runtestcanonicalizetypes.sh]) |
| AC_CONFIG_FILES([tests/mockfedabipkgdiff], |
| [chmod +x tests/mockfedabipkgdiff]) |
| AC_CONFIG_FILES([tests/runtestfedabipkgdiff.py], |
| [chmod +x tests/runtestfedabipkgdiff.py]) |
| AC_CONFIG_FILES([tests/runtestfedabipkgdiffpy3.sh], |
| [chmod +x tests/runtestfedabipkgdiffpy3.sh]) |
| AC_CONFIG_FILES([tests/runtestdefaultsupprs.py], |
| [chmod +x tests/runtestdefaultsupprs.py]) |
| AC_CONFIG_FILES([tests/runtestdefaultsupprspy3.sh], |
| [chmod +x tests/runtestdefaultsupprspy3.sh]) |
| |
| AC_OUTPUT |
| |
| AC_MSG_NOTICE([ |
| ===================================================================== |
| Libabigail: $VERSION_MAJOR.$VERSION_MINOR.$VERSION_REVISION$VERSION_SUFFIX |
| ===================================================================== |
| |
| Here is the configuration of the package: |
| |
| Prefix : ${prefix} |
| Source code location : ${srcdir} |
| C Compiler : ${CC} |
| C++ Compiler : ${CXX} |
| GCC visibility attribute supported : ${SUPPORTS_GCC_VISIBILITY_ATTRIBUTE} |
| Python : ${PYTHON} |
| |
| OPTIONAL FEATURES: |
| Enable zip archives : ${ENABLE_ZIP_ARCHIVE} |
| Use a C++-11 compiler : ${ENABLE_CXX11} |
| libdw has the dwarf_getalt function : ${FOUND_DWARF_GETALT_IN_LIBDW} |
| Enable rpm support in abipkgdiff : ${ENABLE_RPM} |
| Enable deb support in abipkgdiff : ${ENABLE_DEB} |
| Enable GNU tar archive support in abipkgdiff : ${ENABLE_TAR} |
| Enable bash completion : ${ENABLE_BASH_COMPLETION} |
| Enable fedabipkgdiff : ${ENABLE_FEDABIPKGDIFF} |
| Enable python 3 : ${ENABLE_PYTHON3} |
| Enable running tests under Valgrind : ${enable_valgrind} |
| Enable build with -fsanitize=address : ${ENABLE_ASAN} |
| Enable build with -fsanitize=memory : ${ENABLE_MSAN} |
| Enable build with -fsanitize=thread : ${ENABLE_TSAN} |
| Enable build with -fsanitize=undefined : ${ENABLE_UBSAN} |
| Generate html apidoc : ${ENABLE_APIDOC} |
| Generate html manual : ${ENABLE_MANUAL} |
| ]) |