661 lines
28 KiB
Plaintext
661 lines
28 KiB
Plaintext
## Process this file with autoconf to produce configure.
|
|
## In general, the safest way to proceed is to run ./autogen.sh
|
|
|
|
# make sure we're interpreted by some minimal autoconf
|
|
AC_PREREQ([2.69])
|
|
|
|
AC_INIT([gperftools],[2.10],[gperftools@googlegroups.com])
|
|
# Update this value for every release! (A:B:C will map to foo.so.(A-C).C.B)
|
|
# http://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html
|
|
TCMALLOC_SO_VERSION=9:10:5
|
|
PROFILER_SO_VERSION=5:5:5
|
|
TCMALLOC_AND_PROFILER_SO_VERSION=10:5:6
|
|
|
|
AC_SUBST(TCMALLOC_SO_VERSION)
|
|
AC_SUBST(PROFILER_SO_VERSION)
|
|
AC_SUBST(TCMALLOC_AND_PROFILER_SO_VERSION)
|
|
|
|
# The argument here is just something that should be in the current directory
|
|
# (for sanity checking)
|
|
AC_CONFIG_SRCDIR(README)
|
|
AC_CONFIG_MACRO_DIR([m4])
|
|
AC_CANONICAL_HOST
|
|
AM_INIT_AUTOMAKE([dist-zip foreign])
|
|
AC_CONFIG_HEADERS([src/config.h])
|
|
|
|
AM_MAINTAINER_MODE()
|
|
# Export the version information (for tc_version and friends)
|
|
TC_VERSION_MAJOR=`expr "$PACKAGE_VERSION" : '\([[0-9]]*\)'`
|
|
TC_VERSION_MINOR=`expr "$PACKAGE_VERSION" : '[[0-9]]*\.\([[0-9]]*\)'`
|
|
TC_VERSION_PATCH=`expr "$PACKAGE_VERSION" : '[[0-9]]*\.[[0-9]]*\(.*\)$'`
|
|
AC_SUBST(TC_VERSION_MAJOR)
|
|
AC_SUBST(TC_VERSION_MINOR)
|
|
AC_SUBST(TC_VERSION_PATCH)
|
|
AC_SUBST(PACKAGE_STRING)
|
|
|
|
# The user can choose not to compile in the heap-profiler, the
|
|
# heap-checker, or the cpu-profiler. There's also the possibility
|
|
# for a 'fully minimal' compile, which leaves out the stacktrace
|
|
# code as well. By default, we include all of these that the
|
|
# target system supports.
|
|
default_enable_cpu_profiler=yes
|
|
default_enable_heap_profiler=yes
|
|
# heap checker is Linux-only.
|
|
default_enable_heap_checker=no
|
|
heap_checker_supported=no
|
|
default_enable_debugalloc=yes
|
|
default_enable_minimal=no
|
|
default_tcmalloc_alignment=16
|
|
heap_checker_is_default=no
|
|
need_nanosleep=yes # Used later, to decide if to run ACX_NANOSLEEP
|
|
case "$host" in
|
|
*-mingw*) default_enable_minimal=yes; default_enable_debugalloc=no;
|
|
need_nanosleep=no;;
|
|
*-cygwin*) default_enable_cpu_profiler=no;;
|
|
*-linux*) default_enable_heap_checker=yes; heap_checker_supported=yes;;
|
|
esac
|
|
|
|
# Currently only backtrace works on s390 and OSX.
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(, [
|
|
#if !defined(__s390__) && !defined(__APPLE__)
|
|
#error not s390 and not osx
|
|
#endif
|
|
return 1
|
|
])],
|
|
[default_enable_libunwind=no
|
|
default_enable_backtrace=yes],
|
|
[default_enable_libunwind=yes
|
|
default_enable_backtrace=no])
|
|
|
|
# Disable libunwind linking on ppc64 by default.
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(, [return __PPC64__])],
|
|
[default_enable_libunwind=no
|
|
default_tcmalloc_pagesize=64],
|
|
[default_enable_libunwind=yes
|
|
default_tcmalloc_pagesize=8])
|
|
|
|
AC_ARG_ENABLE([cpu-profiler],
|
|
[AS_HELP_STRING([--disable-cpu-profiler],
|
|
[do not build the cpu profiler])],
|
|
[],
|
|
[enable_cpu_profiler="$default_enable_cpu_profiler"])
|
|
AC_ARG_ENABLE([heap-profiler],
|
|
[AS_HELP_STRING([--disable-heap-profiler],
|
|
[do not build the heap profiler])],
|
|
[],
|
|
[enable_heap_profiler="$default_enable_heap_profiler"])
|
|
AC_ARG_ENABLE([heap-checker],
|
|
[AS_HELP_STRING([--disable-heap-checker],
|
|
[do not build the heap checker])],
|
|
[],
|
|
[enable_heap_checker="$default_enable_heap_checker"; heap_checker_is_default=yes])
|
|
AC_ARG_ENABLE([debugalloc],
|
|
[AS_HELP_STRING([--disable-debugalloc],
|
|
[do not build versions of libs with debugalloc])],
|
|
[],
|
|
[enable_debugalloc="$default_enable_debugalloc"])
|
|
AC_ARG_ENABLE([minimal],
|
|
[AS_HELP_STRING([--enable-minimal],
|
|
[build only tcmalloc-minimal (and maybe tcmalloc-minimal-debug)])],
|
|
[],
|
|
[enable_minimal="$default_enable_minimal"])
|
|
if test "$enable_minimal" = yes; then
|
|
enable_cpu_profiler=no
|
|
enable_heap_profiler=no
|
|
enable_heap_checker=no
|
|
fi
|
|
AC_ARG_ENABLE([stacktrace-via-backtrace],
|
|
[AS_HELP_STRING([--enable-stacktrace-via-backtrace],
|
|
[enable use of backtrace() for stacktrace capturing (may deadlock)])],
|
|
[enable_backtrace=yes],
|
|
[enable_backtrace="$default_enable_backtrace"])
|
|
AC_ARG_ENABLE([libgcc-unwinder-by-default],
|
|
[AS_HELP_STRING([--enable-libgcc-unwinder-by-default],
|
|
[prefer libgcc's _Unwind_Backtrace as default stacktrace capturing method])],
|
|
[enable_libgcc_by_default=yes],
|
|
[enable_libgcc_by_default=no])
|
|
AS_IF([test "x$enable_libgcc_by_default" = xyes],
|
|
[AC_DEFINE(PREFER_LIBGCC_UNWINDER, 1, [if libgcc stacktrace method should be default])])
|
|
AC_ARG_ENABLE([libunwind],
|
|
[AS_HELP_STRING([--enable-libunwind],
|
|
[enable libunwind linking])],
|
|
[],
|
|
[enable_libunwind="$default_enable_libunwind"])
|
|
AC_ARG_WITH([tcmalloc-pagesize],
|
|
[AS_HELP_STRING([--with-tcmalloc-pagesize],
|
|
[Set the tcmalloc internal page size to 4K, 8K, 16K, 32K, 64K, 128K or 256K])],
|
|
[],
|
|
[with_tcmalloc_pagesize=$default_tcmalloc_pagesize])
|
|
AC_ARG_WITH([tcmalloc-alignment],
|
|
[AS_HELP_STRING([--with-tcmalloc-alignment],
|
|
[Set the tcmalloc allocation alignment to 8 or 16 bytes])],
|
|
[],
|
|
[with_tcmalloc_alignment=$default_tcmalloc_alignment])
|
|
|
|
case "$with_tcmalloc_pagesize" in
|
|
4)
|
|
AC_DEFINE(TCMALLOC_PAGE_SIZE_SHIFT, 12);;
|
|
8)
|
|
#Default tcmalloc page size.
|
|
;;
|
|
16)
|
|
AC_DEFINE(TCMALLOC_PAGE_SIZE_SHIFT, 14);;
|
|
32)
|
|
AC_DEFINE(TCMALLOC_PAGE_SIZE_SHIFT, 15);;
|
|
64)
|
|
AC_DEFINE(TCMALLOC_PAGE_SIZE_SHIFT, 16);;
|
|
128)
|
|
AC_DEFINE(TCMALLOC_PAGE_SIZE_SHIFT, 17);;
|
|
256)
|
|
AC_DEFINE(TCMALLOC_PAGE_SIZE_SHIFT, 18,
|
|
[Define internal page size for tcmalloc as number of left bitshift]);;
|
|
*)
|
|
AC_MSG_WARN([${with_tcmalloc_pagesize}K size not supported, using default tcmalloc page size.])
|
|
esac
|
|
case "$with_tcmalloc_alignment" in
|
|
8)
|
|
AC_DEFINE(TCMALLOC_ALIGN_8BYTES, 1,
|
|
[Define 8 bytes of allocation alignment for tcmalloc]);;
|
|
16)
|
|
#Default tcmalloc allocation alignment.
|
|
;;
|
|
*)
|
|
AC_MSG_WARN([${with_tcmalloc_alignment} bytes not supported, using default tcmalloc allocation alignment.])
|
|
esac
|
|
|
|
AS_IF([test "x$enable_heap_checker" = xyes],
|
|
[AS_IF([test "x$heap_checker_supported" = xno],
|
|
[AC_MSG_NOTICE([your system isn't Linux, and I won't build heap checker despite your request])]
|
|
enable_heap_checker=no)])
|
|
|
|
dnl Heap checker is (and has always been) Linux-only, and also now
|
|
dnl depends on clone support in libc. Most Linux libc's do ship clone()
|
|
dnl (includes glibc, musl and even bionic), but not all. So we check.
|
|
AS_IF([test "x$enable_heap_checker" = xyes],
|
|
[AC_MSG_CHECKING([clone() support])
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
|
|
#ifndef _GNU_SOURCE
|
|
#define _GNU_SOURCE
|
|
#endif
|
|
|
|
#include <sched.h>
|
|
|
|
static int fn(void *dummy) { return 0; }
|
|
|
|
]],[[
|
|
char stk[16];
|
|
return clone(fn, stk, CLONE_VM|CLONE_FS|CLONE_FILES, 0);
|
|
]])], [AC_MSG_RESULT([yes])], [ dnl clone not found
|
|
AC_MSG_RESULT([no])
|
|
enable_heap_checker=no
|
|
AS_IF([test "x$heap_checker_is_default" = xyes],
|
|
[AC_MSG_NOTICE([your Linux system won't have heap checker built due to missing clone() support])],
|
|
[AC_MSG_WARN([you requested heap checker built, but your libc doesn't have clone() support])])
|
|
])])
|
|
|
|
# Checks for programs.
|
|
AC_PROG_CXX
|
|
AC_LANG([C++])
|
|
AM_CONDITIONAL(GCC, test "$GCC" = yes) # let the Makefile know if we're gcc
|
|
|
|
AX_CXX_COMPILE_STDCXX(11, ext, mandatory)
|
|
|
|
# Check if we have an objcopy installed that supports -W
|
|
AC_CHECK_TOOL([OBJCOPY], [objcopy], [])
|
|
AS_IF([test -n "$OBJCOPY"], [dnl
|
|
AC_CACHE_CHECK([if $OBJCOPY supports -W], gpt_cv_objcopy_weaken, [dnl
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([void foo() {}])], [dnl
|
|
AS_IF(["$OBJCOPY" -W foo conftest$ac_exeext /dev/null],
|
|
[gpt_cv_objcopy_weaken=yes], [gpt_cv_objcopy_weaken=no])],
|
|
[gpt_cv_objcopy_weaken=no])])],
|
|
[gpt_cv_objcopy_weaken=no])
|
|
AM_CONDITIONAL(HAVE_OBJCOPY_WEAKEN, test $gpt_cv_objcopy_weaken = yes)
|
|
|
|
LT_INIT
|
|
|
|
# Lets try enable frame pointers to enable simpler stacktrace
|
|
# capturing methods, but keep performace for critical bits with
|
|
# -momit-leaf-frame-pointer. However, we should be conservative so
|
|
# that we don't disable leaf frame pointers on whatever architectures
|
|
# that have them enabled by default.
|
|
AC_CACHE_CHECK(
|
|
[compiler and target supports -fno-omit-frame-pointer -momit-leaf-frame-pointer],
|
|
[ac_cv_frame_pointer_cflags],
|
|
[OLD_CXXFLAGS="$CXXFLAGS"
|
|
CXXFLAGS="$CXXFLAGS -fno-omit-frame-pointer -momit-leaf-frame-pointer"
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
#if !(__i386__ || __x86_64__ || __riscv || __aarch64__)
|
|
#error unsupported arch
|
|
#endif
|
|
)],
|
|
[ac_cv_frame_pointer_cflags=yes],
|
|
[ac_cv_frame_pointer_cflags=no])
|
|
CXXFLAGS="$OLD_CXXFLAGS"])
|
|
AM_CONDITIONAL(ENABLE_FP_FLAGS, [test "x$ac_cv_frame_pointer_cflags" = "xyes"])
|
|
|
|
AX_C___ATTRIBUTE__
|
|
|
|
AC_MSG_CHECKING(for __attribute__((aligned(N))) on functions)
|
|
AC_CACHE_VAL(ac_cv___attribute__aligned_fn, [
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdlib.h>
|
|
void foo(void) __attribute__((aligned(128)));
|
|
void foo(void) { exit(1); }]], [[]])],[ac_cv___attribute__aligned_fn=yes],[ac_cv___attribute__aligned_fn=no
|
|
])])
|
|
if test "$ac_cv___attribute__aligned_fn" = "yes"; then
|
|
AC_DEFINE(HAVE___ATTRIBUTE__ALIGNED_FN, 1, [define if your compiler supports alignment of functions])
|
|
fi
|
|
AC_MSG_RESULT($ac_cv___attribute__aligned_fn)
|
|
|
|
|
|
# TODO(csilvers): we could remove a lot when WITH_CPU_PROFILER etc is "no".
|
|
AC_CHECK_TYPES([struct mallinfo],,, [#include <malloc.h>])
|
|
AC_CHECK_TYPES([Elf32_Versym],,, [#include <elf.h>]) # for vdso_support.h
|
|
AC_CHECK_FUNCS(sbrk) # for tcmalloc to get memory
|
|
AC_CHECK_FUNCS(__sbrk) # for tcmalloc to get memory
|
|
AC_CHECK_FUNCS(geteuid) # for turning off services when run as root
|
|
AC_CHECK_FUNCS(fork) # for the pthread_atfork setup
|
|
AC_CHECK_HEADERS(features.h) # for vdso_support.h, __GLIBC__ macros
|
|
AC_CHECK_HEADERS(malloc.h) # some systems define stuff there, others not
|
|
AC_CHECK_HEADERS(glob.h) # for heap-profile-table (cleaning up profiles)
|
|
AC_CHECK_HEADERS(execinfo.h) # for stacktrace? and heapchecker_unittest
|
|
AC_CHECK_HEADERS(unwind.h) # for stacktrace
|
|
AC_CHECK_HEADERS(sched.h) # for being nice in our spinlock code
|
|
AC_CHECK_HEADERS(sys/syscall.h)
|
|
AC_CHECK_HEADERS(sys/socket.h) # optional; for forking out to symbolizer
|
|
AC_CHECK_HEADERS(sys/wait.h) # optional; for forking out to symbolizer
|
|
AC_CHECK_HEADERS(poll.h) # optional; for forking out to symbolizer
|
|
AC_CHECK_HEADERS(fcntl.h) # for tcmalloc_unittest
|
|
AC_CHECK_HEADERS(grp.h) # for heapchecker_unittest
|
|
AC_CHECK_HEADERS(pwd.h) # for heapchecker_unittest
|
|
AC_CHECK_HEADERS(sys/resource.h) # for memalign_unittest.cc
|
|
AC_CHECK_HEADERS(sys/cdefs.h) # Where glibc defines __THROW
|
|
# We also need <ucontext.h>/<sys/ucontext.h>, but we get those from
|
|
# AC_PC_FROM_UCONTEXT, below.
|
|
|
|
# We override a lot of memory allocation routines, not all of which are
|
|
# standard. For those the system doesn't declare, we'll declare ourselves.
|
|
AC_CHECK_DECLS([cfree,
|
|
posix_memalign,
|
|
memalign,
|
|
valloc,
|
|
pvalloc],,,
|
|
[#define _XOPEN_SOURCE 600
|
|
#include <stdlib.h>
|
|
#include <malloc.h>])
|
|
|
|
if test "$ac_cv_type_struct_mallinfo" = yes; then
|
|
AC_SUBST(ac_cv_have_struct_mallinfo, 1) # gperftools/tcmalloc.h needs this
|
|
else
|
|
AC_SUBST(ac_cv_have_struct_mallinfo, 0)
|
|
fi
|
|
|
|
# We hardcode HAVE_MMAP to 1. There are no interesting systems anymore
|
|
# without functional mmap. And our windows (except mingw) builds
|
|
# aren't using autoconf. So we keep HAVE_MMAP define, but only to
|
|
# distingush windows and rest.
|
|
case "$host" in
|
|
*-mingw*) default_emergency_malloc=no;;
|
|
*) default_emergency_malloc=yes
|
|
AC_DEFINE(HAVE_MMAP, 1, [Define to 1 if you have a working `mmap' system call.])
|
|
esac
|
|
|
|
# We want to access the "PC" (Program Counter) register from a struct
|
|
# ucontext. Every system has its own way of doing that. We try all the
|
|
# possibilities we know about. Note REG_PC should come first (REG_RIP
|
|
# is also defined on solaris, but does the wrong thing). But don't
|
|
# bother if we're not doing cpu-profiling.
|
|
# [*] means that we've not actually tested one of these systems
|
|
if test "$enable_cpu_profiler" = yes; then
|
|
AC_PC_FROM_UCONTEXT(AC_MSG_WARN(Could not find the PC. Will not try to compile libprofiler...);
|
|
enable_cpu_profiler=no)
|
|
fi
|
|
|
|
# Some tests test the behavior of .so files, and only make sense for dynamic.
|
|
AM_CONDITIONAL(ENABLE_STATIC, test "$enable_static" = yes)
|
|
|
|
# We want to link in libunwind if it is enabled and exists.
|
|
UNWIND_LIBS=
|
|
if test "$enable_libunwind" = yes; then
|
|
AC_CHECK_HEADERS([libunwind.h],
|
|
[AC_CHECK_LIB(unwind, backtrace,
|
|
[UNWIND_LIBS=-lunwind
|
|
AC_DEFINE([USE_LIBUNWIND], [1], [libunwind.h was found and is working])
|
|
will_use_libunwind=yes])])
|
|
fi
|
|
AC_SUBST(UNWIND_LIBS)
|
|
|
|
AC_ARG_ENABLE(frame_pointers,
|
|
AS_HELP_STRING([--enable-frame-pointers],
|
|
[Add -fno-omit-frame-pointer to compile flags]),
|
|
, enable_frame_pointers=no)
|
|
AM_CONDITIONAL(ENABLE_FRAME_POINTERS, test "$enable_frame_pointers" = yes)
|
|
|
|
# See if the compiler supports -Wno-unused-result.
|
|
# Newer ubuntu's turn on -D_FORTIFY_SOURCE=2, enabling
|
|
# __attribute__((warn_unused_result)) for things like write(),
|
|
# which we don't care about.
|
|
AC_CACHE_CHECK([if the compiler supports -Wno-unused-result],
|
|
perftools_cv_w_no_unused_result,
|
|
[OLD_CXXFLAGS="$CXXFLAGS"
|
|
CXXFLAGS="$CXXFLAGS -Wno-error -Wunused-result"
|
|
# gcc doesn't warn about unknown flags unless it's
|
|
# also warning for some other purpose, hence the
|
|
# divide-by-0. (We use -Wno-error to make sure the
|
|
# divide-by-0 doesn't cause this test to fail!)
|
|
#
|
|
# Also gcc is giving only warning for unknown flags of
|
|
# -Wno-XXX form. So in order to detect support we're
|
|
# using -Wunused-result which will cause gcc to give
|
|
# error which we can detect.
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(, return 1/0)],
|
|
perftools_cv_w_no_unused_result=yes,
|
|
perftools_cv_w_no_unused_result=no)
|
|
CXXFLAGS="$OLD_CXXFLAGS"])
|
|
AM_CONDITIONAL(HAVE_W_NO_UNUSED_RESULT,
|
|
test "$perftools_cv_w_no_unused_result" = yes)
|
|
|
|
AC_ARG_ENABLE([deprecated-pprof],
|
|
[AS_HELP_STRING([--disable-deprecated-pprof],
|
|
[do not install old deprecated and unmaintained bundled pprof
|
|
(see github.com/google/pprof for supported version)])],
|
|
[enable_pprof="$enableval"],
|
|
[enable_pprof=yes])
|
|
|
|
AM_CONDITIONAL(INSTALL_PPROF,
|
|
[test "x$enable_pprof" = xyes])
|
|
|
|
AC_ARG_ENABLE([dynamic-sized-delete-support],
|
|
[AS_HELP_STRING([--enable-dynamic-sized-delete-support],
|
|
[try to build run-time switch for sized delete operator])],
|
|
[enable_dyn_sized_delete="$enableval"],
|
|
[enable_dyn_sized_delete=no])
|
|
|
|
AS_IF([test "x$enable_dyn_sized_delete" = xyes],
|
|
[AC_DEFINE([ENABLE_DYNAMIC_SIZED_DELETE], 1,
|
|
[Build runtime detection for sized delete])])
|
|
|
|
AC_ARG_ENABLE([sized-delete],
|
|
[AS_HELP_STRING([--enable-sized-delete],
|
|
[build sized delete operator])],
|
|
[enable_sized_delete="$enableval"],
|
|
[enable_sized_delete="no"])
|
|
AS_IF([test "x$enable_sized_delete" = xyes],
|
|
[AC_DEFINE([ENABLE_SIZED_DELETE], 1, [Build sized deletion operators])
|
|
AC_MSG_NOTICE([Will build sized deallocation operators])],
|
|
[AS_IF([test "x$enable_dyn_sized_delete" = xyes],
|
|
[AC_MSG_NOTICE([Will build dynamically detected sized deallocation operators])],
|
|
[AC_MSG_NOTICE([Will build sized deallocation operators that ignore size])])])
|
|
|
|
AC_CACHE_CHECK([if C++ compiler supports -fsized-deallocation],
|
|
[perftools_cv_sized_deallocation_result],
|
|
[OLD_CXXFLAGS="$CXXFLAGS"
|
|
CXXFLAGS="$CXXFLAGS -fsized-deallocation"
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM(
|
|
[[#include <new>
|
|
#include <stddef.h>]],
|
|
[[static void (* volatile ptr)(void *, size_t) = ::operator delete; (*ptr)(0, 256);]])],
|
|
perftools_cv_sized_deallocation_result=yes,
|
|
perftools_cv_sized_deallocation_result=no)
|
|
CXXFLAGS="$OLD_CXXFLAGS"])
|
|
|
|
AM_CONDITIONAL(HAVE_SIZED_DEALLOCATION,
|
|
test "$perftools_cv_sized_deallocation_result" = yes)
|
|
|
|
AC_CACHE_CHECK([if C++ compiler supports std::align_val_t without options],
|
|
[perftools_cv_have_align_val_t],
|
|
[AC_LINK_IFELSE([AC_LANG_PROGRAM(
|
|
[[#include <new>]],
|
|
[[(::operator delete)((::operator new)(256, std::align_val_t(16)), std::align_val_t(16))]])],
|
|
perftools_cv_have_align_val_t=yes,
|
|
perftools_cv_have_align_val_t=no)])
|
|
|
|
AC_CACHE_CHECK([if C++ compiler supports -faligned-new],
|
|
[perftools_cv_have_f_aligned_new],
|
|
[OLD_CXXFLAGS="$CXXFLAGS"
|
|
CXXFLAGS="$CXXFLAGS -faligned-new"
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM(
|
|
[[#include <new>]],
|
|
[[(::operator delete)((::operator new)(256, std::align_val_t(16)), std::align_val_t(16))]])],
|
|
perftools_cv_have_f_aligned_new=yes,
|
|
perftools_cv_have_f_aligned_new=no)
|
|
CXXFLAGS="$OLD_CXXFLAGS"])
|
|
|
|
AM_CONDITIONAL(HAVE_F_ALIGNED_NEW,
|
|
test "$perftools_cv_have_f_aligned_new" = yes)
|
|
|
|
AS_IF([test "$perftools_cv_have_align_val_t" = yes || test "$perftools_cv_have_f_aligned_new" = yes],
|
|
[AC_DEFINE([ENABLE_ALIGNED_NEW_DELETE], 1, [Build new/delete operators for overaligned types])
|
|
AC_MSG_NOTICE([Will build new/delete operators for overaligned types])],
|
|
AC_MSG_NOTICE([Will not build new/delete operators for overaligned types]))
|
|
|
|
if test "$perftools_cv_have_align_val_t" = yes || test "$perftools_cv_have_f_aligned_new" = yes; then
|
|
AC_SUBST(ac_cv_have_std_align_val_t, 1) # gperftools/tcmalloc.h and windows/gperftools/tcmalloc.h need this
|
|
else
|
|
AC_SUBST(ac_cv_have_std_align_val_t, 0)
|
|
fi
|
|
|
|
AC_CACHE_CHECK([if target has _Unwind_Backtrace],
|
|
[perftools_cv_have_unwind_backtrace],
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
|
|
[[#include <unwind.h>
|
|
#if defined(__APPLE__) || defined(__FreeBSD__)
|
|
#error OSX and FreeBSD _Unwind_Backtrace recurses back to malloc
|
|
#endif
|
|
]],
|
|
[[&_Unwind_Backtrace]])],
|
|
[perftools_cv_have_unwind_backtrace=yes],
|
|
[perftools_cv_have_unwind_backtrace=no])])
|
|
AS_IF([test "x$perftools_cv_have_unwind_backtrace" = xyes],
|
|
[AC_DEFINE(HAVE_UNWIND_BACKTRACE, 1, [Whether <unwind.h> contains _Unwind_Backtrace])])
|
|
|
|
AS_IF([test "x$will_use_libunwind" = xyes],
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM(, [return __arm__])],
|
|
[default_emergency_malloc=yes])])
|
|
|
|
AC_ARG_ENABLE([emergency-malloc],
|
|
[AS_HELP_STRING([--enable-emergency-malloc],
|
|
[build emergency malloc feature])],
|
|
[enable_emergency_malloc="$enableval"],
|
|
[enable_emergency_malloc="$default_emergency_malloc"])
|
|
|
|
AM_CONDITIONAL(BUILD_EMERGENCY_MALLOC, [test "x$enable_emergency_malloc" = xyes])
|
|
|
|
# Also make sure we get standard PRI... definitions, even with glibc.
|
|
# We have to use AH_VERBATIM because we need the #ifdef guard (gcc buglet)
|
|
AH_VERBATIM([__STDC_FORMAT_MACROS],
|
|
[/* C99 says: define this to get the PRI... macros from stdint.h */
|
|
#ifndef __STDC_FORMAT_MACROS
|
|
# define __STDC_FORMAT_MACROS 1
|
|
#endif])
|
|
|
|
# Check if __environ is available (for GetenvBeforeMain)
|
|
AC_MSG_CHECKING([for __environ])
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <unistd.h>],
|
|
[char **env = __environ])],
|
|
[AC_DEFINE(HAVE___ENVIRON, 1,
|
|
[Define to 1 if compiler supports __environ])
|
|
AC_MSG_RESULT([yes])],
|
|
[AC_MSG_RESULT([no])])
|
|
|
|
# If we support __thread, that can speed up tcmalloc a bit.
|
|
# Note, however, that our code tickles a bug in gcc < 4.1.2
|
|
# involving TLS and -fPIC (which our libraries will use) on x86:
|
|
# http://gcc.gnu.org/ml/gcc-bugs/2006-09/msg02275.html
|
|
#
|
|
# And mingw also does compile __thread but resultant code actually
|
|
# fails to work correctly at least in some not so ancient version:
|
|
# http://mingw-users.1079350.n2.nabble.com/gcc-4-4-multi-threaded-exception-handling-amp-thread-specifier-not-working-td3440749.html
|
|
#
|
|
# Also it was reported that earlier gcc versions for mips compile
|
|
# __thread but it doesn't really work
|
|
AC_MSG_CHECKING([for __thread])
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([#if defined(__GNUC__) && ((__GNUC__ < 4) || (__GNUC__ == 4 && __GNUC_MINOR__ < 1) || (__GNUC__ == 4 && __GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ < 2))
|
|
#error gcc has this bug: http://gcc.gnu.org/ml/gcc-bugs/2006-09/msg02275.html
|
|
#elif defined(__MINGW32__)
|
|
#error mingw doesnt really support tls
|
|
#elif defined(__APPLE__)
|
|
#error OSX __thread support is known to call malloc which makes it unsafe to use from malloc replacement
|
|
#elif defined(_AIX)
|
|
#error AIX thread support is known to call malloc which makes it unsafe to use from malloc replacement
|
|
#endif
|
|
], [static __thread int p = 0])],
|
|
[AC_DEFINE(HAVE_TLS, 1,
|
|
Define to 1 if compiler supports __thread)
|
|
AC_MSG_RESULT([yes])],
|
|
[AC_MSG_RESULT([no])])
|
|
|
|
# Nanosleep requires extra libraries on some architectures (solaris).
|
|
# This sets NANOSLEEP_LIBS. nanosleep doesn't exist on mingw, which
|
|
# is fine for us because we don't compile libspinlock, which uses it.
|
|
if test "$need_nanosleep" = yes; then
|
|
ACX_NANOSLEEP
|
|
AC_SUBST(NANOSLEEP_LIBS)
|
|
fi
|
|
|
|
# Solaris 10 6/06 has a bug where /usr/sfw/lib/libstdc++.la is empty.
|
|
# If so, we replace it with our own version.
|
|
LIBSTDCXX_LA_LINKER_FLAG=
|
|
if test -f /usr/sfw/lib/libstdc++.la && ! test -s /usr/sfw/lib/libstdc++.la
|
|
then
|
|
LIBSTDCXX_LA_LINKER_FLAG='-L$(top_srcdir)/src/solaris'
|
|
fi
|
|
AC_SUBST(LIBSTDCXX_LA_LINKER_FLAG)
|
|
|
|
# In fact, a lot of the code in this directory depends on pthreads
|
|
AX_PTHREAD
|
|
|
|
# Figure out where libc has program_invocation_name
|
|
AC_PROGRAM_INVOCATION_NAME
|
|
|
|
# Make the install prefix available, to figure out where to look for pprof
|
|
AC_INSTALL_PREFIX
|
|
|
|
dnl only very recent mingw has sleep and nanosleep
|
|
case "$host" in
|
|
*-mingw*)
|
|
AC_CHECK_DECLS([sleep], [], [], [#include <unistd.h>])
|
|
AC_CHECK_DECLS([nanosleep], [], [], [#include <time.h>])
|
|
;;
|
|
esac
|
|
|
|
if test "x$enable_backtrace" = xyes; then
|
|
AC_CHECK_DECLS([backtrace], [], [], [#include <execinfo.h>])
|
|
save_LIBS=$LIBS
|
|
LIBS=$UNWIND_LIBS
|
|
AC_SEARCH_LIBS([backtrace], [execinfo])
|
|
UNWIND_LIBS=$LIBS
|
|
LIBS=$save_LIBS
|
|
fi
|
|
|
|
STACKTRACE_UNITTEST_LIBS=
|
|
AS_IF([test "x$ac_cv_header_execinfo_h" = xyes],
|
|
AS_IF([test "x$enable_cpu_profiler" = xyes -o "x$enable_heap_profiler" = xyes -o "x$enable_heap_checker" = xyes],
|
|
[AC_CHECK_DECLS([backtrace_symbols], [], [], [#include <execinfo.h>
|
|
])
|
|
save_LIBS=$LIBS
|
|
LIBS=
|
|
AC_SEARCH_LIBS([backtrace_symbols], [execinfo])
|
|
STACKTRACE_UNITTEST_LIBS=$LIBS
|
|
LIBS=$save_LIBS]))
|
|
AC_SUBST(STACKTRACE_UNITTEST_LIBS)
|
|
|
|
# For windows, this has a non-trivial value (__declspec(export)), but any
|
|
# system that uses configure wants this to be the empty string.
|
|
AC_DEFINE(PERFTOOLS_DLL_DECL,,
|
|
[Always the empty-string on non-windows systems.
|
|
On windows, should be "__declspec(dllexport)".
|
|
This way, when we compile the dll, we export our functions/classes.
|
|
It's safe to define this here because config.h is only used
|
|
internally, to compile the DLL, and every DLL source file
|
|
#includes "config.h" before anything else.])
|
|
|
|
# In theory, config.h files shouldn't need a header guard, but we do,
|
|
# because we (maybe) #include windows/mingw.h from within config.h,
|
|
# and it #includes other .h files. These all have header guards, so
|
|
# the end result is if config.h is #included twice, its #undefs get
|
|
# evaluated twice, but all the ones in mingw.h/etc only get evaluated
|
|
# once, potentially causing trouble. c.f.
|
|
# https://github.com/gperftools/gperftools/issues/248
|
|
AH_TOP([
|
|
#ifndef GPERFTOOLS_CONFIG_H_
|
|
#define GPERFTOOLS_CONFIG_H_
|
|
])
|
|
|
|
AH_VERBATIM([PTHREADS_CRASHES_IF_RUN_TOO_EARLY],
|
|
[/* Mark the systems where we know it's bad if pthreads runs too
|
|
early before main (before threads are initialized, presumably). */
|
|
#if defined(__FreeBSD__) || defined(_AIX)
|
|
#define PTHREADS_CRASHES_IF_RUN_TOO_EARLY 1
|
|
#endif])
|
|
|
|
# MinGW uses autoconf, but also needs the windows shim routines
|
|
# (since it doesn't have its own support for, say, pthreads).
|
|
# This requires us to #include a special header file, and also to
|
|
# link in some windows versions of .o's instead of the unix versions.
|
|
#
|
|
# Also, manually mark systems where we have to be careful how early
|
|
# we run pthreads. TODO(csilvers): turn this into an autoconf check.
|
|
AH_BOTTOM([
|
|
#ifdef __MINGW32__
|
|
#include "windows/mingw.h"
|
|
#endif
|
|
|
|
#endif /* #ifndef GPERFTOOLS_CONFIG_H_ */
|
|
])
|
|
AM_CONDITIONAL(MINGW, expr $host : '.*-mingw' >/dev/null 2>&1)
|
|
AM_CONDITIONAL(OSX, expr $host : '.*-apple-darwin.*' >/dev/null 2>&1)
|
|
|
|
# Export the --enable flags we set above. We do this at the end so
|
|
# other configure rules can enable or disable targets based on what
|
|
# they find.
|
|
AM_CONDITIONAL(WITH_CPU_PROFILER, test "$enable_cpu_profiler" = yes)
|
|
AM_CONDITIONAL(WITH_HEAP_PROFILER, test "$enable_heap_profiler" = yes)
|
|
AM_CONDITIONAL(WITH_HEAP_CHECKER, test "$enable_heap_checker" = yes)
|
|
AM_CONDITIONAL(WITH_DEBUGALLOC, test "$enable_debugalloc" = yes)
|
|
# We make tcmalloc.so if either heap-profiler or heap-checker is asked for.
|
|
AM_CONDITIONAL(WITH_HEAP_PROFILER_OR_CHECKER,
|
|
test "$enable_heap_profiler" = yes -o \
|
|
"$enable_heap_checker" = yes)
|
|
# If we don't use any profilers, we don't need stack traces (or pprof)
|
|
AM_CONDITIONAL(WITH_STACK_TRACE, test "$enable_cpu_profiler" = yes -o \
|
|
"$enable_heap_profiler" = yes -o \
|
|
"$enable_heap_checker" = yes)
|
|
|
|
have_linux_sigev_thread_id=no
|
|
AC_MSG_CHECKING([for Linux SIGEV_THREAD_ID])
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM([[#include <signal.h>
|
|
#include <time.h>]],
|
|
[[return SIGEV_THREAD_ID || CLOCK_THREAD_CPUTIME_ID || __linux;]])],
|
|
[AC_DEFINE(HAVE_LINUX_SIGEV_THREAD_ID, 1,
|
|
[Define if this is Linux that has SIGEV_THREAD_ID])
|
|
have_linux_sigev_thread_id=yes
|
|
AC_MSG_RESULT([yes])],
|
|
[AC_MSG_RESULT([no])])
|
|
|
|
# Disable large allocation report by default.
|
|
AC_ARG_ENABLE([large-alloc-report],
|
|
[AS_HELP_STRING([--enable-large-alloc-report],
|
|
[report very large allocations to stderr])],
|
|
[enable_large_alloc_report="$enableval"],
|
|
[enable_large_alloc_report=no])
|
|
AS_IF([test "x$enable_large_alloc_report" = xyes],
|
|
[AC_DEFINE([ENABLE_LARGE_ALLOC_REPORT], 1, [report large allocation])])
|
|
|
|
# Enable aggressive decommit by default
|
|
AC_ARG_ENABLE([aggressive-decommit-by-default],
|
|
[AS_HELP_STRING([--enable-aggressive-decommit-by-default],
|
|
[enable aggressive decommit by default])],
|
|
[enable_aggressive_decommit_by_default="$enableval"],
|
|
[enable_aggressive_decommit_by_default=no])
|
|
AS_IF([test "x$enable_aggressive_decommit_by_default" = xyes],
|
|
[AC_DEFINE([ENABLE_AGGRESSIVE_DECOMMIT_BY_DEFAULT],
|
|
1,
|
|
[enable aggressive decommit by default])])
|
|
|
|
# Write generated configuration file
|
|
AC_CONFIG_FILES([Makefile
|
|
src/gperftools/tcmalloc.h src/windows/gperftools/tcmalloc.h])
|
|
AC_OUTPUT
|