src/third_party/tcmalloc/vendor/Makefile.am

   1 ## Process this file with automake to produce Makefile.in
   2
   3 # Note: for every library we create, we're explicit about what symbols
   4 # we export.  In order to avoid complications with C++ mangling, we always
   5 # use the regexp for of specifying symbols.
   6
   7 # Make sure that when we re-make ./configure, we get the macros we need
   8 ACLOCAL_AMFLAGS = -I m4
   9
  10 # This is so we can #include <gperftools/foo>
  11 AM_CPPFLAGS = -I$(top_srcdir)/src
  12
  13 if !WITH_STACK_TRACE
  14 AM_CPPFLAGS += -DNO_TCMALLOC_SAMPLES
  15 endif !WITH_STACK_TRACE
  16
  17 # This is mostly based on configure options
  18 AM_CXXFLAGS =
  19
  20 # These are good warnings to turn on by default.  We also tell gcc
  21 # that malloc, free, realloc, mmap, etc. are not builtins (these flags
  22 # are supported since gcc 3.1.1).  gcc doesn't think most of them are
  23 # builtins now in any case, but it's best to be explicit in case that
  24 # changes one day.  gcc ignores functions it doesn't understand.
  25 if GCC
  26 AM_CXXFLAGS += -Wall -Wwrite-strings -Woverloaded-virtual \
  27                -Wno-sign-compare \
  28                -fno-builtin-malloc -fno-builtin-free -fno-builtin-realloc \
  29                -fno-builtin-calloc -fno-builtin-cfree \
  30                -fno-builtin-memalign -fno-builtin-posix_memalign \
  31                -fno-builtin-valloc -fno-builtin-pvalloc
  32 # On i386, -mmmx is needed for the mmx-based instructions in
  33 # atomicops-internal-x86.h.
  34 if I386
  35 AM_CXXFLAGS += -mmmx
  36 endif I386
  37 endif GCC
  38 if HAVE_W_NO_UNUSED_RESULT
  39 AM_CXXFLAGS += -Wno-unused-result
  40 endif HAVE_W_NO_UNUSED_RESULT
  41
  42 # The -no-undefined flag allows libtool to generate shared libraries for
  43 # Cygwin and MinGW.  LIBSTDCXX_LA_LINKER_FLAG is used to fix a Solaris bug.
  44 AM_LDFLAGS = -no-undefined $(LIBSTDCXX_LA_LINKER_FLAG)
  45
  46 # We know our low-level code cannot trigger an exception.  On some
  47 # systems, such as cygwin, it would be disastrous if they did, because
  48 # the exception handler might call malloc!  If our low-level routines
  49 # raised an exception within the malloc, they'd deadlock.  Luckily,
  50 # we control all this code, and do not need exceptions for it.
  51 if GCC
  52 NO_EXCEPTIONS = -fno-exceptions
  53 else !GCC
  54 NO_EXCEPTIONS =
  55 endif !GCC
  56
  57 # These are x86-specific, having to do with frame-pointers.  In
  58 # particular, some x86_64 systems do not insert frame pointers by
  59 # default (all i386 systems that I know of, do.  I don't know about
  60 # non-x86 chips).  We need to tell perftools what to do about that.
  61 if X86_64_AND_NO_FP_BY_DEFAULT
  62 if ENABLE_FRAME_POINTERS
  63 AM_CXXFLAGS += -fno-omit-frame-pointer
  64 else
  65   # TODO(csilvers): check if -fomit-frame-pointer might be in $(CXXFLAGS),
  66   #                 before setting this.
  67 AM_CXXFLAGS += -DNO_FRAME_POINTER
  68 endif !ENABLE_FRAME_POINTERS
  69 endif X86_64_AND_NO_FP_BY_DEFAULT
  70
  71 # For windows systems (at least, mingw), we need to tell all our
  72 # tests to link in libtcmalloc using -u.  This is because libtcmalloc
  73 # accomplishes its tasks via patching, leaving no work for the linker
  74 # to identify, so the linker will ignore libtcmalloc by default unless
  75 # we explicitly create a dependency via -u.
  76 TCMALLOC_FLAGS =
  77 if MINGW
  78 TCMALLOC_FLAGS += -Wl,-u__tcmalloc
  79 endif MINGW
  80
  81 # If we have objcopy, make malloc/free/etc weak symbols.  That way folks
  82 # can override our malloc if they want to (they can still use tc_malloc).
  83 # Note: the weird-looking symbols are the c++ memory functions:
  84 # (in order) new, new(nothrow), new[], new[](nothrow), delete, delete[]
  85 # In theory this will break if mangling changes, but that seems pretty
  86 # unlikely at this point.  Just in case, I throw in versions with an
  87 # extra underscore as well, which may help on OS X.
  88 if HAVE_OBJCOPY_WEAKEN
  89 WEAKEN = $(OBJCOPY) -W malloc -W free -W realloc -W calloc -W cfree \
  90          -W memalign -W posix_memalign -W valloc -W pvalloc \
  91          -W malloc_stats -W mallopt -W mallinfo \
  92          -W _Znwm -W _ZnwmRKSt9nothrow_t -W _Znam -W _ZnamRKSt9nothrow_t \
  93          -W _ZdlPv -W _ZdaPv \
  94          -W __Znwm -W __ZnwmRKSt9nothrow_t -W __Znam -W __ZnamRKSt9nothrow_t \
  95          -W __ZdlPv -W __ZdaPv
  96 else
  97 WEAKEN = :
  98 endif !HAVE_OBJCOPY_WEAKEN
  99
 100 LIBS_TO_WEAKEN =
 101
 102 perftoolsincludedir = $(includedir)/gperftools
 103 # The .h files you want to install (that is, .h files that people
 104 # who install this package can include in their own applications.)
 105 # We'll add to this later, on a library-by-library basis
 106 perftoolsinclude_HEADERS =
 107 # tcmalloc.h is a special case, because it's a .h.in file
 108 nodist_perftoolsinclude_HEADERS = src/gperftools/tcmalloc.h
 109 noinst_HEADERS = src/gperftools/tcmalloc.h.in
 110
 111 # This is provided for backwards compatibility.  It is populated by
 112 # files that just forward to the canonical location in
 113 # perftoolsincludedir.
 114 googleincludedir = $(includedir)/google
 115 googleinclude_HEADERS =                         \
 116    src/google/heap-checker.h                    \
 117    src/google/heap-profiler.h                   \
 118    src/google/malloc_extension.h                \
 119    src/google/malloc_extension_c.h              \
 120    src/google/malloc_hook.h                     \
 121    src/google/malloc_hook_c.h                   \
 122    src/google/profiler.h                        \
 123    src/google/stacktrace.h                      \
 124    src/google/tcmalloc.h                        \
 125    src/windows/google/tcmalloc.h
 126
 127 docdir = $(prefix)/share/doc/$(PACKAGE)-$(VERSION)
 128 # This is for HTML and other documentation you want to install.
 129 # Add your documentation files (in doc/) in addition to these
 130 # top-level boilerplate files.  Also add a TODO file if you have one.
 131 # We'll add to this later, on a library-by-library basis
 132 dist_doc_DATA = AUTHORS COPYING ChangeLog INSTALL NEWS README README_windows.txt \
 133                 TODO
 134
 135 # The libraries (.so's) you want to install
 136 # We'll add to this later, on a library-by-library basis
 137 lib_LTLIBRARIES =
 138 # This is for 'convenience libraries' -- basically just a container for sources
 139 noinst_LTLIBRARIES =
 140 ## The location of the windows project file for each binary we make
 141 WINDOWS_PROJECTS = gperftools.sln
 142
 143 # unittests you want to run when people type 'make check'.
 144 # Note: tests cannot take any arguments!
 145 # In theory, unittests that are scripts should be added to check_SCRIPTS
 146 # instead.  But check_SCRIPTS is definitely a second-class testing mechanims:
 147 # it don't get TESTS_ENVIRONMENT, and it doesn't get success/failure counting
 148 # (in fact, a script failure aborts all the rest of the tests, even with -k).
 149 # So, for scripts, we add the script to tests, and also put in an empty
 150 # rule so automake doesn't try to build the script as a C binary.
 151 TESTS =
 152 # TESTS_ENVIRONMENT sets environment variables for when you run unittest.
 153 # We always get "srcdir" set for free.
 154 # We'll add to this later, on a library-by-library basis.
 155 TESTS_ENVIRONMENT =
 156 # All script tests should be added here
 157 noinst_SCRIPTS =
 158 # If your test calls another program that, like the test itself, shouldn't
 159 # be installed, add it here.  (Stuff in TESTS is automatically added later).
 160 noinst_PROGRAMS =
 161
 162 # Binaries we might build that should be installed
 163 bin_PROGRAMS =
 164
 165 # This is my own var, used for extra libraries I make that I need installed
 166 EXTRA_INSTALL =
 167
 168 ## vvvv RULES TO MAKE THE LIBRARIES, BINARIES, AND UNITTESTS
 169
 170 dist_doc_DATA += doc/index.html doc/designstyle.css
 171
 172
 173 ### ------- library routines, in src/base
 174
 175 # This is a 'convenience library' -- it's not actually installed or anything
 176 LOGGING_INCLUDES = src/base/logging.h \
 177                    src/base/commandlineflags.h \
 178                    src/base/basictypes.h \
 179                    src/base/dynamic_annotations.h \
 180                    src/third_party/valgrind.h
 181 noinst_LTLIBRARIES += liblogging.la
 182 liblogging_la_SOURCES = src/base/logging.cc \
 183                         src/base/dynamic_annotations.c \
 184                         $(LOGGING_INCLUDES)
 185
 186 SYSINFO_INCLUDES = src/base/sysinfo.h \
 187                    src/base/logging.h \
 188                    src/base/commandlineflags.h \
 189                    src/base/cycleclock.h \
 190                    src/base/arm_instruction_set_select.h \
 191                    src/base/basictypes.h
 192 noinst_LTLIBRARIES += libsysinfo.la
 193 libsysinfo_la_SOURCES = src/base/sysinfo.cc \
 194                         $(SYSINFO_INCLUDES)
 195 libsysinfo_la_LIBADD = $(NANOSLEEP_LIBS)
 196
 197 # For MinGW, we use also have to use libwindows Luckily, we need the
 198 # windows.a library in exactly the same place we need spinlock.a
 199 # (pretty much everywhere), so we can use the same variable name for
 200 # each.  We can also optimize the MinGW rule a bit by leaving out
 201 # files we know aren't used on windows, such as
 202 # atomicops-internals-x86.cc.  libwindows also obsoletes the need for
 203 # other files like system_alloc.cc.
 204 if MINGW
 205 WINDOWS_INCLUDES = src/windows/port.h \
 206                    src/windows/mingw.h \
 207                    src/windows/mini_disassembler.h \
 208                    src/windows/mini_disassembler_types.h \
 209                    src/windows/preamble_patcher.h
 210 noinst_LTLIBRARIES += libwindows.la
 211 libwindows_la_SOURCES = $(WINDOWS_INCLUDES) \
 212                         src/windows/port.cc \
 213                         src/windows/ia32_modrm_map.cc \
 214                         src/windows/ia32_opcode_map.cc \
 215                         src/windows/mini_disassembler.cc \
 216                         src/windows/patch_functions.cc \
 217                         src/windows/preamble_patcher.cc \
 218                         src/windows/preamble_patcher_with_stub.cc
 219 # patch_functions.cc uses Psapi.lib.  MSVC has a #pragma for that, but not us.
 220 libwindows_la_LIBADD = -lPsapi
 221
 222 SPINLOCK_INCLUDES = src/base/spinlock.h \
 223                     src/base/spinlock_internal.h \
 224                     src/base/spinlock_win32-inl.h \
 225                     src/base/spinlock_linux-inl.h \
 226                     src/base/spinlock_posix-inl.h \
 227                     src/base/synchronization_profiling.h \
 228                     src/base/atomicops-internals-macosx.h \
 229                     src/base/atomicops-internals-linuxppc.h \
 230                     src/base/atomicops-internals-arm-generic.h \
 231                     src/base/atomicops-internals-arm-v6plus.h \
 232                     src/base/atomicops-internals-windows.h \
 233                     src/base/atomicops-internals-x86.h
 234 noinst_LTLIBRARIES += libspinlock.la
 235 libspinlock_la_SOURCES = src/base/spinlock.cc \
 236                          src/base/spinlock_internal.cc \
 237                          $(SPINLOCK_INCLUDES)
 238
 239 LIBSPINLOCK = libwindows.la libspinlock.la libsysinfo.la liblogging.la
 240
 241 # We also need to tell mingw that sysinfo.cc needs shlwapi.lib.
 242 # (We do this via a #pragma for msvc, but need to do it here for mingw).
 243 libsysinfo_la_LIBADD += -lshlwapi
 244
 245 # There's a windows-specific unittest we can run.  Right now it's
 246 # win64-specific, and relies on masm, so we comment it out.
 247 ## TESTS += preamble_patcher_test
 248 ## preamble_patcher_test_SOURCES = src/windows/preamble_patcher_test.cc \
 249 ##                                 src/windows/shortproc.asm \
 250 ##                                 src/windows/auto_testing_hook.h \
 251 ##                                 src/windows/preamble_patcher.h \
 252 ##                                 src/base/basictypes.h \
 253 ##                                 src/base/logging.h
 254 ## preamble_patcher_test_LDFLAGS = $(TCMALLOC_FLAGS)
 255 ## preamble_patcher_test_LDADD = $(LIBTCMALLOC_MINIMAL)
 256
 257 # patch_functions.cc #includes tcmalloc.cc, so no need to link it in.
 258 TCMALLOC_CC =
 259 # windows has its own system for threads and system memory allocation.
 260 MAYBE_THREADS_CC =
 261 SYSTEM_ALLOC_CC =
 262 else !MINGW
 263 # spinlock is the only code that uses atomicops.
 264 SPINLOCK_INCLUDES = src/base/spinlock.h \
 265                     src/base/spinlock_internal.h \
 266                     src/base/atomicops.h \
 267                     src/base/atomicops-internals-macosx.h \
 268                     src/base/atomicops-internals-linuxppc.h \
 269                     src/base/atomicops-internals-windows.h \
 270                     src/base/atomicops-internals-x86.h
 271
 272 noinst_LTLIBRARIES += libspinlock.la
 273 libspinlock_la_SOURCES = src/base/spinlock.cc \
 274                          src/base/spinlock_internal.cc \
 275                          src/base/atomicops-internals-x86.cc \
 276                          $(SPINLOCK_INCLUDES)
 277 libspinlock_la_LIBADD = $(NANOSLEEP_LIBS)
 278 # spinlock also needs NumCPUs, from libsysinfo, which in turn needs liblogging
 279 LIBSPINLOCK = libspinlock.la libsysinfo.la liblogging.la
 280
 281 TCMALLOC_CC = src/tcmalloc.cc
 282 MAYBE_THREADS_CC = src/maybe_threads.cc
 283 SYSTEM_ALLOC_CC = src/system-alloc.cc
 284 endif !MINGW
 285
 286 # Add this whether or not we're under MinGW, to keep the tarball complete.
 287 WINDOWS_PROJECTS += vsprojects/preamble_patcher_test/preamble_patcher_test.vcproj
 288 # Because we've commented out the test, above, we have to explicitly add
 289 # the test files to the tarball or automake will leave them out.
 290 WINDOWS_PROJECTS += src/windows/preamble_patcher_test.cc \
 291                     src/windows/shortproc.asm \
 292                     src/windows/auto_testing_hook.h
 293
 294 ### Unittests
 295 TESTS += low_level_alloc_unittest
 296 WINDOWS_PROJECTS += vsprojects/low_level_alloc_unittest/low_level_alloc_unittest.vcproj
 297 LOW_LEVEL_ALLOC_UNITTEST_INCLUDES = src/base/low_level_alloc.h \
 298                                     src/base/basictypes.h \
 299                                     src/gperftools/malloc_hook.h \
 300                                     src/gperftools/malloc_hook_c.h \
 301                                     src/malloc_hook-inl.h \
 302                                     src/malloc_hook_mmap_linux.h \
 303                                     src/malloc_hook_mmap_freebsd.h \
 304                                     $(SPINLOCK_INCLUDES) \
 305                                     $(LOGGING_INCLUDES)
 306 low_level_alloc_unittest_SOURCES = src/base/low_level_alloc.cc \
 307                                    src/malloc_hook.cc \
 308                                    $(MAYBE_THREADS_CC) \
 309                                    src/tests/low_level_alloc_unittest.cc \
 310                                    $(LOW_LEVEL_ALLOC_UNITTEST_INCLUDES)
 311 # By default, MallocHook takes stack traces for use by the heap-checker.
 312 # We don't need that functionality here, so we turn it off to reduce deps.
 313 low_level_alloc_unittest_CXXFLAGS = -DNO_TCMALLOC_SAMPLES
 314 low_level_alloc_unittest_LDADD = $(LIBSPINLOCK)
 315
 316 TESTS += atomicops_unittest
 317 ATOMICOPS_UNITTEST_INCLUDES = src/base/atomicops.h \
 318                               src/base/atomicops-internals-macosx.h \
 319                               src/base/atomicops-internals-windows.h \
 320                               src/base/atomicops-internals-x86.h \
 321                               $(LOGGING_INCLUDES)
 322 atomicops_unittest_SOURCES = src/tests/atomicops_unittest.cc \
 323                              $(ATOMICOPS_UNITTEST_INCLUDES)
 324 atomicops_unittest_LDADD = $(LIBSPINLOCK)
 325
 326
 327 ### ------- stack trace
 328
 329 if WITH_STACK_TRACE
 330
 331 ### The header files we use.  We divide into categories based on directory
 332 S_STACKTRACE_INCLUDES = src/stacktrace_config.h \
 333                         src/stacktrace_generic-inl.h \
 334                         src/stacktrace_libunwind-inl.h \
 335                         src/stacktrace_arm-inl.h \
 336                         src/stacktrace_powerpc-inl.h \
 337                         src/stacktrace_x86-inl.h \
 338                         src/stacktrace_win32-inl.h \
 339                         src/base/elf_mem_image.h \
 340                         src/base/vdso_support.h
 341
 342 SG_STACKTRACE_INCLUDES = src/gperftools/stacktrace.h
 343 STACKTRACE_INCLUDES = $(S_STACKTRACE_INCLUDES) $(SG_STACKTRACE_INCLUDES)
 344 perftoolsinclude_HEADERS += $(SG_STACKTRACE_INCLUDES)
 345
 346 ### Making the library
 347 noinst_LTLIBRARIES += libstacktrace.la
 348 libstacktrace_la_SOURCES = src/stacktrace.cc \
 349                            src/base/elf_mem_image.cc \
 350                            src/base/vdso_support.cc \
 351                            $(STACKTRACE_INCLUDES)
 352 libstacktrace_la_LIBADD = $(UNWIND_LIBS) $(LIBSPINLOCK)
 353 STACKTRACE_SYMBOLS = '(GetStackTrace|GetStackFrames|GetStackTraceWithContext|GetStackFramesWithContext)'
 354 libstacktrace_la_LDFLAGS = -export-symbols-regex $(STACKTRACE_SYMBOLS)
 355
 356 ### Unittests
 357 TESTS += stacktrace_unittest
 358 STACKTRACE_UNITTEST_INCLUDES = src/config_for_unittests.h \
 359                                src/base/commandlineflags.h \
 360                                $(STACKTRACE_INCLUDES) \
 361                                $(LOGGING_INCLUDES)
 362 stacktrace_unittest_SOURCES = src/tests/stacktrace_unittest.cc \
 363                               $(STACKTRACE_UNITTEST_INCLUDES)
 364 stacktrace_unittest_LDADD = libstacktrace.la liblogging.la
 365
 366 ### Documentation
 367 dist_doc_DATA +=
 368
 369 endif WITH_STACK_TRACE
 370
 371 ### ------- pprof
 372
 373 # If we are not compiling with stacktrace support, pprof is worthless
 374 if WITH_STACK_TRACE
 375
 376 bin_SCRIPTS = src/pprof
 377
 378 ### Unittests
 379
 380 check_SCRIPTS = pprof_unittest
 381 pprof_unittest: $(top_srcdir)/src/pprof
 382         $(top_srcdir)/src/pprof -test
 383
 384 # Let unittests find pprof if they need to run it
 385 TESTS_ENVIRONMENT += PPROF_PATH=$(top_srcdir)/src/pprof
 386
 387 ### Documentation
 388 dist_man_MANS = doc/pprof.1
 389 dist_doc_DATA += doc/pprof_remote_servers.html
 390
 391 # On MSVC, we need our own versions of addr2line and nm to work with pprof.
 392 WINDOWS_PROJECTS += vsprojects/nm-pdb/nm-pdb.vcproj
 393 WINDOWS_PROJECTS += vsprojects/addr2line-pdb/addr2line-pdb.vcproj
 394 # This is a slight abuse of WINDOWS_PROJECTS, but not much
 395 WINDOWS_PROJECTS += src/windows/nm-pdb.c \
 396                     src/windows/addr2line-pdb.c
 397
 398 endif WITH_STACK_TRACE
 399
 400 ### ------- tcmalloc_minimal (thread-caching malloc)
 401
 402 ### The header files we use.  We divide into categories based on directory
 403 S_TCMALLOC_MINIMAL_INCLUDES = src/common.h \
 404                               src/internal_logging.h \
 405                               src/system-alloc.h \
 406                               src/packed-cache-inl.h \
 407                               $(SPINLOCK_INCLUDES) \
 408                               src/tcmalloc_guard.h \
 409                               src/base/commandlineflags.h \
 410                               src/base/basictypes.h \
 411                               src/pagemap.h \
 412                               src/sampler.h \
 413                               src/central_freelist.h \
 414                               src/linked_list.h \
 415                               src/libc_override.h \
 416                               src/libc_override_gcc_and_weak.h \
 417                               src/libc_override_glibc.h \
 418                               src/libc_override_osx.h \
 419                               src/libc_override_redefine.h \
 420                               src/page_heap.h \
 421                               src/page_heap_allocator.h \
 422                               src/span.h \
 423                               src/static_vars.h \
 424                               src/symbolize.h \
 425                               src/thread_cache.h \
 426                               src/stack_trace_table.h \
 427                               src/base/thread_annotations.h \
 428                               src/malloc_hook-inl.h \
 429                               src/malloc_hook_mmap_linux.h \
 430                               src/malloc_hook_mmap_freebsd.h \
 431                               src/maybe_threads.h
 432 SG_TCMALLOC_MINIMAL_INCLUDES = src/gperftools/malloc_hook.h \
 433                                src/gperftools/malloc_hook_c.h \
 434                                src/gperftools/malloc_extension.h \
 435                                src/gperftools/malloc_extension_c.h \
 436                                src/gperftools/stacktrace.h
 437 TCMALLOC_MINIMAL_INCLUDES = $(S_TCMALLOC_MINIMAL_INCLUDES) $(SG_TCMALLOC_MINIMAL_INCLUDES)
 438 perftoolsinclude_HEADERS += $(SG_TCMALLOC_MINIMAL_INCLUDES)
 439
 440 ### Making the library
 441
 442 # As we describe at the top of this file, we want to turn off exceptions
 443 # for all files in this library -- except tcmalloc.cc which needs them
 444 # to fulfill its API.  Automake doesn't allow per-file CXXFLAGS, so we need
 445 # to separate into two libraries.
 446 noinst_LTLIBRARIES += libtcmalloc_minimal_internal.la
 447 libtcmalloc_minimal_internal_la_SOURCES = src/common.cc \
 448                                           src/internal_logging.cc \
 449                                           $(SYSTEM_ALLOC_CC) \
 450                                           src/memfs_malloc.cc \
 451                                           src/central_freelist.cc \
 452                                           src/page_heap.cc \
 453                                           src/sampler.cc \
 454                                           src/span.cc \
 455                                           src/stack_trace_table.cc \
 456                                           src/static_vars.cc \
 457                                           src/symbolize.cc \
 458                                           src/thread_cache.cc \
 459                                           src/malloc_hook.cc \
 460                                           src/malloc_extension.cc \
 461                                           $(MAYBE_THREADS_CC) \
 462                                           $(TCMALLOC_MINIMAL_INCLUDES)
 463 # We #define NO_TCMALLOC_SAMPLES, since sampling is turned off for _minimal.
 464 libtcmalloc_minimal_internal_la_CXXFLAGS = -DNO_TCMALLOC_SAMPLES \
 465                                            -DNO_HEAP_CHECK \
 466                                            $(PTHREAD_CFLAGS) -DNDEBUG \
 467                                            $(AM_CXXFLAGS) $(NO_EXCEPTIONS)
 468 libtcmalloc_minimal_internal_la_LDFLAGS = $(PTHREAD_CFLAGS)
 469 libtcmalloc_minimal_internal_la_LIBADD = $(PTHREAD_LIBS) $(LIBSPINLOCK)
 470
 471 lib_LTLIBRARIES += libtcmalloc_minimal.la
 472 WINDOWS_PROJECTS += vsprojects/libtcmalloc_minimal/libtcmalloc_minimal.vcproj
 473 libtcmalloc_minimal_la_SOURCES = $(TCMALLOC_CC) $(TCMALLOC_MINIMAL_INCLUDES)
 474 libtcmalloc_minimal_la_CXXFLAGS = -DNO_TCMALLOC_SAMPLES \
 475                                   $(PTHREAD_CFLAGS) -DNDEBUG $(AM_CXXFLAGS)
 476 # -version-info gets passed to libtool
 477 libtcmalloc_minimal_la_LDFLAGS = $(PTHREAD_CFLAGS) -version-info @TCMALLOC_SO_VERSION@
 478 libtcmalloc_minimal_la_LIBADD = libtcmalloc_minimal_internal.la $(PTHREAD_LIBS)
 479
 480 # For windows, we're playing around with trying to do some stacktrace
 481 # support even with libtcmalloc_minimal.  For everyone else, though,
 482 # we turn off all stack-trace activity for libtcmalloc_minimal.
 483 # TODO(csilvers): when we're done experimenting, do something principled here
 484 if MINGW
 485 LIBTCMALLOC_MINIMAL = libtcmalloc_minimal.la libstacktrace.la
 486 else !MINGW
 487 LIBTCMALLOC_MINIMAL = libtcmalloc_minimal.la
 488 endif !MINGW
 489
 490 LIBS_TO_WEAKEN += libtcmalloc_minimal.la
 491
 492 ### Unittests
 493
 494 # Commented out for the moment because malloc(very_big_num) is broken in
 495 # standard libc!  At least, in some situations, some of the time.
 496 ## TESTS += malloc_unittest
 497 ## MALLOC_UNITEST_INCLUDES = src/gperftools/malloc_extension.h \
 498 ##                           src/gperftools/malloc_hook.h \
 499 ##                           src/gperftools/malloc_hook_c.h \
 500 ##                           src/malloc_hook-inl.h \
 501 ##                           src/malloc_hook_mmap_linux.h \
 502 ##                           src/malloc_hook_mmap_freebsd.h \
 503 ##                           src/base/basictypes.h \
 504 ##                           src/maybe_threads.h
 505 ## malloc_unittest_SOURCES = src/tests/tcmalloc_unittest.cc \
 506 ##                           src/malloc_hook.cc \
 507 ##                           src/malloc_extension.cc \
 508 ##                           $(MAYBE_THREADS_CC) \
 509 ##                           $(MALLOC_UNITTEST_INCLUDES)
 510 ## malloc_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 511 ## malloc_unittest_LDFLAGS = $(PTHREAD_CFLAGS)
 512 ## malloc_unittest_LDADD = $(PTHREAD_LIBS)
 513
 514 TESTS += tcmalloc_minimal_unittest
 515 WINDOWS_PROJECTS += vsprojects/tcmalloc_minimal_unittest/tcmalloc_minimal_unittest.vcproj
 516 WINDOWS_PROJECTS += vsprojects/tmu-static/tmu-static.vcproj
 517 tcmalloc_minimal_unittest_SOURCES = src/tests/tcmalloc_unittest.cc \
 518                                     src/tests/testutil.h src/tests/testutil.cc \
 519                                     $(TCMALLOC_UNITTEST_INCLUDES)
 520 tcmalloc_minimal_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 521 tcmalloc_minimal_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 522 # We want libtcmalloc last on the link line, but due to a bug in
 523 # libtool involving convenience libs, they need to come last on the
 524 # link line in order to get dependency ordering right.  This is ok:
 525 # convenience libraries are .a's, so tcmalloc is still the last .so.
 526 # We also put pthreads after tcmalloc, because some pthread
 527 # implementations define their own malloc, and we need to go on the
 528 # first linkline to make sure our malloc 'wins'.
 529 tcmalloc_minimal_unittest_LDADD = $(LIBTCMALLOC_MINIMAL) \
 530                                   liblogging.la $(PTHREAD_LIBS)
 531
 532 TESTS += tcmalloc_minimal_large_unittest
 533 WINDOWS_PROJECTS += vsprojects/tcmalloc_minimal_large/tcmalloc_minimal_large_unittest.vcproj
 534 tcmalloc_minimal_large_unittest_SOURCES = src/tests/tcmalloc_large_unittest.cc
 535 tcmalloc_minimal_large_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 536 tcmalloc_minimal_large_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 537 tcmalloc_minimal_large_unittest_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
 538
 539 # This tests it works to LD_PRELOAD libtcmalloc (tests maybe_threads.cc)
 540 # In theory this should work under mingw, but mingw has trouble running
 541 # shell scripts that end in .exe.  And it doesn't seem to build shared
 542 # libraries anyway (so can't be LD_PRELOADed) -- in fact, anybody who
 543 # chooses not to build shared libraries won't be able to run this test.
 544 # TODO(csilvers): figure out how to nix ".exe" or otherwise work under mingw
 545 if !MINGW
 546 if !ENABLE_STATIC
 547 TESTS += maybe_threads_unittest.sh$(EXEEXT)
 548 maybe_threads_unittest_sh_SOURCES = src/tests/maybe_threads_unittest.sh
 549 noinst_SCRIPTS += $(maybe_threads_unittest_sh_SOURCES)
 550 # This script preloads libtcmalloc, and calls two other binaries as well
 551 # TODO(csilvers): replace by 'if ! cmp $^ $@ >/dev/null 2>&; then ...; fi'
 552 maybe_threads_unittest.sh$(EXEEXT): $(top_srcdir)/$(maybe_threads_unittest_sh_SOURCES) \
 553                            $(LIBTCMALLOC_MINIMAL) \
 554                            low_level_alloc_unittest
 555         rm -f $@
 556         cp -p $(top_srcdir)/$(maybe_threads_unittest_sh_SOURCES) $@
 557 endif !ENABLE_STATIC
 558 endif !MINGW
 559
 560 # These all tests components of tcmalloc_minimal
 561
 562 TESTS += addressmap_unittest
 563 WINDOWS_PROJECTS += vsprojects/addressmap_unittest/addressmap_unittest.vcproj
 564 ADDRESSMAP_UNITTEST_INCLUDES = src/addressmap-inl.h \
 565                                src/base/commandlineflags.h \
 566                                $(LOGGING_INCLUDES)
 567 addressmap_unittest_SOURCES = src/tests/addressmap_unittest.cc \
 568                               $(ADDRESSMAP_UNITTEST_INCLUDES)
 569 if MINGW
 570 addressmap_unittest_SOURCES += src/windows/port.h src/windows/port.cc
 571 endif MINGW
 572 addressmap_unittest_CXXFLAGS = -g $(AM_CXXFLAGS)
 573 addressmap_unittest_LDADD = liblogging.la
 574
 575 if !MINGW
 576 TESTS += system_alloc_unittest
 577 system_alloc_unittest_SOURCES = src/config_for_unittests.h \
 578                                 src/tests/system-alloc_unittest.cc
 579 system_alloc_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 580 system_alloc_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 581 system_alloc_unittest_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
 582 endif !MINGW
 583
 584 TESTS += packed_cache_test
 585 WINDOWS_PROJECTS += vsprojects/packed-cache_test/packed-cache_test.vcproj
 586 packed_cache_test_SOURCES = src/tests/packed-cache_test.cc
 587 packed_cache_test_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 588 packed_cache_test_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 589 packed_cache_test_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
 590
 591 TESTS += frag_unittest
 592 WINDOWS_PROJECTS += vsprojects/frag_unittest/frag_unittest.vcproj
 593 frag_unittest_SOURCES = src/tests/frag_unittest.cc src/config_for_unittests.h
 594 frag_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 595 frag_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 596 frag_unittest_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
 597
 598 TESTS += markidle_unittest
 599 WINDOWS_PROJECTS += vsprojects/markidle_unittest/markidle_unittest.vcproj
 600 markidle_unittest_SOURCES = src/tests/markidle_unittest.cc \
 601                             src/config_for_unittests.h \
 602                             src/tests/testutil.h src/tests/testutil.cc
 603 markidle_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 604 markidle_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 605 markidle_unittest_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
 606
 607 TESTS += current_allocated_bytes_test
 608 WINDOWS_PROJECTS += vsprojects/current_allocated_bytes_test/current_allocated_bytes_test.vcproj
 609 current_allocated_bytes_test_SOURCES = src/tests/current_allocated_bytes_test.cc \
 610                                        src/config_for_unittests.h
 611 current_allocated_bytes_test_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 612 current_allocated_bytes_test_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 613 current_allocated_bytes_test_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
 614
 615 TESTS += malloc_hook_test
 616 WINDOWS_PROJECTS += vsprojects/malloc_hook_test/malloc_hook_test.vcproj
 617 malloc_hook_test_SOURCES = src/tests/malloc_hook_test.cc \
 618                            src/config_for_unittests.h \
 619                            src/base/logging.h \
 620                            src/gperftools/malloc_hook.h \
 621                            src/tests/testutil.h src/tests/testutil.cc
 622 malloc_hook_test_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 623 malloc_hook_test_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 624 malloc_hook_test_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
 625
 626 TESTS += malloc_extension_test
 627 WINDOWS_PROJECTS += vsprojects/malloc_extension_test/malloc_extension_test.vcproj
 628 malloc_extension_test_SOURCES = src/tests/malloc_extension_test.cc \
 629                                 src/config_for_unittests.h \
 630                                 src/base/logging.h \
 631                                 src/gperftools/malloc_extension.h \
 632                                 src/gperftools/malloc_extension_c.h
 633 malloc_extension_test_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 634 malloc_extension_test_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 635 malloc_extension_test_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
 636
 637 # This doesn't work with static linkage, because libtcmalloc.a isn't
 638 # happy with C linkage (it misses the stdc++ library).  Likewise with
 639 # mingw, which links foo.a even though it doesn't set ENABLE_STATIC.
 640 # TODO(csilvers): set enable_static=true in configure.ac:36?
 641 if !MINGW
 642 if !ENABLE_STATIC
 643 TESTS += malloc_extension_c_test
 644 malloc_extension_c_test_SOURCES = src/tests/malloc_extension_c_test.c \
 645                                   src/gperftools/malloc_extension.h \
 646                                   src/gperftools/malloc_extension_c.h
 647 malloc_extension_c_test_CFLAGS = $(PTHREAD_CFLAGS) $(AM_CFLAGS)
 648 # -ansi here is just to help ensure the code is bog-standard C.
 649 if GCC
 650 malloc_extension_c_test_CFLAGS += -ansi
 651 endif GCC
 652 malloc_extension_c_test_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 653 malloc_extension_c_test_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
 654 endif !ENABLE_STATIC
 655 endif !MINGW
 656
 657 if !MINGW
 658 if !OSX
 659 TESTS += memalign_unittest
 660 memalign_unittest_SOURCES = src/tests/memalign_unittest.cc \
 661                             src/tcmalloc.h \
 662                             src/config_for_unittests.h \
 663                             src/tests/testutil.h src/tests/testutil.cc
 664 memalign_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 665 memalign_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 666 memalign_unittest_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
 667 endif !OSX
 668 endif !MINGW
 669
 670 TESTS += page_heap_test
 671 WINDOWS_PROJECTS += vsprojects/page_heap_test/page_heap_test.vcproj
 672 page_heap_test_SOURCES = src/tests/page_heap_test.cc \
 673                          src/config_for_unittests.h \
 674                          src/base/logging.h \
 675                          src/common.h \
 676                          src/page_heap.h
 677 page_heap_test_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 678 page_heap_test_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 679 page_heap_test_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
 680
 681 TESTS += pagemap_unittest
 682 WINDOWS_PROJECTS += vsprojects/pagemap_unittest/pagemap_unittest.vcproj
 683 pagemap_unittest_SOURCES = src/tests/pagemap_unittest.cc \
 684                            src/config_for_unittests.h \
 685                            src/base/logging.h \
 686                            src/pagemap.h
 687 pagemap_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 688 pagemap_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 689 pagemap_unittest_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
 690
 691 TESTS += realloc_unittest
 692 WINDOWS_PROJECTS += vsprojects/realloc_unittest/realloc_unittest.vcproj
 693 realloc_unittest_SOURCES = src/tests/realloc_unittest.cc \
 694                            src/config_for_unittests.h \
 695                            src/base/logging.h
 696 realloc_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 697 realloc_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 698 realloc_unittest_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
 699
 700 TESTS += stack_trace_table_test
 701 WINDOWS_PROJECTS += vsprojects/stack_trace_table_test/stack_trace_table_test.vcproj
 702 stack_trace_table_test_SOURCES = src/tests/stack_trace_table_test.cc \
 703                                  src/config_for_unittests.h
 704 stack_trace_table_test_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 705 stack_trace_table_test_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 706 stack_trace_table_test_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
 707
 708 TESTS += thread_dealloc_unittest
 709 WINDOWS_PROJECTS += vsprojects/thread_dealloc_unittest/thread_dealloc_unittest.vcproj
 710 thread_dealloc_unittest_SOURCES = src/tests/thread_dealloc_unittest.cc \
 711                                   src/config_for_unittests.h \
 712                                   src/tests/testutil.h src/tests/testutil.cc
 713 thread_dealloc_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 714 thread_dealloc_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 715 thread_dealloc_unittest_LDADD = $(LIBTCMALLOC_MINIMAL) $(PTHREAD_LIBS)
 716
 717 ### Documentation
 718 dist_doc_DATA += doc/tcmalloc.html \
 719                  doc/overview.gif \
 720                  doc/pageheap.gif \
 721                  doc/spanmap.gif \
 722                  doc/threadheap.gif \
 723                  doc/t-test1.times.txt \
 724                  doc/tcmalloc-opspercpusec.vs.threads.1024.bytes.png    \
 725                  doc/tcmalloc-opspercpusec.vs.threads.128.bytes.png     \
 726                  doc/tcmalloc-opspercpusec.vs.threads.131072.bytes.png  \
 727                  doc/tcmalloc-opspercpusec.vs.threads.16384.bytes.png   \
 728                  doc/tcmalloc-opspercpusec.vs.threads.2048.bytes.png    \
 729                  doc/tcmalloc-opspercpusec.vs.threads.256.bytes.png     \
 730                  doc/tcmalloc-opspercpusec.vs.threads.32768.bytes.png   \
 731                  doc/tcmalloc-opspercpusec.vs.threads.4096.bytes.png    \
 732                  doc/tcmalloc-opspercpusec.vs.threads.512.bytes.png     \
 733                  doc/tcmalloc-opspercpusec.vs.threads.64.bytes.png      \
 734                  doc/tcmalloc-opspercpusec.vs.threads.65536.bytes.png   \
 735                  doc/tcmalloc-opspercpusec.vs.threads.8192.bytes.png    \
 736                  doc/tcmalloc-opspersec.vs.size.1.threads.png           \
 737                  doc/tcmalloc-opspersec.vs.size.12.threads.png          \
 738                  doc/tcmalloc-opspersec.vs.size.16.threads.png          \
 739                  doc/tcmalloc-opspersec.vs.size.2.threads.png           \
 740                  doc/tcmalloc-opspersec.vs.size.20.threads.png          \
 741                  doc/tcmalloc-opspersec.vs.size.3.threads.png           \
 742                  doc/tcmalloc-opspersec.vs.size.4.threads.png           \
 743                  doc/tcmalloc-opspersec.vs.size.5.threads.png           \
 744                  doc/tcmalloc-opspersec.vs.size.8.threads.png
 745
 746 # I don't know how to say "distribute the .dot files but don't install them";
 747 # noinst doesn't seem to work with data.  I separate them out anyway, in case
 748 # one day we figure it out.  Regardless, installing the dot files isn't the
 749 # end of the world.
 750 dist_doc_DATA += doc/overview.dot \
 751                  doc/pageheap.dot \
 752                  doc/spanmap.dot \
 753                  doc/threadheap.dot
 754
 755
 756 ### ------- tcmalloc_minimal_debug (thread-caching malloc with debugallocation)
 757
 758 # Like tcmalloc.cc, debugallocation.cc needs exceptions to fulfill its
 759 # API.  Luckily, we can reuse everything else from tcmalloc_minimal.
 760
 761 if WITH_DEBUGALLOC
 762
 763 lib_LTLIBRARIES += libtcmalloc_minimal_debug.la
 764 libtcmalloc_minimal_debug_la_SOURCES = src/debugallocation.cc \
 765                                        $(TCMALLOC_MINIMAL_INCLUDES)
 766 libtcmalloc_minimal_debug_la_CXXFLAGS = $(libtcmalloc_minimal_la_CXXFLAGS) \
 767                                         -DTCMALLOC_FOR_DEBUGALLOCATION
 768 # version_info gets passed to libtool
 769 libtcmalloc_minimal_debug_la_LDFLAGS = $(libtcmalloc_minimal_la_LDFLAGS) \
 770                                        -version-info @TCMALLOC_SO_VERSION@
 771 libtcmalloc_minimal_debug_la_LIBADD = $(libtcmalloc_minimal_la_LIBADD)
 772
 773 LIBS_TO_WEAKEN += libtcmalloc_minimal_debug.la
 774
 775 ### Unittests
 776
 777 TESTS += tcmalloc_minimal_debug_unittest
 778 tcmalloc_minimal_debug_unittest_SOURCES = $(tcmalloc_minimal_unittest_SOURCES)
 779 tcmalloc_minimal_debug_unittest_CXXFLAGS = $(tcmalloc_minimal_unittest_CXXFLAGS) \
 780                                            -DDEBUGALLOCATION
 781 tcmalloc_minimal_debug_unittest_LDFLAGS = $(tcmalloc_minimal_unittest_LDFLAGS)
 782 tcmalloc_minimal_debug_unittest_LDADD = libtcmalloc_minimal_debug.la $(PTHREAD_LIBS)
 783
 784 TESTS += malloc_extension_debug_test
 785 malloc_extension_debug_test_SOURCES = $(malloc_extension_test_SOURCES)
 786 malloc_extension_debug_test_CXXFLAGS = $(malloc_extension_test_CXXFLAGS)
 787 malloc_extension_debug_test_LDFLAGS = $(malloc_extension_test_LDFLAGS)
 788 malloc_extension_debug_test_LDADD = libtcmalloc_minimal_debug.la $(PTHREAD_LIBS)
 789
 790 if !MINGW
 791 if !OSX
 792 TESTS += memalign_debug_unittest
 793 memalign_debug_unittest_SOURCES = $(memalign_unittest_SOURCES)
 794 memalign_debug_unittest_CXXFLAGS = $(memalign_unittest_CXXFLAGS)
 795 memalign_debug_unittest_LDFLAGS = $(memalign_unittest_LDFLAGS)
 796 memalign_debug_unittest_LDADD = libtcmalloc_minimal_debug.la $(PTHREAD_LIBS)
 797 endif !OSX
 798 endif !MINGW
 799
 800 TESTS += realloc_debug_unittest
 801 realloc_debug_unittest_SOURCES = $(realloc_unittest_SOURCES)
 802 realloc_debug_unittest_CXXFLAGS = $(realloc_unittest_CXXFLAGS)
 803 realloc_debug_unittest_LDFLAGS = $(realloc_unittest_LDFLAGS)
 804 realloc_debug_unittest_LDADD = libtcmalloc_minimal_debug.la $(PTHREAD_LIBS)
 805
 806 # debugallocation_test checks that we print a proper stacktrace when
 807 # debug-allocs fail, so we can't run it if we don't have stacktrace info.
 808 if WITH_STACK_TRACE
 809 TESTS += debugallocation_test.sh$(EXEEXT)
 810 debugallocation_test_sh_SOURCES = src/tests/debugallocation_test.sh
 811 noinst_SCRIPTS += $(debugallocation_test_sh_SOURCES)
 812 debugallocation_test.sh$(EXEEXT): $(top_srcdir)/$(debugallocation_test_sh_SOURCES) \
 813                                   debugallocation_test
 814         rm -f $@
 815         cp -p $(top_srcdir)/$(debugallocation_test_sh_SOURCES) $@
 816
 817 # This is the sub-program used by debugallocation_test.sh
 818 noinst_PROGRAMS += debugallocation_test
 819 debugallocation_test_SOURCES = src/tests/debugallocation_test.cc
 820 debugallocation_test_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 821 debugallocation_test_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 822 debugallocation_test_LDADD = libtcmalloc_debug.la $(PTHREAD_LIBS)
 823 endif WITH_STACK_TRACE
 824
 825 endif WITH_DEBUGALLOC
 826
 827
 828 ### ------- tcmalloc (thread-caching malloc + heap profiler + heap checker)
 829
 830 if WITH_HEAP_PROFILER_OR_CHECKER
 831
 832 ### The header files we use.  We divide into categories based on directory
 833 S_TCMALLOC_INCLUDES = $(S_TCMALLOC_MINIMAL_INCLUDES) \
 834                       $(LOGGING_INCLUDES) \
 835                       src/addressmap-inl.h \
 836                       src/raw_printer.h \
 837                       src/base/elfcore.h \
 838                       src/base/googleinit.h \
 839                       src/base/linux_syscall_support.h \
 840                       src/base/linuxthreads.h \
 841                       src/base/stl_allocator.h \
 842                       src/base/sysinfo.h \
 843                       src/base/thread_lister.h \
 844                       src/heap-profile-table.h
 845 SG_TCMALLOC_INCLUDES = $(SG_TCMALLOC_MINIMAL_INCLUDES) \
 846                        src/gperftools/heap-profiler.h \
 847                        src/gperftools/heap-checker.h
 848 TCMALLOC_INCLUDES = $(S_TCMALLOC_INCLUDES) $(SG_TCMALLOC_INCLUDES)
 849 perftoolsinclude_HEADERS += $(SG_TCMALLOC_INCLUDES)
 850
 851 ### Making the library
 852
 853 # As we describe at the top of this file, we want to turn off exceptions
 854 # for all files in this library -- except tcmalloc.cc which needs them
 855 # to fulfill its API.  Automake doesn't allow per-file CXXFLAGS, so we need
 856 # to separate into two libraries.
 857 noinst_LTLIBRARIES += libtcmalloc_internal.la
 858 libtcmalloc_internal_la_SOURCES = $(libtcmalloc_minimal_internal_la_SOURCES) \
 859                                   $(TCMALLOC_INCLUDES) \
 860                                   src/base/low_level_alloc.cc \
 861                                   src/heap-profile-table.cc \
 862                                   src/heap-profiler.cc \
 863                                   src/raw_printer.cc \
 864                                   src/memory_region_map.cc
 865 libtcmalloc_internal_la_CXXFLAGS = $(PTHREAD_CFLAGS) -DNDEBUG \
 866                                    $(AM_CXXFLAGS) $(NO_EXCEPTIONS)
 867 libtcmalloc_internal_la_LDFLAGS = $(PTHREAD_CFLAGS)
 868 libtcmalloc_internal_la_LIBADD = libstacktrace.la $(PTHREAD_LIBS)
 869
 870 lib_LTLIBRARIES += libtcmalloc.la
 871 libtcmalloc_la_SOURCES = $(TCMALLOC_CC) $(TCMALLOC_INCLUDES)
 872 libtcmalloc_la_CXXFLAGS = $(PTHREAD_CFLAGS) -DNDEBUG $(AM_CXXFLAGS)
 873 libtcmalloc_la_LDFLAGS = $(PTHREAD_CFLAGS) -version-info @TCMALLOC_SO_VERSION@
 874 libtcmalloc_la_LIBADD = libtcmalloc_internal.la $(PTHREAD_LIBS)
 875
 876 if WITH_HEAP_CHECKER
 877 # heap-checker-bcad is last, in hopes its global ctor will run first.
 878 # (Note this is added to libtcmalloc.la, not libtcmalloc_internal.la,
 879 # but that's ok; the internal/external distinction is only useful for
 880 # cygwin, and cygwin doesn't use HEAP_CHECKER anyway.)
 881 HEAP_CHECKER_SOURCES = src/base/thread_lister.c \
 882                        src/base/linuxthreads.cc \
 883                        src/heap-checker.cc \
 884                        src/heap-checker-bcad.cc
 885 libtcmalloc_la_SOURCES += $(HEAP_CHECKER_SOURCES)
 886 else !WITH_HEAP_CHECKER
 887 HEAP_CHECKER_SOURCES =
 888 libtcmalloc_internal_la_CXXFLAGS += -DNO_HEAP_CHECK
 889 libtcmalloc_la_CXXFLAGS += -DNO_HEAP_CHECK
 890 endif !WITH_HEAP_CHECKER
 891
 892 LIBTCMALLOC = libtcmalloc.la
 893
 894 LIBS_TO_WEAKEN += libtcmalloc.la
 895
 896 ### Unittests
 897
 898 TESTS += tcmalloc_unittest
 899 TCMALLOC_UNITTEST_INCLUDES = src/config_for_unittests.h \
 900                              src/gperftools/malloc_extension.h
 901 tcmalloc_unittest_SOURCES = src/tests/tcmalloc_unittest.cc \
 902                             src/tcmalloc.h \
 903                             src/tests/testutil.h src/tests/testutil.cc \
 904                             $(TCMALLOC_UNITTEST_INCLUDES)
 905 tcmalloc_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 906 tcmalloc_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 907 # We want libtcmalloc last on the link line, but due to a bug in
 908 # libtool involving convenience libs, they need to come last on the
 909 # link line in order to get dependency ordering right.  This is ok:
 910 # convenience libraries are .a's, so tcmalloc is still the last .so.
 911 # We also put pthreads after tcmalloc, because some pthread
 912 # implementations define their own malloc, and we need to go on the
 913 # first linkline to make sure our malloc 'wins'.
 914 tcmalloc_unittest_LDADD = $(LIBTCMALLOC) liblogging.la $(PTHREAD_LIBS)
 915
 916 # This makes sure it's safe to link in both tcmalloc and
 917 # tcmalloc_minimal.  (One would never do this on purpose, but perhaps
 918 # by accident...)  When we can compile libprofiler, we also link it in
 919 # to make sure that works too.  NOTE: On OS X, it's *not* safe to
 920 # link both in (we end up with two copies of every global var, and
 921 # the code tends to pick one arbitrarily), so don't run the test there.
 922 # (We define these outside the 'if' because they're reused below.)
 923 tcmalloc_both_unittest_srcs = src/tests/tcmalloc_unittest.cc \
 924                               src/tests/testutil.h src/tests/testutil.cc \
 925                               $(TCMALLOC_UNITTEST_INCLUDES)
 926 tcmalloc_both_unittest_cflags = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 927 tcmalloc_both_unittest_lflags = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 928 if WITH_CPU_PROFILER
 929 # We want libtcmalloc last on the link line, but due to a bug in
 930 # libtool involving convenience libs, they need to come last on the
 931 # link line in order to get dependency ordering right.  This is ok:
 932 # convenience libraries are .a's, so tcmalloc is still the last .so.
 933 # We also put pthreads after tcmalloc, because some pthread
 934 # implementations define their own malloc, and we need to go on the
 935 # first linkline to make sure our malloc 'wins'.
 936 tcmalloc_both_unittest_ladd = $(LIBTCMALLOC) $(LIBTCMALLOC_MINIMAL) \
 937                               libprofiler.la liblogging.la $(PTHREAD_LIBS)
 938 else
 939 tcmalloc_both_unittest_ladd = $(LIBTCMALLOC) $(LIBTCMALLOC_MINIMAL) \
 940                               liblogging.la $(PTHREAD_LIBS)
 941 endif !WITH_CPU_PROFILER
 942 if !OSX
 943 TESTS += tcmalloc_both_unittest
 944 tcmalloc_both_unittest_SOURCES = $(tcmalloc_both_unittest_srcs)
 945 tcmalloc_both_unittest_CXXFLAGS = $(tcmalloc_both_unittest_cflags)
 946 tcmalloc_both_unittest_LDFLAGS = $(tcmalloc_both_unittest_lflags)
 947 tcmalloc_both_unittest_LDADD = $(tcmalloc_both_unittest_ladd)
 948 endif !OSX
 949
 950 TESTS += tcmalloc_large_unittest
 951 tcmalloc_large_unittest_SOURCES = src/tests/tcmalloc_large_unittest.cc
 952 tcmalloc_large_unittest_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 953 tcmalloc_large_unittest_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 954 tcmalloc_large_unittest_LDADD = $(LIBTCMALLOC) $(PTHREAD_LIBS)
 955
 956 TESTS += raw_printer_test
 957 raw_printer_test_SOURCES = src/tests/raw_printer_test.cc
 958 raw_printer_test_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 959 raw_printer_test_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 960 raw_printer_test_LDADD = $(LIBTCMALLOC) $(PTHREAD_LIBS)
 961
 962 # sampler_test and sampling_test both require sampling to be turned
 963 # on, which it's not by default.  Use the "standard" value of 2^19.
 964 TESTS_ENVIRONMENT += TCMALLOC_SAMPLE_PARAMETER=524288
 965
 966 TESTS += sampler_test
 967 WINDOWS_PROJECTS += vsprojects/sampler_test/sampler_test.vcproj
 968 sampler_test_SOURCES = src/tests/sampler_test.cc \
 969                        src/config_for_unittests.h
 970 sampler_test_CXXFLAGS = $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 971 sampler_test_LDFLAGS = $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 972 sampler_test_LDADD = $(LIBTCMALLOC) $(PTHREAD_LIBS) -lm
 973
 974
 975 # These unittests often need to run binaries.  They're in the current dir
 976 TESTS_ENVIRONMENT += BINDIR=.
 977 TESTS_ENVIRONMENT += TMPDIR=/tmp/perftools
 978
 979 TESTS += sampling_test.sh$(EXEEXT)
 980 sampling_test_sh_SOURCES = src/tests/sampling_test.sh
 981 noinst_SCRIPTS += $(sampling_test_sh_SOURCES)
 982 sampling_test.sh$(EXEEXT): $(top_srcdir)/$(sampling_test_sh_SOURCES) \
 983                            sampling_test
 984         rm -f $@
 985         cp -p $(top_srcdir)/$(sampling_test_sh_SOURCES) $@
 986
 987 # This is the sub-program used by sampling_test.sh
 988 # The -g is so pprof can get symbol information.
 989 noinst_PROGRAMS += sampling_test
 990 SAMPLING_TEST_INCLUDES = src/config_for_unittests.h \
 991                          src/base/logging.h \
 992                          src/gperftools/malloc_extension.h
 993 sampling_test_SOURCES = src/tests/sampling_test.cc \
 994                         $(SAMPLING_TEST_INCLUDES)
 995 sampling_test_CXXFLAGS = -g $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
 996 sampling_test_LDFLAGS = -g $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
 997 sampling_test_LDADD = $(LIBTCMALLOC) $(PTHREAD_LIBS)
 998
 999 endif WITH_HEAP_PROFILER_OR_CHECKER
1000
1001 if WITH_HEAP_PROFILER
1002
1003 TESTS += heap-profiler_unittest.sh$(EXEEXT)
1004 heap_profiler_unittest_sh_SOURCES = src/tests/heap-profiler_unittest.sh
1005 noinst_SCRIPTS += $(heap_profiler_unittest_sh_SOURCES)
1006 heap-profiler_unittest.sh$(EXEEXT): $(top_srcdir)/$(heap_profiler_unittest_sh_SOURCES) \
1007                                     heap-profiler_unittest
1008         rm -f $@
1009         cp -p $(top_srcdir)/$(heap_profiler_unittest_sh_SOURCES) $@
1010
1011 # These are sub-programs used by heap-profiler_unittest.sh
1012 noinst_PROGRAMS += heap-profiler_unittest
1013 HEAP_PROFILER_UNITTEST_INCLUDES = src/config_for_unittests.h \
1014                                   src/gperftools/heap-profiler.h
1015 heap_profiler_unittest_SOURCES = src/tests/heap-profiler_unittest.cc \
1016                                  $(HEAP_PROFILER_UNITTEST_INCLUDES)
1017 heap_profiler_unittest_CXXFLAGS = -g $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
1018 heap_profiler_unittest_LDFLAGS = -g $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
1019 heap_profiler_unittest_LDADD = $(LIBTCMALLOC) $(PTHREAD_LIBS)
1020
1021 # Tests the compatibility include-headers in google/.  Requires a function
1022 # defined in the heap-profiler, which is why the test lives here.
1023 TESTS += simple_compat_test
1024 simple_compat_test_SOURCES = src/tests/simple_compat_test.cc \
1025                              $(googleinclude_HEADERS)
1026 simple_compat_test_LDFLAGS = $(TCMALLOC_FLAGS)
1027 simple_compat_test_LDADD = $(LIBTCMALLOC)
1028
1029 endif WITH_HEAP_PROFILER
1030
1031 if WITH_HEAP_CHECKER
1032
1033 TESTS += heap-checker_unittest.sh$(EXEEXT)
1034 heap_checker_unittest_sh_SOURCES = src/tests/heap-checker_unittest.sh
1035 noinst_SCRIPTS += $(heap_checker_unittest_sh_SOURCES)
1036 heap-checker_unittest.sh$(EXEEXT): $(top_srcdir)/$(heap_checker_unittest_sh_SOURCES) \
1037                                    heap-checker_unittest
1038         rm -f $@
1039         cp -p $(top_srcdir)/$(heap_checker_unittest_sh_SOURCES) $@
1040
1041 TESTS += heap-checker-death_unittest.sh$(EXEEXT)
1042 heap_checker_death_unittest_sh_SOURCES = src/tests/heap-checker-death_unittest.sh
1043 noinst_SCRIPTS += $(top_srcdir)/$(heap_checker_death_unittest_sh_SOURCES)
1044 heap-checker-death_unittest.sh$(EXEEXT): $(heap_checker_death_unittest_sh_SOURCES) \
1045                                          heap-checker_unittest
1046         rm -f $@
1047         cp -p $(top_srcdir)/$(heap_checker_death_unittest_sh_SOURCES) $@
1048
1049 # These are sub-programs used by heap-checker_unittest.sh
1050 noinst_PROGRAMS += heap-checker_unittest
1051 HEAP_CHECKER_UNITTEST_INCLUDES = src/config_for_unittests.h \
1052                                  src/memory_region_map.h \
1053                                  src/base/commandlineflags.h \
1054                                  src/base/googleinit.h \
1055                                  src/gperftools/heap-checker.h \
1056                                  $(LOGGING_INCLUDES)
1057 heap_checker_unittest_SOURCES = src/tests/heap-checker_unittest.cc \
1058                                 $(HEAP_CHECKER_UNITTEST_INCLUDES)
1059 heap_checker_unittest_CXXFLAGS = -g $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
1060 heap_checker_unittest_LDFLAGS = -g $(PTHREAD_CFLAGS) $(TCMALLOC_FLAGS)
1061 # We want libtcmalloc last on the link line, but due to a bug in
1062 # libtool involving convenience libs, they need to come last on the
1063 # link line in order to get dependency ordering right.  This is ok:
1064 # convenience libraries are .a's, so tcmalloc is still the last .so.
1065 # We also put pthreads after tcmalloc, because some pthread
1066 # implementations define their own malloc, and we need to go on the
1067 # first linkline to make sure our malloc 'wins'.
1068 heap_checker_unittest_LDADD = $(LIBTCMALLOC) liblogging.la $(PTHREAD_LIBS)
1069
1070 endif WITH_HEAP_CHECKER
1071
1072 ### Documentation (above and beyond tcmalloc_minimal documentation)
1073 if WITH_HEAP_PROFILER
1074 dist_doc_DATA += doc/heapprofile.html doc/heap-example1.png
1075 endif WITH_HEAP_PROFILER
1076
1077 if WITH_HEAP_CHECKER
1078 dist_doc_DATA += doc/heap_checker.html
1079 endif WITH_HEAP_CHECKER
1080
1081
1082 ### ------- tcmalloc with debugallocation
1083
1084 if WITH_DEBUGALLOC
1085 if WITH_HEAP_PROFILER_OR_CHECKER
1086
1087 lib_LTLIBRARIES += libtcmalloc_debug.la
1088 libtcmalloc_debug_la_SOURCES = src/debugallocation.cc $(HEAP_CHECKER_SOURCES) \
1089                                $(TCMALLOC_INCLUDES)
1090 libtcmalloc_debug_la_CXXFLAGS = $(libtcmalloc_la_CXXFLAGS) \
1091                                 -DTCMALLOC_FOR_DEBUGALLOCATION
1092 libtcmalloc_debug_la_LDFLAGS = $(libtcmalloc_la_LDFLAGS) \
1093                                -version-info @TCMALLOC_SO_VERSION@
1094 libtcmalloc_debug_la_LIBADD = $(libtcmalloc_la_LIBADD)
1095
1096 LIBS_TO_WEAKEN += libtcmalloc_debug.la
1097
1098 ### Unittests
1099
1100 TESTS += tcmalloc_debug_unittest
1101 tcmalloc_debug_unittest_SOURCES = $(tcmalloc_unittest_SOURCES)
1102 tcmalloc_debug_unittest_CXXFLAGS = $(tcmalloc_unittest_CXXFLAGS) \
1103                                    -DDEBUGALLOCATION
1104 tcmalloc_debug_unittest_LDFLAGS = $(tcmalloc_unittest_LDFLAGS)
1105 tcmalloc_debug_unittest_LDADD = libtcmalloc_debug.la $(PTHREAD_LIBS)
1106
1107 TESTS += sampler_debug_test
1108 sampler_debug_test_SOURCES = $(sampler_test_SOURCES)
1109 sampler_debug_test_CXXFLAGS = $(samples_test_CXXFLAGS)
1110 sampler_debug_test_LDFLAGS = $(sampler_test_LDFLAGS)
1111 sampler_debug_test_LDADD = libtcmalloc_debug.la $(PTHREAD_LIBS) -lm
1112
1113 TESTS += sampling_debug_test.sh$(EXEEXT)
1114 sampling_debug_test_sh_SOURCES = src/tests/sampling_test.sh
1115 sampling_debug_test.sh$(EXEEXT): $(top_srcdir)/$(sampling_test_sh_SOURCES) \
1116                                  sampling_debug_test
1117         rm -f $@
1118         cp -p $(top_srcdir)/$(sampling_test_sh_SOURCES) $@
1119
1120 # This is the sub-program using by sampling_debug_test.sh
1121 # The -g is so pprof can get symbol information.
1122 noinst_PROGRAMS += sampling_debug_test
1123 sampling_debug_test_SOURCES = $(sampling_test_SOURCES)
1124 sampling_debug_test_CXXFLAGS = $(sampling_test_CXXFLAGS)
1125 sampling_debug_test_LDFLAGS = $(sampling_test_LDFLAGS)
1126 sampling_debug_test_LDADD = libtcmalloc_debug.la $(PTHREAD_LIBS)
1127
1128 endif WITH_HEAP_PROFILER_OR_CHECKER
1129
1130 if WITH_HEAP_PROFILER
1131
1132 TESTS += heap-profiler_debug_unittest.sh$(EXEEXT)
1133 heap_profiler_debug_unittest_sh_SOURCES = src/tests/heap-profiler_unittest.sh
1134 heap-profiler_debug_unittest.sh$(EXEEXT): $(top_srcdir)/$(heap_profiler_unittest_sh_SOURCES) \
1135                                     heap-profiler_debug_unittest
1136         rm -f $@
1137         cp -p $(top_srcdir)/$(heap_profiler_unittest_sh_SOURCES) $@
1138
1139 # These are sub-programs used by heap-profiler_debug_unittest.sh
1140 noinst_PROGRAMS += heap-profiler_debug_unittest
1141 heap_profiler_debug_unittest_SOURCES = $(heap_profiler_unittest_SOURCES)
1142 heap_profiler_debug_unittest_CXXFLAGS = $(heap_profiler_unittest_CXXFLAGS)
1143 heap_profiler_debug_unittest_LDFLAGS = $(heap_profiler_unittest_LDFLAGS)
1144 heap_profiler_debug_unittest_LDADD = libtcmalloc_debug.la $(PTHREAD_LIBS)
1145
1146 endif WITH_HEAP_PROFILER
1147
1148 if WITH_HEAP_CHECKER
1149
1150 TESTS += heap-checker_debug_unittest.sh$(EXEEXT)
1151 heap_checker_debug_unittest_sh_SOURCES = src/tests/heap-checker_unittest.sh
1152 heap-checker_debug_unittest.sh$(EXEEXT): $(top_srcdir)/$(heap_checker_unittest_sh_SOURCES) \
1153                                    heap-checker_debug_unittest
1154         rm -f $@
1155         cp -p $(top_srcdir)/$(heap_checker_unittest_sh_SOURCES) $@
1156
1157 # These are sub-programs used by heap-checker_debug_unittest.sh
1158 noinst_PROGRAMS += heap-checker_debug_unittest
1159 heap_checker_debug_unittest_SOURCES = $(heap_checker_unittest_SOURCES)
1160 heap_checker_debug_unittest_CXXFLAGS = $(heap_checker_unittest_CXXFLAGS)
1161 heap_checker_debug_unittest_LDFLAGS = $(heap_checker_unittest_LDFLAGS)
1162 # We want libtcmalloc last on the link line, but due to a bug in
1163 # libtool involving convenience libs, they need to come last on the
1164 # link line in order to get dependency ordering right.  This is ok:
1165 # convenience libraries are .a's, so tcmalloc is still the last .so.
1166 heap_checker_debug_unittest_LDADD = libtcmalloc_debug.la liblogging.la \
1167                                     $(PTHREAD_LIBS)
1168
1169 endif WITH_HEAP_CHECKER
1170 endif WITH_DEBUGALLOC
1171
1172
1173 ### ------- CPU profiler
1174
1175 if WITH_CPU_PROFILER
1176
1177 ### The header files we use.  We divide into categories based on directory
1178 S_CPU_PROFILER_INCLUDES = src/profiledata.h \
1179                           src/profile-handler.h \
1180                           src/getpc.h \
1181                           src/base/basictypes.h \
1182                           src/base/commandlineflags.h \
1183                           src/base/googleinit.h \
1184                           src/base/logging.h \
1185                           src/base/simple_mutex.h \
1186                           src/base/sysinfo.h \
1187                           $(SPINLOCK_INCLUDES) \
1188                           $(LOGGING_INCLUDES)
1189 SG_CPU_PROFILER_INCLUDES = src/gperftools/profiler.h \
1190                            src/gperftools/stacktrace.h
1191 CPU_PROFILER_INCLUDES = $(S_CPU_PROFILER_INCLUDES) $(SG_CPU_PROFILER_INCLUDES)
1192 perftoolsinclude_HEADERS += $(SG_CPU_PROFILER_INCLUDES)
1193
1194 ### Making the library
1195 lib_LTLIBRARIES += libprofiler.la
1196 libprofiler_la_SOURCES = src/profiler.cc \
1197                          src/profile-handler.cc \
1198                          src/profiledata.cc \
1199                          $(CPU_PROFILER_INCLUDES)
1200 libprofiler_la_LIBADD = libstacktrace.la
1201 # We have to include ProfileData for profiledata_unittest
1202 CPU_PROFILER_SYMBOLS = '(ProfilerStart|ProfilerStartWithOptions|ProfilerStop|ProfilerFlush|ProfilerEnable|ProfilerDisable|ProfilingIsEnabledForAllThreads|ProfilerRegisterThread|ProfilerGetCurrentState|ProfilerState|ProfileData|ProfileHandler)'
1203 libprofiler_la_LDFLAGS = -export-symbols-regex $(CPU_PROFILER_SYMBOLS) \
1204                          -version-info @PROFILER_SO_VERSION@
1205
1206 # See discussion above (under LIBTCMALLOC_MINIMAL) for why we do this.
1207 # Basically it's to work around systems where --rpath doesn't work right.
1208 LIBPROFILER = libstacktrace.la libprofiler.la
1209
1210 ### Unittests
1211 TESTS += getpc_test
1212 #WINDOWS_PROJECTS += vsprojects/getpc_test/getpc_test.vcproj
1213 getpc_test_SOURCES = src/tests/getpc_test.cc src/getpc.h
1214
1215 TESTS += profiledata_unittest
1216 #WINDOWS_PROJECTS += vsprojects/profiledata_unittest/profiledata_unittest.vcproj
1217 profiledata_unittest_SOURCES = src/tests/profiledata_unittest.cc \
1218                                src/profiledata.h \
1219                                src/base/commandlineflags.h \
1220                                src/base/logging.h \
1221                                src/base/basictypes.h
1222 profiledata_unittest_LDADD = $(LIBPROFILER)
1223
1224 TESTS += profile_handler_unittest
1225 profile_handler_unittest_SOURCES = src/tests/profile-handler_unittest.cc \
1226                                    src/profile-handler.h
1227 profile_handler_unittest_CXXFLAGS = $(PTHREAD_CFLAGS)
1228 profile_handler_unittest_LDFLAGS = $(PTHREAD_CFLAGS)
1229 profile_handler_unittest_LDADD = $(LIBPROFILER) $(PTHREAD_LIBS)
1230
1231 TESTS += profiler_unittest.sh$(EXEEXT)
1232 profiler_unittest_sh_SOURCES = src/tests/profiler_unittest.sh
1233 noinst_SCRIPTS += $(profiler_unittest_sh_SOURCES)
1234 profiler_unittest.sh$(EXEEXT): $(top_srcdir)/$(profiler_unittest_sh_SOURCES) \
1235                                profiler1_unittest profiler2_unittest \
1236                                profiler3_unittest profiler4_unittest
1237         rm -f $@
1238         cp -p $(top_srcdir)/$(profiler_unittest_sh_SOURCES) $@
1239
1240 # These are sub-programs used by profiler_unittest.sh
1241 noinst_PROGRAMS += profiler1_unittest profiler2_unittest profiler3_unittest \
1242                    profiler4_unittest
1243 PROFILER_UNITTEST_INCLUDES = src/config_for_unittests.h \
1244                              src/gperftools/profiler.h
1245 PROFILER_UNITTEST_SRCS = src/tests/profiler_unittest.cc \
1246                          src/tests/testutil.h src/tests/testutil.cc \
1247                          $(PROFILER_UNITTEST_INCLUDES)
1248 profiler1_unittest_SOURCES = $(PROFILER_UNITTEST_SRCS)
1249 profiler1_unittest_CXXFLAGS = -g -DNO_THREADS $(AM_CXXFLAGS)
1250 profiler1_unittest_LDADD = $(LIBPROFILER)
1251 profiler2_unittest_SOURCES = $(PROFILER_UNITTEST_SRCS)
1252 profiler2_unittest_CXXFLAGS = -g -DNO_THREADS $(AM_CXXFLAGS)
1253 profiler2_unittest_LDADD = -lstacktrace -lprofiler
1254 # We depend on -lprofiler but haven't yet said how to build it.  Do so now.
1255 profiler2_unittest_DEPENDENCIES = $(LIBPROFILER)
1256 profiler3_unittest_SOURCES = $(PROFILER_UNITTEST_SRCS)
1257 profiler3_unittest_CXXFLAGS = -g $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
1258 profiler3_unittest_LDFLAGS = $(PTHREAD_CFLAGS)
1259 profiler3_unittest_LDADD = $(LIBPROFILER) $(PTHREAD_LIBS)
1260 profiler4_unittest_SOURCES = $(PROFILER_UNITTEST_SRCS)
1261 profiler4_unittest_CXXFLAGS = -g $(PTHREAD_CFLAGS) $(AM_CXXFLAGS)
1262 profiler4_unittest_LDFLAGS = $(PTHREAD_CFLAGS)
1263 profiler4_unittest_LDADD = -lstacktrace -lprofiler $(PTHREAD_LIBS)
1264 # We depend on -lprofiler but haven't yet said how to build it.  Do so now.
1265 profiler4_unittest_DEPENDENCIES = $(LIBPROFILER)
1266
1267
1268 ### Documentation
1269 dist_doc_DATA += doc/cpuprofile.html \
1270                  doc/cpuprofile-fileformat.html \
1271                  doc/pprof-test-big.gif \
1272                  doc/pprof-test.gif \
1273                  doc/pprof-vsnprintf-big.gif \
1274                  doc/pprof-vsnprintf.gif
1275
1276 endif WITH_CPU_PROFILER
1277
1278
1279 ### ------- CPU profiler and heap checker, in one!
1280
1281 # Ideally, folks who wanted to use both tcmalloc and libprofiler,
1282 # could just link them both into their application.  But while this
1283 # works fine for .so files, it does not for .a files.  The easiest way
1284 # around this -- and I've tried a bunch of the hard ways -- is to just
1285 # to create another set of libraries that has both functionality in it.
1286
1287 if WITH_HEAP_PROFILER_OR_CHECKER
1288 if WITH_CPU_PROFILER
1289
1290 lib_LTLIBRARIES += libtcmalloc_and_profiler.la
1291 libtcmalloc_and_profiler_la_SOURCES = $(libtcmalloc_la_SOURCES) $(libprofiler_la_SOURCES)
1292 libtcmalloc_and_profiler_la_CXXFLAGS = $(libtcmalloc_la_CXXFLAGS) $(libprofiler_la_CXXFLAGS)
1293 # Since this library is meant to be used as a .a, I don't worry as much
1294 # about .so versioning.  I just give the libtcmalloc version number.
1295 # TODO(csilvers): use -export-symbols-regex?
1296 libtcmalloc_and_profiler_la_LDFLAGS = $(PTHREAD_CFLAGS) \
1297                                       -version-info @TCMALLOC_SO_VERSION@
1298 # We don't include libprofiler_la_LIBADD here because all it adds is
1299 # libstacktrace.la, which we already get via libtcmalloc.  Trying to
1300 # specify it twice causes link-time duplicate-definition errors. :-(
1301 libtcmalloc_and_profiler_la_LIBADD = $(libtcmalloc_la_LIBADD)
1302
1303 TESTS += tcmalloc_and_profiler_unittest
1304 tcmalloc_and_profiler_unittest_SOURCES = $(tcmalloc_both_unittest_srcs)
1305 tcmalloc_and_profiler_unittest_CXXFLAGS = $(tcmalloc_both_unittest_cflags)
1306 tcmalloc_and_profiler_unittest_LDFLAGS = $(tcmalloc_both_unittest_lflags)
1307 tcmalloc_and_profiler_unittest_LDADD = libtcmalloc_and_profiler.la
1308
1309 LIBS_TO_WEAKEN += libtcmalloc_and_profiler.la
1310
1311 endif WITH_CPU_PROFILER
1312 endif WITH_HEAP_PROFILER_OR_CHECKER
1313
1314 ## ^^^^ END OF RULES TO MAKE YOUR LIBRARIES, BINARIES, AND UNITTESTS
1315
1316
1317 # Do the weakening on some exported libtcmalloc symbols.
1318 install-exec-local: all-local
1319 all-local: $(LIBS_TO_WEAKEN)
1320         for la in $(LIBS_TO_WEAKEN); do lib=".libs/`basename $$la .la`.a"; [ ! -f "$$lib" ] || $(WEAKEN) "$$lib"; done
1321
1322
1323 # This should always include $(TESTS), but may also include other
1324 # binaries that you compile but don't want automatically installed.
1325 # We'll add to this later, on a library-by-library basis
1326 noinst_PROGRAMS += $(TESTS)
1327
1328 rpm: dist-gzip packages/rpm.sh packages/rpm/rpm.spec
1329         @cd packages && ./rpm.sh ${PACKAGE} ${VERSION}
1330
1331 deb: dist-gzip packages/deb.sh packages/deb/*
1332         @cd packages && ./deb.sh ${PACKAGE} ${VERSION}
1333
1334 # http://linux.die.net/man/1/pkg-config, http://pkg-config.freedesktop.org/wiki
1335 pkgconfigdir = $(libdir)/pkgconfig
1336 pkgconfig_DATA = libtcmalloc.pc libtcmalloc_minimal.pc \
1337                  libtcmalloc_debug.pc libtcmalloc_minimal_debug.pc \
1338                  libprofiler.pc
1339 CLEANFILES = $(pkgconfig_DATA)
1340
1341 # I get the description and URL lines from the rpm spec. I use sed to
1342 # try to rewrite exec_prefix, libdir, and includedir in terms of
1343 # prefix, if possible.
1344 libtcmalloc.pc: Makefile packages/rpm/rpm.spec
1345         echo 'prefix=$(prefix)' > "$@".tmp
1346         echo 'exec_prefix='`echo '$(exec_prefix)' | sed 's@^$(prefix)@$${prefix}@'` >> "$@".tmp
1347         echo 'libdir='`echo '$(libdir)' | sed 's@^$(exec_prefix)@$${exec_prefix}@'` >> "$@".tmp
1348         echo 'includedir='`echo '$(includedir)' | sed 's@^$(prefix)@$${prefix}@'` >> "$@".tmp
1349         echo '' >> "$@".tmp
1350         echo 'Name: $(PACKAGE)' >> "$@".tmp
1351         echo 'Version: $(VERSION)' >> "$@".tmp
1352         -grep '^Summary:' $(top_srcdir)/packages/rpm/rpm.spec | sed s/^Summary:/Description:/ | head -n1 >> "$@".tmp
1353         -grep '^URL: ' $(top_srcdir)/packages/rpm/rpm.spec >> "$@".tmp
1354         echo 'Requires:' >> "$@".tmp
1355         echo 'Libs: -L$${libdir} -ltcmalloc' >> "$@".tmp
1356         echo 'Libs.private: $(PTHREAD_CFLAGS) $(PTHREAD_LIBS)' >> "$@".tmp
1357         echo 'Cflags: -I$${includedir}' >> "$@".tmp
1358         mv -f "$@".tmp "$@"
1359
1360 # The other versions are mostly the same.
1361 libtcmalloc_minimal.pc: libtcmalloc.pc
1362         cat libtcmalloc.pc | sed s/-ltcmalloc/-ltcmalloc_minimal/ > "$@"
1363
1364 libtcmalloc_debug.pc: libtcmalloc.pc
1365         cat libtcmalloc.pc | sed s/-ltcmalloc/-ltcmalloc_debug/ > "$@"
1366
1367 libtcmalloc_minimal_debug.pc: libtcmalloc.pc
1368         cat libtcmalloc.pc | sed s/-ltcmalloc/-ltcmalloc_minimal_debug/ > "$@"
1369
1370 libprofiler.pc: libtcmalloc.pc
1371         cat libtcmalloc.pc | sed s/-ltcmalloc/-lprofiler/ > "$@"
1372
1373 libtool: $(LIBTOOL_DEPS)
1374         $(SHELL) ./config.status --recheck
1375
1376 # Windows wants write permission to .vcproj files and maybe even sln files.
1377 dist-hook:
1378         test -e "$(distdir)/vsprojects" \
1379            && chmod -R u+w $(distdir)/*.sln $(distdir)/vsprojects/
1380
1381 EXTRA_DIST = packages/rpm.sh packages/rpm/rpm.spec packages/deb.sh packages/deb \
1382              $(SCRIPTS) libtool \
1383              src/windows/get_mangled_names.cc src/windows/override_functions.cc \
1384              src/windows/config.h src/windows/gperftools/tcmalloc.h \
1385              $(WINDOWS_PROJECTS) \
1386              src/solaris/libstdc++.la