closes #5485 #5368 clean up cmake and get darwin portability:

for 5485: - remove icc handling stuff from cmake - clean up remaining cmake files - create libtokudb_static.a in a cleaner way using cmake OBJECT libs (requires cmake 2.8.9) - use POSITION_INDEPENDENT_CODE property instead of manually setting -fPIC for 5368: - fix compilation failures due to small differences between gcc and clang, mostly in tests - use toku_fileids_are_equal instead of memcmp to compare fileids (closes #5505) - create dummy implementation of partitioned_counter for osx (quick fix for, and closes #5506) - add mutex->valid bit under TOKU_PTHREAD_DEBUG - initialize mutex of DB_TXN created during recovery for 2PC (closes #5507) git-svn-id: file:///svn/toku/tokudb@48024 c7de825b-a66e-492c-adef-691d508d4ae1
13 years ago · bd63072bdf
76 changed files with 285 additions and 406 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,10 +1,6 @@
 cmake_minimum_required(VERSION 2.8.8)
 cmake_minimum_required(VERSION 2.8.9 FATAL_ERROR)
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules")
 ## this needs to happen before calling project(), when cmake detects some
 ## basic things about the compiler
 include(TokuSetupIntelCompiler)
 project(TokuDB)
 # suppress -rdynamic
@ -23,13 +19,6 @@ include(TokuMergeLibs)
 set(LIBTOKUPORTABILITY "tokuportability" CACHE STRING "Name of libtokuportability.so")
 set(LIBTOKUDB "tokudb" CACHE STRING "Name of libtokudb.so")
 ## add an option for cilk
 option(USE_CILK "Use cilk in tokudb." OFF)
 ## can't use cilk without icc
 if (USE_CILK AND (NOT CMAKE_CXX_COMPILER_ID MATCHES Intel))
  message(FATAL_ERROR "You specified USE_CILK=ON so you need INTEL_CC=ON.")
 endif ()
 include_directories(
  ${VALGRIND_INCLUDE_DIR}
  )
--- a/cmake/merge_archives_unix.cmake.in
+++ b/cmake/merge_archives_unix.cmake.in
@ -22,19 +22,6 @@ SET(STATIC_LIBS "@STATIC_LIBS@")
 SET(CMAKE_CURRENT_BINARY_DIR "@CMAKE_CURRENT_BINARY_DIR@")
 SET(CMAKE_AR "@CMAKE_AR@")
 SET(CMAKE_RANLIB "@CMAKE_RANLIB@")
 SET(CMAKE_C_COMPILER "@CMAKE_C_COMPILER@")
 SET(CMAKE_C_COMPILER_ID "@CMAKE_C_COMPILER_ID@")
 SET(CMAKE_C_FLAGS "@CMAKE_C_FLAGS@")
 SET(CMAKE_C_FLAGS_DEBUG "@CMAKE_C_FLAGS_DEBUG@")
 SET(CMAKE_C_FLAGS_RELEASE "@CMAKE_C_FLAGS_RELEASE@")
 SET(CMAKE_CXX_COMPILER "@CMAKE_CXX_COMPILER@")
 SET(CMAKE_CXX_COMPILER_ID "@CMAKE_CXX_COMPILER_ID@")
 SET(CMAKE_CXX_FLAGS "@CMAKE_CXX_FLAGS@")
 SET(CMAKE_CXX_FLAGS_DEBUG "@CMAKE_CXX_FLAGS_DEBUG@")
 SET(CMAKE_CXX_FLAGS_RELEASE "@CMAKE_CXX_FLAGS_RELEASE@")
 SET(CMAKE_BUILD_TYPE "@CMAKE_BUILD_TYPE@")
 SET(CMAKE_TOP_BINARY_DIR "@CMAKE_TOP_BINARY_DIR@")
 SET(LIBTOKUPORTABILITY "@LIBTOKUPORTABILITY@")
 SET(TEMP_DIR ${CMAKE_CURRENT_BINARY_DIR}/merge_archives_${TARGET})
@ -49,12 +36,8 @@ FOREACH(LIB ${STATIC_LIBS})
    WORKING_DIRECTORY ${TEMP_SUBDIR}
    )
  FILE(GLOB_RECURSE LIB_OBJECTS "${TEMP_SUBDIR}/*.ilo")
  if (NOT LIB_OBJECTS)
    FILE(GLOB_RECURSE NONIPO_LIB_OBJECTS "${TEMP_SUBDIR}/*.o")
  ENDIF ()
  FILE(GLOB_RECURSE LIB_OBJECTS "${TEMP_SUBDIR}/*.o")
  SET(OBJECTS ${OBJECTS} ${LIB_OBJECTS})
  SET(EXTRA_OBJECTS ${EXTRA_OBJECTS} ${NONIPO_LIB_OBJECTS})
 ENDFOREACH()
 # Use relative paths, makes command line shorter.
@ -64,30 +47,11 @@ FOREACH(OBJ ${OBJECTS})
  FILE(TO_NATIVE_PATH ${OBJ} OBJ)
  SET(ALL_OBJECTS ${ALL_OBJECTS} ${OBJ})
 ENDFOREACH()
 FOREACH(OBJ ${EXTRA_OBJECTS})
  FILE(RELATIVE_PATH OBJ ${ABS_TEMP_DIR} ${OBJ})
  FILE(TO_NATIVE_PATH ${OBJ} OBJ)
  SET(ALL_EXTRA_OBJECTS ${ALL_EXTRA_OBJECTS} ${OBJ})
 ENDFOREACH()
 SET(TARGET_O ${TARGET}_combined.o)
 IF(CMAKE_BUILD_TYPE STREQUAL Release AND CMAKE_CXX_COMPILER_ID STREQUAL Intel)
  SET(flags "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE}")
  SEPARATE_ARGUMENTS(flags)
  EXECUTE_PROCESS(
    COMMAND ${CMAKE_CXX_COMPILER} ${flags} -ipo1 -ipo-c -diag-disable 10015 -o ${TARGET_O} ${ALL_OBJECTS}
    WORKING_DIRECTORY ${TEMP_DIR}
    )
  SET(TARGET_OBJECTS ${TARGET_O} ${ALL_EXTRA_OBJECTS})
 ELSE()
  SET(TARGET_OBJECTS ${ALL_OBJECTS} ${ALL_EXTRA_OBJECTS})
 ENDIF()
 FILE(TO_NATIVE_PATH ${TARGET_LOCATION} ${TARGET_LOCATION})
 # Now pack the objects into library with ar.
 EXECUTE_PROCESS(
  COMMAND ${CMAKE_AR} -r ${TARGET_LOCATION} ${TARGET_OBJECTS}
  COMMAND ${CMAKE_AR} -r ${TARGET_LOCATION} ${ALL_OBJECTS}
  WORKING_DIRECTORY ${TEMP_DIR}
 )
 EXECUTE_PROCESS(
--- a/cmake_modules/TokuFeatureDetection.cmake
+++ b/cmake_modules/TokuFeatureDetection.cmake
@ -22,6 +22,7 @@ check_include_files(libkern/OSByteOrder.h HAVE_LIBKERN_OSBYTEORDER_H)
 check_include_files(limits.h HAVE_LIMITS_H)
 check_include_files(machine/endian.h HAVE_MACHINE_ENDIAN_H)
 check_include_files(malloc.h HAVE_MALLOC_H)
 check_include_files(malloc/malloc.h HAVE_MALLOC_MALLOC_H)
 check_include_files(pthread.h HAVE_PTHREAD_H)
 check_include_files(stdint.h HAVE_STDINT_H)
 check_include_files(stdlib.h HAVE_STDLIB_H)
--- a/cmake_modules/TokuSetupCTest.cmake
+++ b/cmake_modules/TokuSetupCTest.cmake
@ -62,48 +62,9 @@ macro(hostname out)
  string(REGEX REPLACE "\\.tokutek\\.com$" "" ${out} ${fullhostname})
 endmacro(hostname)
 ## determines the current revision of ${svn_dir}
 macro(get_svn_revision svn_dir out)
  find_program(CMAKE_SVN_PROG svn)
  if(CMAKE_SVN_PROG MATCHES "CMAKE_SVN_PROG-NOTFOUND")
    message(ERROR "can't find svn")
  endif()
  find_program(CMAKE_AWK_PROG NAMES awk gawk)
  if(CMAKE_AWK_PROG MATCHES "CMAKE_AWK_PROG-NOTFOUND")
    message(ERROR "can't find awk or gawk")
  endif()
  execute_process(
    COMMAND ${CMAKE_SVN_PROG} info ${svn_dir}
    COMMAND ${CMAKE_AWK_PROG} "/Revision/ { print $2 }"
    OUTPUT_VARIABLE revision
    OUTPUT_STRIP_TRAILING_WHITESPACE)
  set(${out} ${revision})
 endmacro(get_svn_revision)
 ## determines whether you have local changes in ${svn_dir} (${out} will be
 ## either the empty string if it's clean, or "-dirty" if you have changes)
 macro(get_svn_wc_status svn_dir out)
  find_program(CMAKE_SVN_PROG svn)
  if(CMAKE_SVN_PROG MATCHES "CMAKE_SVN_PROG-NOTFOUND")
    message(ERROR "can't find svn")
  endif()
  find_program(CMAKE_AWK_PROG NAMES awk gawk)
  execute_process(
    COMMAND ${CMAKE_SVN_PROG} status -q ${svn_dir}
    OUTPUT_VARIABLE svn_status
    OUTPUT_STRIP_TRAILING_WHITESPACE)
  if(svn_status MATCHES "^$")
    set(${out} "")
  else()
    set(${out} "-dirty")
  endif()
 endmacro(get_svn_wc_status)
 ## gather machine info
 uname("-m" machine_type)
 real_executable_name("${CMAKE_CXX_COMPILER}" real_cxx_compiler)
 #get_svn_revision("${CMAKE_CURRENT_SOURCE_DIR}" svn_revision)  ## unused since it confuses cdash about history
 #get_svn_wc_status("${CMAKE_CURRENT_SOURCE_DIR}" wc_status)    ## unused since it confuses cdash about history
 get_filename_component(branchname "${CMAKE_CURRENT_SOURCE_DIR}" NAME)
 hostname(host)
 whoami(user)
--- a/cmake_modules/TokuSetupCompiler.cmake
+++ b/cmake_modules/TokuSetupCompiler.cmake
@ -2,11 +2,10 @@ function(add_c_defines)
  set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS ${ARGN})
 endfunction(add_c_defines)
 ## os name detection (threadpool-test.cc needs this)
 if (CMAKE_SYSTEM_NAME MATCHES Darwin)
 if (APPLE)
  add_c_defines(DARWIN=1 _DARWIN_C_SOURCE)
 elseif (CMAKE_SYSTEM_NAME MATCHES Linux)
 #  add_c_defines(__linux__=1)
  message(WARNING "Setting TOKU_ALLOW_DEPRECATED on Darwin and with clang.  TODO: find a portable way to deprecate, and remove this.")
  add_c_defines(TOKU_ALLOW_DEPRECATED)
 endif ()
 ## preprocessor definitions we want everywhere
@ -22,11 +21,6 @@ add_c_defines(
 ## add TOKU_PTHREAD_DEBUG for debug builds
 set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS_DEBUG TOKU_PTHREAD_DEBUG)
 if (CMAKE_SYSTEM_NAME STREQUAL Darwin OR CMAKE_CXX_COMPILER_ID MATCHES Clang)
  message(WARNING "Setting TOKU_ALLOW_DEPRECATED on Darwin and with clang.  TODO: remove this.")
  add_c_defines(TOKU_ALLOW_DEPRECATED)
 endif ()
 ## coverage
 option(USE_GCOV "Use gcov for test coverage." OFF)
 if (USE_GCOV)
@ -39,11 +33,6 @@ endif (USE_GCOV)
 include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 #####################################################
 ## Xcode needs to have this set manually.
 ## Other generators (makefiles) ignore this setting.
 set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
 ## adds a compiler flag if the compiler supports it
 macro(set_cflags_if_supported_named flag flagname)
  check_c_compiler_flag("${flag}" HAVE_C_${flagname})
@ -94,6 +83,7 @@ set_cflags_if_supported(
  -fno-rtti
  -fno-exceptions
  )
 ## set_cflags_if_supported_named("-Weffc++" -Weffcpp)
 ## Clang has stricter POD checks.  So, only enable this warning on our other builds (Linux + GCC)
 if (NOT CMAKE_CXX_COMPILER_ID MATCHES Clang)
@ -102,43 +92,28 @@ if (NOT CMAKE_CXX_COMPILER_ID MATCHES Clang)
    )
 endif ()
 ## set_cflags_if_supported_named("-Weffc++" -Weffcpp)
 ## this hits with optimized builds somewhere in ftleaf_split, we don't
 ## know why but we don't think it's a big deal
 set_ldflags_if_supported(
  -Wno-error=strict-overflow
  )
 ## set extra debugging flags and preprocessor definitions
 set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g3 -ggdb -O0")
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g3 -ggdb -O0")
 set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS_DEBUG FORTIFY_SOURCE=2)
 set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g3 -O0")
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g3 -O0")
 set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS_DEBUG _FORTIFY_SOURCE=2)
 ## set extra release flags, we overwrite this because the default passes -DNDEBUG and we don't want that
 if (CMAKE_CXX_COMPILER_ID STREQUAL Clang AND CMAKE_SYSTEM_NAME STREQUAL Darwin)
  set(CMAKE_C_FLAGS_RELEASE "-g -O4")
  set(CMAKE_CXX_FLAGS_RELEASE "-g -O4")
 else ()
 ## set extra release flags
 if (APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL Clang)
  # have tried -flto and -O4, both make our statically linked executables break apple's linker
  set(CMAKE_C_FLAGS_RELEASE "-g -O3")
  set(CMAKE_CXX_FLAGS_RELEASE "-g -O3")
  ## check how to do inter-procedural optimization
  check_c_compiler_flag(-flto HAVE_C_FLAG_FLTO)
  check_c_compiler_flag(-ipo HAVE_C_FLAG_IPO)
  if (HAVE_C_FLAG_FLTO)
    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -flto -fuse-linker-plugin")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -g -fuse-linker-plugin")
    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -g -fuse-linker-plugin")
  elseif (HAVE_C_FLAG_IPO)
    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -ip -ipo1")
  endif ()
  check_cxx_compiler_flag(-flto HAVE_CXX_FLAG_FLTO)
  check_cxx_compiler_flag(-ipo HAVE_CXX_FLAG_IPO)
  if (HAVE_CXX_FLAG_FLTO)
    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -flto -fuse-linker-plugin")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -g -fuse-linker-plugin")
    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -g -fuse-linker-plugin")
  elseif (HAVE_CXX_FLAG_IPO)
    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ip -ipo1")
  endif ()
 else ()
  # we overwrite this because the default passes -DNDEBUG and we don't want that
  set(CMAKE_C_FLAGS_RELEASE "-g -O3 -flto -fuse-linker-plugin")
  set(CMAKE_CXX_FLAGS_RELEASE "-g -O3 -flto -fuse-linker-plugin")
  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -g -fuse-linker-plugin")
  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -g -fuse-linker-plugin")
 endif ()
 option(USE_VALGRIND "Do not pass NVALGRIND to the compiler, because valgrind will be run on the generated executables." ON)
@ -146,80 +121,65 @@ if (NOT USE_VALGRIND)
  set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS_RELEASE NVALGRIND=1)
 endif ()
 ## We need to explicitly set this standard library for Xcode builds.
 ##add_definitions(-stdlib=libc++)
 if (CMAKE_CXX_COMPILER_ID MATCHES Intel)
  set(CMAKE_C_FLAGS "-std=c99 ${CMAKE_C_FLAGS}")
  set(CMAKE_CXX_FLAGS "-std=c++0x ${CMAKE_CXX_FLAGS}")
  ## make sure intel libs are linked statically
  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -static-intel")
 ## set warnings
 set(WARN_FLAGS
  -Wextra
  -Wbad-function-cast
  -Wno-missing-noreturn
  -Wstrict-prototypes
  -Wmissing-prototypes
  -Wmissing-declarations
  -Wpointer-arith
  -Wmissing-format-attribute
  -Wshadow
  ## other flags to try:
  #-Wunsafe-loop-optimizations
  #-Wpointer-arith
  #-Wc++-compat
  #-Wc++11-compat
  #-Wwrite-strings
  #-Wzero-as-null-pointer-constant
  #-Wlogical-op
  #-Wvector-optimization-performance
  )
  ## disable some intel-specific warnings
  set(intel_warnings
    94     # allow arrays of length 0
    411    # allow const struct members without a constructor
    589    # do not complain about goto that skips initialization
    1292   # icc lies (it says it is "__GNUC__", but it doesn't handle the resulting macroexpansions from glibc 2.15.37 (which is designed for gcc 4.7, and appears in Fedora 17)
    2259   # do not complain about "non-pointer conversion from int to u_int8_t (and other small types) may lose significant bits".  this produces too many false positives
    11000  # do not remark about multi-file optimizations, single-file optimizations, and object temp files
    11001
    11006
    11003  # do not complain if some file was compiled without -ipo
    )
  string(REGEX REPLACE ";" "," intel_warning_string "${intel_warnings}")
  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -diag-disable ${intel_warning_string}")
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -diag-disable ${intel_warning_string}")
  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -diag-disable ${intel_warning_string}")
  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -diag-disable ${intel_warning_string}")
 option(WARN_ABOUT_PACKED "Warn about useless __attribute__((packed)).  This generates lots of warnings." OFF)
 if (WARN_ABOUT_PACKED)
  list(APPEND WARN_FLAGS -Wpacked -Wno-error=packed)
 endif ()
  ## icc does -g differently
  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -debug all")
  set(CMAKE_C_FLAGS "-Wcheck ${CMAKE_C_FLAGS}")
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -debug all")
  set(CMAKE_CXX_FLAGS "-Wcheck ${CMAKE_CXX_FLAGS}")
 else()
  set(CMAKE_C_FLAGS "-std=c99 ${CMAKE_C_FLAGS}")
  set(CMAKE_CXX_FLAGS "-std=c++0x ${CMAKE_CXX_FLAGS}")
  ## set gcc warnings
  set(CMAKE_C_FLAGS "-Wextra ${CMAKE_C_FLAGS}")
  set(CMAKE_CXX_FLAGS "-Wextra ${CMAKE_CXX_FLAGS}")
  set(WARN_CFLAGS
    -Wbad-function-cast
    -Wno-missing-noreturn
    -Wstrict-prototypes
    -Wmissing-prototypes
    -Wmissing-declarations
    -Wpointer-arith
    -Wmissing-format-attribute
    )
  if (WARN_ABOUT_PACKED)
    list(APPEND WARN_CFLAGS -Wpacked -Wno-error=packed)
  endif ()
  ## other flags to try:
  ##  -Wunsafe-loop-optimizations
  ##  -Wpointer-arith
  ##  -Wc++-compat
  ##  -Wc++11-compat
  ##  -Wwrite-strings
  ##  -Wzero-as-null-pointer-constant
  ##  -Wlogical-op
  ##  -Wvector-optimization-performance
  if (CMAKE_SYSTEM_NAME STREQUAL Darwin)
    message(WARNING "Disabling -Wcast-align and -Wshadow on osx.  TODO: fix casting and shadowed declarations and re-enable them.")
  elseif (CMAKE_CXX_COMPILER_ID STREQUAL Clang)
    message(WARNING "Disabling -Wcast-align with clang.  TODO: fix casting and re-enable it.")
    list(APPEND WARN_CFLAGS -Wshadow)
  else ()
    list(APPEND WARN_CFLAGS -Wcast-align -Wshadow)
  endif ()
 endif()
 if (CMAKE_CXX_COMPILER_ID STREQUAL Clang)
  message(WARNING "Disabling -Wcast-align with clang.  TODO: fix casting and re-enable it.")
 else ()
  list(APPEND WARN_FLAGS -Wcast-align)
 endif ()
 set_cflags_if_supported(${WARN_CFLAGS})
 ## always want these
 set(CMAKE_C_FLAGS "-Wall -Werror ${CMAKE_C_FLAGS}")
 set(CMAKE_CXX_FLAGS "-Wall -Werror ${CMAKE_CXX_FLAGS}")
 ## need to set -stdlib=libc++ to get real c++11 support on darwin
 if (APPLE)
  if (CMAKE_GENERATOR STREQUAL Xcode)
    set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
  else ()
    set(CMAKE_CXX_FLAGS "-stdlib=libc++ ${CMAKE_CXX_FLAGS}")
  endif ()
 endif ()
 # pick language dialect
 set(CMAKE_C_FLAGS "-std=c99 ${CMAKE_C_FLAGS}")
 check_cxx_compiler_flag(-std=c++11 HAVE_STDCXX11)
 check_cxx_compiler_flag(-std=c++0x HAVE_STDCXX0X)
 if (HAVE_STDCXX11)
  set(CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
 elseif (HAVE_STDCXX0X)
  set(CMAKE_CXX_FLAGS "-std=c++0x ${CMAKE_CXX_FLAGS}")
 else ()
  message(FATAL_ERROR "${CMAKE_CXX_COMPILER} doesn't support -std=c++11 or -std=c++0x, you need one that does.")
 endif ()
 function(add_space_separated_property type obj propname val)
  get_property(oldval ${type} ${obj} PROPERTY ${propname})
  if (oldval MATCHES NOTFOUND)
@ -229,14 +189,6 @@ function(add_space_separated_property type obj propname val)
  endif ()
 endfunction(add_space_separated_property)
 function(set_targets_need_intel_libs)
  if (CMAKE_CXX_COMPILER_ID STREQUAL Intel)
    foreach(tgt ${ARGN})
      target_link_libraries(${tgt} LINK_PUBLIC -Bstatic irc -Bdynamic stdc++)
    endforeach(tgt)
  endif ()
 endfunction(set_targets_need_intel_libs)
 ## this function makes sure that the libraries passed to it get compiled
 ## with gcov-needed flags, we only add those flags to our libraries
 ## because we don't really care whether our tests get covered
@ -250,16 +202,10 @@ function(maybe_add_gcov_to_libraries)
  endif (USE_GCOV)
 endfunction(maybe_add_gcov_to_libraries)
 ## adds -fvisibility=hidden -fPIE to compile phase
 ## adds -pie (or -Wl,-pie) to link phase
 ## adds -fvisibility=hidden
 ## good for binaries
 function(add_common_options_to_binary_targets)
  foreach(tgt ${ARGN})
    if (CMAKE_C_COMPILER_ID STREQUAL Clang)
      add_space_separated_property(TARGET ${tgt} COMPILE_FLAGS "-fvisibility=hidden")
    else ()
      add_space_separated_property(TARGET ${tgt} COMPILE_FLAGS "-fvisibility=hidden -fPIE")
      add_space_separated_property(TARGET ${tgt} LINK_FLAGS "-fPIE -pie")
    endif ()
    add_space_separated_property(TARGET ${tgt} COMPILE_FLAGS "-fvisibility=hidden")
  endforeach(tgt)
 endfunction(add_common_options_to_binary_targets)
--- a/cmake_modules/TokuSetupIntelCompiler.cmake
+++ b/cmake_modules/TokuSetupIntelCompiler.cmake
@ -1,15 +0,0 @@
 option(INTEL_CC "Use the Intel compiler." OFF)
 if (INTEL_CC)
  find_program(CMAKE_C_COMPILER NAMES icc)
  find_program(CMAKE_CXX_COMPILER NAMES icpc)
  find_program(CMAKE_AR NAMES xiar)
  find_program(CMAKE_LINKER NAMES xild)
  if (CMAKE_C_COMPILER MATCHES CMAKE_C_COMPILER-NOTFOUND OR
      CMAKE_CXX_COMPILER MATCHES CMAKE_CXX_COMPILER-NOTFOUND OR
      CMAKE_AR MATCHES CMAKE_AR-NOTFOUND OR
      CMAKE_LINKER MATCHES CMAKE_LINKER-NOTFOUND)
    message(FATAL_ERROR "Cannot find Intel compiler.  You may need to run `source /opt/intel/bin/compilervars.sh intel64'")
  endif ()
 endif (INTEL_CC)
--- a/cmake_modules/TokuThirdParty.cmake
+++ b/cmake_modules/TokuThirdParty.cmake
@ -3,18 +3,14 @@ set(TOKU_SVNROOT "${TokuDB_SOURCE_DIR}/../.." CACHE FILEPATH "The top of the tok
 ## add lzma with an external project
 include(ExternalProject)
 set(xz_configure_opts --with-pic)
 if (CMAKE_SYSTEM_NAME MATCHES Darwin)
  ## lzma has some assembly that doesn't work on osx
 set(xz_configure_opts --with-pic --enable-static)
 if (APPLE)
  ## lzma has some assembly that doesn't work on darwin
  list(APPEND xz_configure_opts --disable-assembler)
 endif ()
 list(APPEND xz_configure_opts CC=${CMAKE_C_COMPILER})
 if (CMAKE_BUILD_TYPE MATCHES Release)
  if (CMAKE_C_COMPILER_ID MATCHES Intel)
    list(APPEND xz_configure_opts "CFLAGS=-O2 -g -ip -ipo1" AR=xiar)
  endif ()
 else ()
 if (NOT CMAKE_BUILD_TYPE MATCHES Release)
  list(APPEND xz_configure_opts --enable-debug)
 endif ()
--- a/db-benchmark-test/multi-bench.cc
+++ b/db-benchmark-test/multi-bench.cc
@ -76,7 +76,7 @@ static int inserter(struct keygen *keygen, DB_ENV *env, DB *db) {
        if (r != 0)
            break;
        if (verbose) printf("%d: %" PRIu64 "\n", (int) pthread_self(), k);
        if (verbose) printf("%" PRIdPTR ": %" PRIu64 "\n", (intptr_t) pthread_self(), k);
        DB_TXN *txn;
        r = env->txn_begin(env, NULL, &txn, 0);
@ -95,7 +95,7 @@ static int inserter(struct keygen *keygen, DB_ENV *env, DB *db) {
 }
 static void *inserter_wrap(void *arg) {
    if (verbose) printf("%d\n", (int) pthread_self());
    if (verbose) printf("%" PRIdPTR "\n", (intptr_t) pthread_self());
    struct inserter_arg *inserter_arg = (struct inserter_arg *) arg;
    int r = inserter(inserter_arg->keygen, inserter_arg->env, inserter_arg->db);
    assert(r == 0);
--- a/db-benchmark-test/scanscan.cc
+++ b/db-benchmark-test/scanscan.cc
@ -11,6 +11,7 @@
 #include <toku_assert.h>
 #include <db.h>
 #include <errno.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
 #include <fcntl.h>
@ -292,7 +293,7 @@ static int counttotalbytes (DBT const *key, DBT const *data, void *extrav) {
    struct extra_count *CAST_FROM_VOIDP(e, extrav);
    e->totalbytes += key->size + data->size;
    e->rowcounter++;
    if (do_mysql && 0) {
    if (do_mysql && false) {
        static uint64_t expect_key = 0;
        uint64_t k = mysql_get_bigint((unsigned char*)key->data+1);
        if (k != expect_key)
--- a/ft/CMakeLists.txt
+++ b/ft/CMakeLists.txt
@ -79,14 +79,15 @@ set(FT_SOURCES
  )
 add_library(ft SHARED ${FT_SOURCES})
 add_library(ft_static STATIC ${FT_SOURCES})
 add_library(ft_objects OBJECT ${FT_SOURCES})
 ## we're going to link this into libtokudb.so so it needs to have PIC
 add_space_separated_property(TARGET ft_static COMPILE_FLAGS -fPIC)
 maybe_add_gcov_to_libraries(ft ft_static)
 set_target_properties(ft_objects PROPERTIES POSITION_INDEPENDENT_CODE ON)
 maybe_add_gcov_to_libraries(ft ft_objects)
 add_library(ft_static STATIC $<TARGET_OBJECTS:ft_objects>)
 ## depend on other generated targets
 add_dependencies(ft install_tdb_h generate_log_code build_lzma)
 add_dependencies(ft_static install_tdb_h generate_log_code build_lzma)
 add_dependencies(ft_objects install_tdb_h generate_log_code build_lzma)
 ## link with lzma (which should be static) and link dependers with zlib
 target_link_libraries(ft LINK_PRIVATE lzma ${LIBTOKUPORTABILITY})
--- a/ft/cachetable.cc
+++ b/ft/cachetable.cc
@ -332,7 +332,7 @@ int toku_cachetable_openfd_with_filenum (CACHEFILE *cfptr, CACHETABLE ct, int fd
    }
    ct->cf_list.write_lock();
    for (extant = ct->cf_list.m_head; extant; extant = extant->next) {
        if (memcmp(&extant->fileid, &fileid, sizeof(fileid))==0) {
        if (toku_fileids_are_equal(&extant->fileid, &fileid)) {
            // Clients must serialize cachefile open, close, and unlink
            // So, during open, we should never see a closing cachefile 
            // or one that has been marked as unlink on close.
--- a/ft/partitioned_counter.cc
+++ b/ft/partitioned_counter.cc
@ -12,6 +12,42 @@
 #include "doubly_linked_list.h"
 #include "growable_array.h"
 #ifdef __APPLE__
 // TODO(leif): The __thread declspec is broken in ways I don't understand
 // on Darwin.  Partitioned counters use them and it would be prohibitive
 // to tease them apart before a week after 6.5.0, so instead, we're just
 // not going to use them in the most brutal way possible.  This is a
 // terrible implementation of the API in partitioned_counter.h but it
 // should be correct enough to release a non-performant version on OSX for
 // development.  Soon, we need to either make portable partitioned
 // counters, or we need to do this disabling in a portable way.
 struct partitioned_counter {
    uint64_t v;
 };
 PARTITIONED_COUNTER create_partitioned_counter(void) {
    PARTITIONED_COUNTER XCALLOC(counter);
    return counter;
 }
 void destroy_partitioned_counter(PARTITIONED_COUNTER counter) {
    toku_free(counter);
 }
 void increment_partitioned_counter(PARTITIONED_COUNTER counter, uint64_t delta) {
    (void) __sync_fetch_and_add(&counter->v, delta);
 }
 uint64_t read_partitioned_counter(PARTITIONED_COUNTER counter) {
    return counter->v;
 }
 void partitioned_counters_init(void) {}
 void partitioned_counters_destroy(void) {}
 #else // __APPLE__
 //******************************************************************************
 //
 // Representation: The representation of a partitioned counter comprises a
@ -333,3 +369,5 @@ void partitioned_counters_destroy(void)
    destroy_counters();
    pc_unlock();
 }
 #endif // __APPLE__
--- a/ft/recover.cc
+++ b/ft/recover.cc
@ -1503,7 +1503,7 @@ static int do_recovery(RECOVER_ENV renv, const char *env_dir, const char *log_di
    {
        // write a recovery log entry
        BYTESTRING recover_comment = { strlen("recover"), (char *) "recover" };
        BYTESTRING recover_comment = { static_cast<uint32_t>(strlen("recover")), (char *) "recover" };
        r = toku_log_comment(renv->logger, NULL, true, 0, recover_comment);
        assert(r == 0);
    }
--- a/ft/tests/cachetable-prefetch-getandpin-test.cc
+++ b/ft/tests/cachetable-prefetch-getandpin-test.cc
@ -126,11 +126,11 @@ static void cachetable_prefetch_maybegetandpin_test (bool do_partial_fetch) {
    r = toku_cachetable_get_and_pin(f1, key, fullhash, &v, &size, wc, fetch, pf_req_callback, pf_callback, true, NULL);
    assert(r == 0 && v == 0 && size == 2);
    struct timeval tend; 
    struct timeval tend;
    gettimeofday(&tend, NULL);
    assert(tdelta_usec(&tend, &tstart) >= 2000000); 
    assert(tdelta_usec(&tend, &tstart) >= 1900000);
    toku_cachetable_verify(ct);
    r = toku_test_cachetable_unpin(f1, key, fullhash, CACHETABLE_CLEAN, make_pair_attr(1));
--- a/ft/tests/cachetable-test.cc
+++ b/ft/tests/cachetable-test.cc
@ -63,9 +63,6 @@ struct item {
    const char *something;
 };
 static volatile int expect_n_flushes=0;
 static CACHEFILE expect_f;
 static void maybe_flush(CACHETABLE t) {
--- a/ft/tests/ftloader-test-extractor-errors.cc
+++ b/ft/tests/ftloader-test-extractor-errors.cc
@ -24,7 +24,7 @@ static void copy_dbt(DBT *dest, const DBT *src) {
 }
 static int generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_val = dest_val; src_key = src_key; src_val = src_val;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_val; (void) src_key; (void) src_val;
    copy_dbt(dest_key, src_key);
    copy_dbt(dest_val, src_val);
--- a/ft/tests/logcursor-timestamp.cc
+++ b/ft/tests/logcursor-timestamp.cc
@ -43,7 +43,7 @@ test_main (int argc, const char *argv[]) {
    r = toku_log_comment(logger, &lsn, 0, now(), bs0);
    assert(r == 0);
    sleep(10);
    sleep(11);
    BYTESTRING bs1 = { .len = 5, .data = (char *) "world" };
    r = toku_log_comment(logger, &lsn, 0, now(), bs1);
--- a/ft/tests/marked-omt-test.cc
+++ b/ft/tests/marked-omt-test.cc
@ -27,25 +27,29 @@ namespace test {
 static inline uint32_t fudge(const uint32_t x) { return x + 300; }
 static inline uint32_t defudge(const uint32_t fx) { return fx - 300; }
 static int test_iterator(const uint32_t &v, const uint32_t idx, bool *const UU(unused)) {
 int test_iterator(const uint32_t &v, const uint32_t idx, bool *const UU(unused));
 int test_iterator(const uint32_t &v, const uint32_t idx, bool *const UU(unused)) {
    invariant(defudge(v) == idx);
    return 0;
 }
 static int check_iterator_before(const uint32_t &v, const uint32_t idx, bool *const called) {
 int check_iterator_before(const uint32_t &v, const uint32_t idx, bool *const called);
 int check_iterator_before(const uint32_t &v, const uint32_t idx, bool *const called) {
    invariant(defudge(v) == idx);
    invariant(idx % 10 < 5);
    called[idx] = true;
    return 0;
 }
 static int check_iterator_after(const uint32_t &v, const uint32_t UU(idx), bool *const called) {
 int check_iterator_after(const uint32_t &v, const uint32_t UU(idx), bool *const called);
 int check_iterator_after(const uint32_t &v, const uint32_t UU(idx), bool *const called) {
    invariant(defudge(v) % 10 >= 5);
    called[defudge(v)] = true;
    return 0;
 }
 static int die(const uint32_t &UU(v), const uint32_t UU(idx), void *const UU(unused)) {
 int die(const uint32_t &UU(v), const uint32_t UU(idx), void *const UU(unused));
 int die(const uint32_t &UU(v), const uint32_t UU(idx), void *const UU(unused)) {
    abort();
    return 0; // hahaha
 }
@ -109,7 +113,8 @@ static void run_test(uint32_t nelts) {
 typedef omt<uint32_t, uint32_t, true> stress_omt;
 static int int_heaviside(const uint32_t &v, const uint32_t &target) {
 int int_heaviside(const uint32_t &v, const uint32_t &target);
 int int_heaviside(const uint32_t &v, const uint32_t &target) {
    return (v > target) - (v < target);
 }
@ -145,7 +150,7 @@ static void generate_range(struct random_data *rng, const struct stress_shared &
    if (range_limit > 1000) {
        range_limit = 1000;
    }
    *begin = rand_choices(rng, nelts);
    *begin = rand_choices(rng, nelts - 1);
    if (*begin + range_limit > nelts) {
        range_limit = nelts - *begin;
    }
@ -157,7 +162,8 @@ struct pair {
    uint32_t limit;
 };
 static int mark_read_iterator(const uint32_t &UU(v), const uint32_t idx, struct pair * const pair) {
 int mark_read_iterator(const uint32_t &UU(v), const uint32_t idx, struct pair * const pair);
 int mark_read_iterator(const uint32_t &UU(v), const uint32_t idx, struct pair * const pair) {
    invariant(defudge(v) == idx);
    invariant(idx >= pair->begin);
    invariant(idx < pair->limit);
@ -211,7 +217,8 @@ public:
    }
 };
 static int use_array_ftor(const uint32_t &v, const uint32_t UU(idx), array_ftor<uint32_t> *const fp) {
 int use_array_ftor(const uint32_t &v, const uint32_t UU(idx), array_ftor<uint32_t> *const fp);
 int use_array_ftor(const uint32_t &v, const uint32_t UU(idx), array_ftor<uint32_t> *const fp) {
    array_ftor<uint32_t> &f = *fp;
    f(v);
    return 0;
@ -266,7 +273,8 @@ static void simulate_reader_marks_on_array(struct reader_extra *const reader, co
    }
 }
 static int copy_marks(const uint32_t &v, const uint32_t idx, bool * const is_marked) {
 int copy_marks(const uint32_t &v, const uint32_t idx, bool * const is_marked);
 int copy_marks(const uint32_t &v, const uint32_t idx, bool * const is_marked) {
    invariant(defudge(v) == idx);
    is_marked[idx] = true;
    return 0;
--- a/ft/tests/omt-tmpl-test.cc
+++ b/ft/tests/omt-tmpl-test.cc
@ -5,11 +5,7 @@
 #ident "Copyright (c) 2007-2012 Tokutek Inc.  All rights reserved."
 #ident "The technology is licensed by the Massachusetts Institute of Technology, Rutgers State University of New Jersey, and the Research Foundation of State University of New York at Stony Brook under United States of America Serial No. 11/760379 and to the patents and/or patent applications resulting from it."
 #if defined(__ICL) || defined(__ICC)
 # define static_assert(foo, bar)
 #else
 # include <type_traits>
 #endif
 #include <type_traits>
 #include <toku_portability.h>
 #include <toku_assert.h>
 #include <toku_time.h>
@ -26,7 +22,8 @@ namespace test {
        TXNID one, two, three, four;
    };
    static inline int find_xid_one(const struct four_xids &xids, const TXNID &find) {
    inline int find_xid_one(const struct four_xids &xids, const TXNID &find);
    inline int find_xid_one(const struct four_xids &xids, const TXNID &find) {
        if (xids.one > find) {
            return 1;
        }
@ -36,7 +33,8 @@ namespace test {
        return 0;
    }
    static inline int find_xid_two(const struct four_xids &xids, const TXNID &find) {
    inline int find_xid_two(const struct four_xids &xids, const TXNID &find);
    inline int find_xid_two(const struct four_xids &xids, const TXNID &find) {
        if (xids.two > find) {
            return 1;
        }
@ -46,15 +44,17 @@ namespace test {
        return 0;
    }
    static inline int fx_iter(const struct four_xids &UU(xids), const uint32_t UU(idx), void *const UU(unused)) {
    inline int fx_iter(const struct four_xids &UU(xids), const uint32_t UU(idx), void *const UU(unused));
    inline int fx_iter(const struct four_xids &UU(xids), const uint32_t UU(idx), void *const UU(unused)) {
        return 0;
    }
    typedef omt<four_xids, four_xids *> fx_omt_t;
    static_assert(std::is_pod<fx_omt_t>::value, "fx_omt_t isn't POD");
    ENSURE_POD(fx_omt_t);
    static_assert(24 == sizeof(fx_omt_t), "fx_omt_t is bigger than 24 bytes");
    static inline int find_by_xid(const TOKUTXN &txn, const TXNID &findid) {
    inline int find_by_xid(const TOKUTXN &txn, const TXNID &findid);
    inline int find_by_xid(const TOKUTXN &txn, const TXNID &findid) {
        if (txn->txnid64 > findid) {
            return 1;
        }
@ -64,12 +64,13 @@ namespace test {
        return 0;
    }
    static inline int txn_iter(const TOKUTXN &UU(txn), const uint32_t UU(idx), void *const UU(unused)) {
    inline int txn_iter(const TOKUTXN &UU(txn), const uint32_t UU(idx), void *const UU(unused));
    inline int txn_iter(const TOKUTXN &UU(txn), const uint32_t UU(idx), void *const UU(unused)) {
        return 0;
    }
    typedef omt<TOKUTXN> txn_omt_t;
    static_assert(std::is_pod<txn_omt_t>::value, "txn_omt_t isn't POD");
    ENSURE_POD(txn_omt_t);
    static_assert(24 == sizeof(txn_omt_t), "txn_omt_t is bigger than 24 bytes");
    const int NTXNS = 1<<13;
@ -183,7 +184,8 @@ namespace test {
        printf("memused: %" PRId64 "\n", maxrss);
    }
    static inline int intcmp(const int &a, const int &b) {
    inline int intcmp(const int &a, const int &b);
    inline int intcmp(const int &a, const int &b) {
        if (a < b) {
            return -1;
        }
@ -196,7 +198,8 @@ namespace test {
    typedef omt<int> int_omt_t;
    static int intiter_magic = 0xdeadbeef;
    static int intiter(const int &value __attribute__((__unused__)), const uint32_t idx __attribute__((__unused__)), int *const extra) {
    inline int intiter(const int &value __attribute__((__unused__)), const uint32_t idx __attribute__((__unused__)), int *const extra);
    inline int intiter(const int &value __attribute__((__unused__)), const uint32_t idx __attribute__((__unused__)), int *const extra) {
        invariant(*extra == intiter_magic);
        return 0;
    }
@ -205,7 +208,8 @@ namespace test {
        int count;
        int last;
    };
    static int intiter2(const int &value, const uint32_t idx __attribute__((__unused__)), struct intiter2extra *const extra) {
    inline int intiter2(const int &value, const uint32_t idx __attribute__((__unused__)), struct intiter2extra *const extra);
    inline int intiter2(const int &value, const uint32_t idx __attribute__((__unused__)), struct intiter2extra *const extra) {
        extra->count++;
        invariant(extra->last < value);
        extra->last = value;
--- a/ft/tests/pqueue-test.cc
+++ b/ft/tests/pqueue-test.cc
@ -29,8 +29,8 @@ static inline DBT *dbt_init(DBT *dbt, void *data, uint32_t size) {
 }
 static void err_cb(DB *db, int which_db, int err, DBT *key, DBT *val, void *extra) {
    db = db; which_db = which_db; err = err; extra = extra;
    val = val;
    (void) db; (void) which_db; (void) err; (void) extra;
    (void) val;
    found_dup = *(int *)key->data;
    if (verbose) printf("err_cb : key <%d> val <%d>\n", *(int *)key->data, *(int *)val->data);
 }
--- a/ft/tests/test_partitioned_counter.cc
+++ b/ft/tests/test_partitioned_counter.cc
@ -292,7 +292,7 @@ static void *reader_test_fun (void *ta_v) {
 	assert(lastval <= thisval);
 	assert(thisval <= ta->limit+2);
 	lastval = thisval;
 	if (verboseness_cmdarg && (0==(thisval & (thisval-1)))) printf("ufc=%ld Thisval=%ld\n", ta->unfinished_count,thisval);
 	if (verboseness_cmdarg && (0==(thisval & (thisval-1)))) printf("ufc=%" PRIu64 " Thisval=%" PRIu64 "\n", ta->unfinished_count,thisval);
    }
    uint64_t thisval = read_partitioned_counter(ta->pc);
    assert(thisval==ta->limit+2); // we incremented two extra times in the test
--- a/ft/tests/test_toku_malloc_plain_free.cc
+++ b/ft/tests/test_toku_malloc_plain_free.cc
@ -13,7 +13,7 @@ int
 test_main (int argc, const char *argv[]) {
    default_parse_args(argc, argv);
    char *XMALLOC_N(5, m);
    m=m;
    (void)m;
    toku_free(m);
    return 0;
 }
--- a/portability/CMakeLists.txt
+++ b/portability/CMakeLists.txt
@ -14,7 +14,7 @@ add_library(${LIBTOKUPORTABILITY} SHARED ${tokuportability_srcs})
 add_library(${LIBTOKUPORTABILITY}_static STATIC ${tokuportability_srcs})
 maybe_add_gcov_to_libraries(${LIBTOKUPORTABILITY} ${LIBTOKUPORTABILITY}_static)
 set_property(TARGET ${LIBTOKUPORTABILITY} ${LIBTOKUPORTABILITY}_static APPEND PROPERTY COMPILE_DEFINITIONS _GNU_SOURCE)
 add_space_separated_property(TARGET ${LIBTOKUPORTABILITY}_static COMPILE_FLAGS -fPIC)
 set_target_properties(${LIBTOKUPORTABILITY}_static PROPERTIES POSITION_INDEPENDENT_CODE ON)
 target_link_libraries(${LIBTOKUPORTABILITY} LINK_PUBLIC ${CMAKE_THREAD_LIBS_INIT} dl)
 if (CMAKE_CXX_COMPILER_ID STREQUAL Intel)
--- a/portability/tests/CMakeLists.txt
+++ b/portability/tests/CMakeLists.txt
@ -26,12 +26,7 @@ if(BUILD_TESTING)
  foreach(test ${tests})
    add_executable(${test} ${test})
    target_link_libraries(${test} ${LIBTOKUPORTABILITY})
    if(${test} STREQUAL test-fair-rwlock)
      add_space_separated_property(TARGET ${test} COMPILE_FLAGS -fPIC)
      add_space_separated_property(TARGET ${test} LINK_FLAGS -fPIC)
    else()
      add_common_options_to_binary_targets(${test})
    endif()
    set_target_properties(${test} PROPERTIES POSITION_INDEPENDENT_CODE ON)
    if(HAVE_CLOCK_REALTIME)
      target_link_libraries(${test} rt)
    else()
--- a/portability/toku_os_types.h
+++ b/portability/toku_os_types.h
@ -6,7 +6,7 @@
 #if !defined(TOKU_OS_TYPES_H)
 #define TOKU_OS_TYPES_H
 #include <stdbool.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@ -17,6 +17,11 @@ struct fileid {
    ino_t st_ino;
 };
 __attribute__((const, nonnull, warn_unused_result))
 static inline bool toku_fileids_are_equal(struct fileid *a, struct fileid *b) {
    return a->st_dev == b->st_dev && a->st_ino == b->st_ino;
 }
 typedef struct stat toku_struct_stat;
 // windows compat
--- a/portability/toku_pthread.h
+++ b/portability/toku_pthread.h
@ -31,8 +31,9 @@ typedef struct timespec toku_timespec_t;
 typedef struct toku_mutex {
    pthread_mutex_t pmutex;
 #if TOKU_PTHREAD_DEBUG
    bool locked;
    pthread_t owner; // = pthread_self(); // for debugging
    bool locked;
    bool valid;
 #endif
 } toku_mutex_t;
@ -50,12 +51,16 @@ toku_mutex_init(toku_mutex_t *mutex, const toku_pthread_mutexattr_t *attr) {
    assert_zero(r);
 #if TOKU_PTHREAD_DEBUG
    mutex->locked = false;
    invariant(!mutex->valid);
    mutex->valid = true;
 #endif
 }
 static inline void
 toku_mutex_destroy(toku_mutex_t *mutex) {
 #if TOKU_PTHREAD_DEBUG
    invariant(mutex->valid);
    mutex->valid = false;
    invariant(!mutex->locked);
 #endif
    int r = pthread_mutex_destroy(&mutex->pmutex);
@ -67,6 +72,7 @@ toku_mutex_lock(toku_mutex_t *mutex) {
    int r = pthread_mutex_lock(&mutex->pmutex);
    assert_zero(r);
 #if TOKU_PTHREAD_DEBUG
    invariant(mutex->valid);
    invariant(!mutex->locked);
    mutex->locked = true;
    mutex->owner = pthread_self();
@ -76,6 +82,7 @@ toku_mutex_lock(toku_mutex_t *mutex) {
 static inline void
 toku_mutex_unlock(toku_mutex_t *mutex) {
 #if TOKU_PTHREAD_DEBUG
    invariant(mutex->valid);
    invariant(mutex->locked);
    mutex->locked = false;
    mutex->owner = 0;
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@ -26,21 +26,9 @@ target_link_libraries(${LIBTOKUDB} LINK_PUBLIC z)
 ## make the static library
 add_library(tokudb_static_conv STATIC ${tokudb_srcs})
 add_dependencies(tokudb_static_conv install_tdb_h generate_log_code)
 add_space_separated_property(TARGET tokudb_static_conv COMPILE_FLAGS -fPIC)
 set(tokudb_required_libs tokudb_static_conv lock_tree_static range_tree_static
    ft_static lzma ${LIBTOKUPORTABILITY} z ${CMAKE_THREAD_LIBS_INIT} dl)
 if (CMAKE_CXX_COMPILER_ID STREQUAL Intel)
  find_library(IRC_LIBRARIES NAMES libirc.a irc PATHS ENV LIBRARY_PATH)
  add_library(irc_fullpath STATIC IMPORTED)
  set_target_properties(irc_fullpath PROPERTIES IMPORTED_LOCATION ${IRC_LIBRARIES})
  list(APPEND tokudb_required_libs irc_fullpath)
 endif ()
 set(CMAKE_TOP_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/..")
 merge_static_libs(${LIBTOKUDB}_static ${LIBTOKUDB}_static "${tokudb_required_libs}")
 if (CMAKE_CXX_COMPILER_ID STREQUAL Intel)
  target_link_libraries(${LIBTOKUDB} LINK_PRIVATE -nodefaultlibs)
 endif ()
 set_target_properties(tokudb_static_conv PROPERTIES POSITION_INDEPENDENT_CODE ON)
 set(tokudb_source_libs tokudb_static_conv lock_tree_static range_tree_static ft_static lzma ${LIBTOKUPORTABILITY} z ${CMAKE_THREAD_LIBS_INIT} dl)
 merge_static_libs(${LIBTOKUDB}_static ${LIBTOKUDB}_static "${tokudb_source_libs}")
 ## add a version script and set -fvisibility=hidden for the shared library
 configure_file(export.map . COPYONLY)
@ -50,10 +38,8 @@ if (NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)
 endif ()
 ## add gcov and define _GNU_SOURCE
 maybe_add_gcov_to_libraries(${LIBTOKUDB} tokudb_static_conv)
 set_property(TARGET ${LIBTOKUDB} tokudb_static_conv APPEND PROPERTY COMPILE_DEFINITIONS _GNU_SOURCE)
 set_targets_need_intel_libs(${LIBTOKUDB})
 maybe_add_gcov_to_libraries(${LIBTOKUDB} ${LIBTOKUDB}_static)
 set_property(TARGET ${LIBTOKUDB} ${LIBTOKUDB}_static APPEND PROPERTY COMPILE_DEFINITIONS _GNU_SOURCE)
 install(
  TARGETS ${LIBTOKUDB} ${LIBTOKUDB}_static
--- a/src/lock_tree/CMakeLists.txt
+++ b/src/lock_tree/CMakeLists.txt
@ -14,20 +14,16 @@ set_property(TARGET lock_tree_tlog APPEND PROPERTY
 target_link_libraries(lock_tree_tlog range_tree_tlog)
 add_dependencies(lock_tree_tlog install_tdb_h)
 set_targets_need_intel_libs(lock_tree_lin lock_tree_tlog)
 if (CMAKE_CXX_COMPILER_ID STREQUAL Intel)
  add_space_separated_property(TARGET lock_tree_lin LINK_FLAGS "-diag-disable 10237")
  add_space_separated_property(TARGET lock_tree_tlog LINK_FLAGS "-diag-disable 10237")
 endif ()
 ## make the real library, it's going to go into libtokudb.so so it needs
 ## to be PIC
 add_library(lock_tree_static STATIC ${lock_tree_srcs})
 add_space_separated_property(TARGET lock_tree_static COMPILE_FLAGS "-fvisibility=hidden -fPIC")
 set_property(TARGET lock_tree_static APPEND PROPERTY
 add_library(lock_tree_objects OBJECT ${lock_tree_srcs})
 set_target_properties(lock_tree_objects PROPERTIES POSITION_INDEPENDENT_CODE ON)
 add_space_separated_property(TARGET lock_tree_objects COMPILE_FLAGS "-fvisibility=hidden")
 set_property(TARGET lock_tree_objects APPEND PROPERTY
  COMPILE_DEFINITIONS TOKU_RT_NOOVERLAPS)
 add_dependencies(lock_tree_static install_tdb_h)
 add_dependencies(lock_tree_objects install_tdb_h)
 maybe_add_gcov_to_libraries(lock_tree_lin lock_tree_tlog lock_tree_static)
 maybe_add_gcov_to_libraries(lock_tree_lin lock_tree_tlog lock_tree_objects)
 add_library(lock_tree_static STATIC $<TARGET_OBJECTS:lock_tree_objects>)
 add_subdirectory(tests)
--- a/src/lock_tree/tests/test_footprint_point_write.cc
+++ b/src/lock_tree/tests/test_footprint_point_write.cc
@ -17,6 +17,9 @@
 # include <malloc.h>
 #elif defined(HAVE_SYS_MALLOC_H)
 # include <sys/malloc.h>
 # if defined(HAVE_MALLOC_MALLOC_H)
 #  include <malloc/malloc.h>
 # endif
 #endif
 #include "test.h"
 #include <toku_byteswap.h>
@ -30,12 +33,12 @@ static uint64_t htonl64(uint64_t x) {
 #endif
 }
 typedef size_t (*malloc_usable_size_fun_t)(void *p);
 #if defined(HAVE_MALLOC_USABLE_SIZE)
 typedef size_t (*malloc_usable_size_fun_t)(void *p);
 size_t malloc_usable_size(void *p) __THROW;
 static malloc_usable_size_fun_t malloc_usable_size_f = malloc_usable_size;
 #elif defined(HAVE_MALLOC_SIZE)
 size_t malloc_size(void *p) __THROW;
 typedef size_t (*malloc_usable_size_fun_t)(const void *p);
 static malloc_usable_size_fun_t malloc_usable_size_f = malloc_size;
 #endif
--- a/src/lock_tree/tests/test_footprint_range_write.cc
+++ b/src/lock_tree/tests/test_footprint_range_write.cc
@ -17,6 +17,9 @@
 # include <malloc.h>
 #elif defined(HAVE_SYS_MALLOC_H)
 # include <sys/malloc.h>
 # if defined(HAVE_MALLOC_MALLOC_H)
 #  include <malloc/malloc.h>
 # endif
 #endif
 #include "test.h"
 #include <toku_byteswap.h>
@ -30,12 +33,12 @@ static uint64_t htonl64(uint64_t x) {
 #endif
 }
 typedef size_t (*malloc_usable_size_fun_t)(void *p);
 #if defined(HAVE_MALLOC_USABLE_SIZE)
 typedef size_t (*malloc_usable_size_fun_t)(void *p);
 size_t malloc_usable_size(void *p) __THROW;
 static malloc_usable_size_fun_t malloc_usable_size_f = malloc_usable_size;
 #elif defined(HAVE_MALLOC_SIZE)
 size_t malloc_size(void *p) __THROW;
 typedef size_t (*malloc_usable_size_fun_t)(const void *p);
 static malloc_usable_size_fun_t malloc_usable_size_f = malloc_size;
 #endif
--- a/src/range_tree/CMakeLists.txt
+++ b/src/range_tree/CMakeLists.txt
@ -10,18 +10,15 @@ add_library(range_tree_tlog SHARED log_nooverlap)
 target_link_libraries(range_tree_tlog ft ${LIBTOKUPORTABILITY})
 add_dependencies(range_tree_tlog install_tdb_h)
 set_targets_need_intel_libs(range_tree_lin range_tree_tlog)
 if (CMAKE_CXX_COMPILER_ID STREQUAL Intel)
  add_space_separated_property(TARGET range_tree_lin LINK_FLAGS "-diag-disable 10237")
  add_space_separated_property(TARGET range_tree_tlog LINK_FLAGS "-diag-disable 10237")
 endif ()
 ## make the real library, it's going to go into libtokudb.so so it needs
 ## to be PIC
 add_library(range_tree_static STATIC log_nooverlap)
 add_space_separated_property(TARGET range_tree_static COMPILE_FLAGS "-fvisibility=hidden -fPIC")
 add_dependencies(range_tree_static install_tdb_h)
 add_library(range_tree_objects OBJECT log_nooverlap)
 set_target_properties(range_tree_objects PROPERTIES POSITION_INDEPENDENT_CODE ON)
 add_space_separated_property(TARGET range_tree_objects COMPILE_FLAGS "-fvisibility=hidden")
 add_dependencies(range_tree_objects install_tdb_h)
 maybe_add_gcov_to_libraries(range_tree_lin range_tree_tlog range_tree_objects)
 maybe_add_gcov_to_libraries(range_tree_lin range_tree_tlog range_tree_static)
 add_library(range_tree_static STATIC $<TARGET_OBJECTS:range_tree_objects>)
 add_subdirectory(tests)
--- a/src/tests/del-multiple-huge-primary-row.cc
+++ b/src/tests/del-multiple-huge-primary-row.cc
@ -22,7 +22,7 @@ get_data(int *v, int i, int ndbs) {
 static int
 del_callback(DB *dest_db, DB *src_db, DBT *dest_key, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) src_key; (void) src_data;
    assert(src_db == NULL);
    unsigned int dbnum;
--- a/src/tests/del-multiple-srcdb.cc
+++ b/src/tests/del-multiple-srcdb.cc
@ -22,7 +22,7 @@ get_data(int *v, int i, int ndbs) {
 static int
 del_callback(DB *dest_db, DB *src_db, DBT *dest_key, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) src_key; (void) src_data;
    unsigned int dbnum;
    assert(dest_db->descriptor->dbt.size == sizeof dbnum);
--- a/src/tests/del-multiple.cc
+++ b/src/tests/del-multiple.cc
@ -22,7 +22,7 @@ get_data(int *v, int i, int ndbs) {
 static int
 del_callback(DB *dest_db, DB *src_db, DBT *dest_key, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) src_key; (void) src_data;
    assert(src_db == NULL);
    unsigned int dbnum;
--- a/src/tests/env-put-multiple.cc
+++ b/src/tests/env-put-multiple.cc
@ -30,7 +30,7 @@ DBT dest_vals[MAX_DBS];
 static int
 put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) {
    src_db = src_db;
    (void) src_db;
    uint32_t which = *(uint32_t*)dest_db->app_private;
    assert(which < MAX_DBS);
--- a/src/tests/hotindexer-insert-committed-optimized.cc
+++ b/src/tests/hotindexer-insert-committed-optimized.cc
@ -21,7 +21,7 @@ struct kv_pair kv_pairs[NUM_KV_PAIRS] = {{1,4},
 static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) {
    src_db = src_db;
    (void) src_db;
    uint32_t which = (uint32_t) (intptr_t) dest_db->app_private;
    assert(which == 0);
@ -37,8 +37,8 @@ static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *de
 }
 static int poll_print(void *extra, float progress) {
    progress = progress;
    extra = extra;
    (void) progress;
    (void) extra;
    if ( verbose ) printf("poll_print %f\n", progress);
    return 0;
 }
--- a/src/tests/hotindexer-insert-committed.cc
+++ b/src/tests/hotindexer-insert-committed.cc
@ -21,7 +21,7 @@ struct kv_pair kv_pairs[NUM_KV_PAIRS] = {{1,4},
 static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) {
    src_db = src_db;
    (void) src_db;
    uint32_t which = (uint32_t) (intptr_t) dest_db->app_private;
    assert(which == 0);
@ -37,8 +37,8 @@ static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *de
 }
 static int poll_print(void *extra, float progress) {
    progress = progress;
    extra = extra;
    (void) progress;
    (void) extra;
    if ( verbose ) printf("poll_print %f\n", progress);
    return 0;
 }
--- a/src/tests/hotindexer-insert-provisional.cc
+++ b/src/tests/hotindexer-insert-provisional.cc
@ -21,7 +21,7 @@ struct kv_pair kv_pairs[NUM_KV_PAIRS] = {{1,4},
 static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) {
    src_db = src_db;
    (void) src_db;
    uint32_t which = (uint32_t) (intptr_t) dest_db->app_private;
    assert(which == 0);
@ -37,8 +37,8 @@ static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *de
 }
 static int poll_print(void *extra, float progress) {
    progress = progress;
    extra = extra;
    (void) progress;
    (void) extra;
    if ( verbose ) printf("poll_print %f\n", progress);
    return 0;
 }
--- a/src/tests/hotindexer-lock-test.cc
+++ b/src/tests/hotindexer-lock-test.cc
@ -21,7 +21,7 @@ struct kv_pair kv_pairs[NUM_KV_PAIRS] = {{1,4},
 static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) {
    src_db = src_db;
    (void) src_db;
    uint32_t which = (uint32_t) (intptr_t) dest_db->app_private;
    assert(which == 0);
@ -37,8 +37,8 @@ static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *de
 }
 static int poll_print(void *extra, float progress) {
    progress = progress;
    extra = extra;
    (void) progress;
    (void) extra;
    if ( verbose ) printf("poll_print %f\n", progress);
    return 0;
 }
--- a/src/tests/hotindexer-nested-insert-committed.cc
+++ b/src/tests/hotindexer-nested-insert-committed.cc
@ -21,7 +21,7 @@ struct kv_pair kv_pairs[NUM_KV_PAIRS] = {{1,4},
 static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) {
    src_db = src_db;
    (void) src_db;
    uint32_t which = (uint32_t) (intptr_t) dest_db->app_private;
    assert(which == 0);
@ -37,8 +37,8 @@ static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *de
 }
 static int poll_print(void *extra, float progress) {
    progress = progress;
    extra = extra;
    (void) progress;
    (void) extra;
    if ( verbose ) printf("poll_print %f\n", progress);
    return 0;
 }
--- a/src/tests/hotindexer-put-abort.cc
+++ b/src/tests/hotindexer-put-abort.cc
@ -13,8 +13,7 @@
 static int
 put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_data = dest_data; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_data; (void) src_key; (void) src_data;
    lazy_assert(src_db != NULL && dest_db != NULL);
    if (dest_key->flags == DB_DBT_REALLOC) {
--- a/src/tests/hotindexer-put-commit.cc
+++ b/src/tests/hotindexer-put-commit.cc
@ -13,7 +13,7 @@
 static int
 put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_data = dest_data; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_data; (void) src_key; (void) src_data;
    lazy_assert(src_db != NULL && dest_db != NULL);
--- a/src/tests/hotindexer-put-multiple.cc
+++ b/src/tests/hotindexer-put-multiple.cc
@ -21,7 +21,7 @@ struct kv_pair kv_pairs[NUM_KV_PAIRS] = {{1,4},
 static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) {
    src_db = src_db;
    (void) src_db;
    uint32_t which = (uint32_t) (intptr_t) dest_db->app_private;
@ -42,8 +42,8 @@ static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *de
 }
 static int poll_print(void *extra, float progress) {
    progress = progress;
    extra = extra;
    (void) progress;
    (void) extra;
    if ( verbose ) printf("poll_print %f\n", progress);
    return 0;
 }
--- a/src/tests/hotindexer-simple-abort-put.cc
+++ b/src/tests/hotindexer-simple-abort-put.cc
@ -7,8 +7,7 @@
 static int
 put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_data = dest_data; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_data; (void) src_key; (void) src_data;
    lazy_assert(src_db != NULL && dest_db != NULL);
    dest_key->data = toku_xmemdup(src_data->data, src_data->size);
--- a/src/tests/hotindexer-simple-abort.cc
+++ b/src/tests/hotindexer-simple-abort.cc
@ -7,7 +7,7 @@
 static int
 put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_data = dest_data; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_data; (void) src_key; (void) src_data;
    lazy_assert(src_db != NULL && dest_db != NULL);
--- a/src/tests/hotindexer-undo-do-test.cc
+++ b/src/tests/hotindexer-undo-do-test.cc
@ -164,7 +164,7 @@ print_dbt(DBT *dbt) {
 static int
 put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_data = dest_data; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_data; (void) src_key; (void) src_data;
    lazy_assert(src_db != NULL && dest_db != NULL);
@ -201,7 +201,7 @@ put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *
 static int
 del_callback(DB *dest_db, DB *src_db, DBT *dest_key, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) src_key; (void) src_data;
    lazy_assert(src_db != NULL && dest_db != NULL);
--- a/src/tests/key-val.h
+++ b/src/tests/key-val.h
@ -92,7 +92,7 @@ static uint32_t UU() pkey_for_val(int key, int i) {
 // for the handlerton's generate_row_for_put().
 static int UU() put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) {
    src_db = src_db;
    (void) src_db;
    uint32_t which = *(uint32_t*)dest_db->app_private;
@ -155,7 +155,7 @@ static int UU() poll_print(void *extra, float progress) {
            last_progress = progress;
        }
    }    
    extra = extra;
    (void) extra;
    return 0;
 }
--- a/src/tests/loader-cleanup-test.cc
+++ b/src/tests/loader-cleanup-test.cc
@ -462,7 +462,7 @@ static unsigned int pkey_for_val(int key, int i) {
 // for the handlerton's generate_row_for_put().
 static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) {
    src_db = src_db;
    (void) src_db;
    uint32_t which = *(uint32_t*)dest_db->app_private;
--- a/src/tests/loader-dup-test.cc
+++ b/src/tests/loader-dup-test.cc
@ -91,7 +91,7 @@ static unsigned int pkey_for_val(int key, int i) {
 // for the handlerton's generate_row_for_put().
 static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) {
    src_db = src_db;
    (void) src_db;
    uint32_t which = *(uint32_t*)dest_db->app_private;
@ -188,7 +188,7 @@ static void error_callback (DB *db, int which_db, int err, DBT *key, DBT *val, v
    assert(which_db==0);
    struct error_extra *e =(struct error_extra *)extra;
    assert(e->bad_i == *(int*)key->data);
    val=val;
    (void)val;
    assert(e->error_count==0);
    e->error_count++;
 }
--- a/src/tests/loader-no-puts.cc
+++ b/src/tests/loader-no-puts.cc
@ -25,7 +25,7 @@ struct kv_pair kv_pairs[NUM_KV_PAIRS] = {{1,4},
 static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) {
    src_db = src_db;
    (void) src_db;
    uint32_t which = *(uint32_t*)dest_db->app_private;
    assert(which == 0);
--- a/src/tests/loader-reference-test.cc
+++ b/src/tests/loader-reference-test.cc
@ -26,7 +26,7 @@ static uint32_t block_size = 0;
 static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) {
    src_db = src_db;
    (void) src_db;
    uint32_t which = *(uint32_t*)dest_db->app_private;
    assert(which == 0);
--- a/src/tests/loader-stress-del.cc
+++ b/src/tests/loader-stress-del.cc
@ -169,7 +169,7 @@ static unsigned int pkey_for_val(int key, int i) {
 // for the handlerton's generate_row_for_put().
 static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) {
    src_db = src_db;
    (void) src_db;
    uint32_t which = *(uint32_t*)dest_db->app_private;
--- a/src/tests/loader-stress-test.cc
+++ b/src/tests/loader-stress-test.cc
@ -177,7 +177,7 @@ static unsigned int pkey_for_val(int key, int i) {
 // for the handlerton's generate_row_for_put().
 static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) {
    src_db = src_db;
    (void) src_db;
    uint32_t which = *(uint32_t*)dest_db->app_private;
--- a/src/tests/loader-tpch-load.cc
+++ b/src/tests/loader-tpch-load.cc
@ -97,8 +97,8 @@ static int generate_rows_for_region(DB *dest_db, DB *src_db, DBT *dest_key, DBT
 {
    // not used
    src_db  = src_db;
    src_key = src_key;
    (void) src_db;
    (void) src_key;
    assert(*(uint32_t*)dest_db->app_private == 0);
    // region fields
@ -148,8 +148,8 @@ static int generate_rows_for_region(DB *dest_db, DB *src_db, DBT *dest_key, DBT
 static int generate_rows_for_lineitem(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) 
 {
    // not used
    src_db  = src_db;
    src_key = src_key;
    (void) src_db;
    (void) src_key;
    // lineitem fields
    char orderkey[16];   
--- a/src/tests/powerfail.cc
+++ b/src/tests/powerfail.cc
@ -54,7 +54,7 @@ static void close_dbs (void) {
 }
 static long shuffle (long l, int i) {
    i=i;
    (void)i;
    return l;
 }
--- a/src/tests/put-multiple.cc
+++ b/src/tests/put-multiple.cc
@ -22,7 +22,7 @@ get_data(int *v, int i, int ndbs) {
 static int
 put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_data = dest_data; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_data; (void) src_key; (void) src_data;
    assert(src_db == NULL);
    unsigned int dbnum;
--- a/src/tests/recover-del-multiple-abort.cc
+++ b/src/tests/recover-del-multiple-abort.cc
@ -23,7 +23,7 @@ get_data(int *v, int i, int ndbs) {
 static int
 put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_data = dest_data; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_data; (void) src_key; (void) src_data;
    assert(src_db == NULL);
    unsigned int dbnum;
--- a/src/tests/recover-del-multiple-srcdb-fdelete-all.cc
+++ b/src/tests/recover-del-multiple-srcdb-fdelete-all.cc
@ -23,7 +23,7 @@ get_data(int *v, int i, int ndbs) {
 static int
 put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_data = dest_data; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_data; (void) src_key; (void) src_data;
    assert(src_db != NULL);
    unsigned int dbnum;
--- a/src/tests/recover-del-multiple.cc
+++ b/src/tests/recover-del-multiple.cc
@ -23,7 +23,7 @@ get_data(int *v, int i, int ndbs) {
 static int
 put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_data = dest_data; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_data; (void) src_key; (void) src_data;
    assert(src_db == NULL);
    unsigned int dbnum;
--- a/src/tests/recover-hotindexer-simple-abort-put.cc
+++ b/src/tests/recover-hotindexer-simple-abort-put.cc
@ -7,7 +7,7 @@
 static int
 put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_data = dest_data; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_data; (void) src_key; (void) src_data;
    lazy_assert(src_db != NULL && dest_db != NULL);
--- a/src/tests/recover-loader-test.cc
+++ b/src/tests/recover-loader-test.cc
@ -225,7 +225,7 @@ static unsigned int generate_val(int key, int i) {
 // for the handlerton's generate_row_for_put().
 static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) {
    src_db = src_db;
    (void) src_db;
    uint32_t which = *(uint32_t*)dest_db->app_private;
--- a/src/tests/recover-put-multiple-abort.cc
+++ b/src/tests/recover-put-multiple-abort.cc
@ -23,7 +23,7 @@ get_data(int *v, int i, int ndbs) {
 static int
 put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_data = dest_data; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_data; (void) src_key; (void) src_data;
    assert(src_db == NULL);
    unsigned int dbnum;
--- a/src/tests/recover-put-multiple.cc
+++ b/src/tests/recover-put-multiple.cc
@ -23,7 +23,7 @@ get_data(int *v, int i, int ndbs) {
 static int
 put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_data = dest_data; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_data; (void) src_key; (void) src_data;
    assert(src_db == NULL);
    unsigned int dbnum;
--- a/src/tests/recover-split-checkpoint.cc
+++ b/src/tests/recover-split-checkpoint.cc
@ -26,7 +26,7 @@ static void test_checkpoint_callback(void *extra) {
 }
 static void test_checkpoint_callback2(void *extra) {
    extra = extra;
    (void) extra;
 }
 static void run_test (bool do_commit, bool do_abort) {
@ -63,7 +63,7 @@ static void run_test (bool do_commit, bool do_abort) {
 }
 static void run_recover (bool did_commit) {
    did_commit = did_commit;
    (void) did_commit;
    int r;
    DB_ENV *env = NULL;
    r = db_env_create(&env, 0);                                                             CKERR(r);
--- a/src/tests/recover-test-logsuppress-put.cc
+++ b/src/tests/recover-test-logsuppress-put.cc
@ -30,7 +30,7 @@ DB_TXN *child;
 // for the handlerton's generate_row_for_put().
 static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) {
    src_db = src_db;
    (void) src_db;
    uint32_t which = *(uint32_t*)dest_db->app_private;
--- a/src/tests/recover-test-logsuppress.cc
+++ b/src/tests/recover-test-logsuppress.cc
@ -30,7 +30,7 @@ DB_TXN *child;
 // for the handlerton's generate_row_for_put().
 static int put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val) {
    src_db = src_db;
    (void) src_db;
    uint32_t which = *(uint32_t*)dest_db->app_private;
--- a/src/tests/recover-update-multiple-abort.cc
+++ b/src/tests/recover-update-multiple-abort.cc
@ -38,7 +38,7 @@ get_new_data(int *v, int i, int ndbs) {
 static int
 put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_data = dest_data; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_data; (void) src_key; (void) src_data;
    assert(src_db == NULL);
    unsigned int dbnum;
--- a/src/tests/recover-update-multiple.cc
+++ b/src/tests/recover-update-multiple.cc
@ -38,7 +38,7 @@ get_new_data(int *v, int i, int ndbs) {
 static int
 put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_data = dest_data; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_data; (void) src_key; (void) src_data;
    assert(src_db == NULL);
    unsigned int dbnum;
--- a/src/tests/test_kv_gen.h
+++ b/src/tests/test_kv_gen.h
@ -151,8 +151,8 @@ check_results(DB_ENV *env, DB **dbs, const int num_dbs, const int num_rows)
 static int UU() 
 put_multiple_generate(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_val, const DBT *src_key, const DBT *src_val, void *extra) {
    src_db = src_db;
    extra = extra;
    (void) src_db;
    (void) extra;
    uint32_t which = *(uint32_t*)dest_db->app_private;
--- a/src/tests/update-multiple-data-diagonal.cc
+++ b/src/tests/update-multiple-data-diagonal.cc
@ -36,7 +36,7 @@ get_new_data(int *v, int i, int ndbs) {
 static int
 put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_data = dest_data; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_data; (void) src_key; (void) src_data;
    unsigned int dbnum;
    assert(dest_db->descriptor->dbt.size == sizeof dbnum);
--- a/src/tests/update-multiple-key0.cc
+++ b/src/tests/update-multiple-key0.cc
@ -21,7 +21,7 @@ get_data(int *v, int i, int ndbs) {
 static int
 put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_data = dest_data; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_data; (void) src_key; (void) src_data;
    unsigned int dbnum;
    assert(dest_db->descriptor->dbt.size == sizeof dbnum);
--- a/src/tests/update-multiple-nochange.cc
+++ b/src/tests/update-multiple-nochange.cc
@ -21,7 +21,7 @@ get_data(int *v, int i, int ndbs) {
 static int
 put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_data = dest_data; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_data; (void) src_key; (void) src_data;
    unsigned int dbnum;
    assert(dest_db->descriptor->dbt.size == sizeof dbnum);
--- a/src/tests/update-multiple-with-indexer.cc
+++ b/src/tests/update-multiple-with-indexer.cc
@ -36,7 +36,7 @@ get_new_data(int *v, int i, int ndbs) {
 static int
 put_callback(DB *dest_db, DB *src_db, DBT *dest_key, DBT *dest_data, const DBT *src_key, const DBT *src_data) {
    dest_db = dest_db; src_db = src_db; dest_key = dest_key; dest_data = dest_data; src_key = src_key; src_data = src_data;
    (void) dest_db; (void) src_db; (void) dest_key; (void) dest_data; (void) src_key; (void) src_data;
    unsigned int dbnum;
    assert(dest_db->descriptor->dbt.size == sizeof dbnum);
--- a/src/ydb_txn.cc
+++ b/src/ydb_txn.cc
@ -485,8 +485,7 @@ toku_txn_begin(DB_ENV *env, DB_TXN * stxn, DB_TXN ** txn, uint32_t flags) {
 }
 void toku_keep_prepared_txn_callback (DB_ENV *env, TOKUTXN tokutxn) {
    struct __toku_db_txn_external *XMALLOC(eresult);
    memset(eresult, 0, sizeof(*eresult));
    struct __toku_db_txn_external *XCALLOC(eresult);
    DB_TXN *result = &eresult->external_part;
    result->mgrp = env;
    txn_func_init(result);
@ -494,13 +493,12 @@ void toku_keep_prepared_txn_callback (DB_ENV *env, TOKUTXN tokutxn) {
    result->parent = NULL;
 #if !TOKUDB_NATIVE_H
    MALLOC(db_txn_struct_i(result));
    CALLOC(db_txn_struct_i(result));
    if (!db_txn_struct_i(result)) {
        toku_free(result);
        return ENOMEM;
    }
 #endif
    memset(db_txn_struct_i(result), 0, sizeof *db_txn_struct_i(result));
    {
        int r = toku_lth_create(&db_txn_struct_i(result)->lth);
@ -511,6 +509,7 @@ void toku_keep_prepared_txn_callback (DB_ENV *env, TOKUTXN tokutxn) {
    toku_txn_set_container_db_txn(tokutxn, result);
    toku_mutex_init(&db_txn_struct_i(result)->txn_mutex, NULL);
    (void) __sync_fetch_and_add(&env->i->open_txns, 1);
 }
--- a/toku_include/config.h.in
+++ b/toku_include/config.h.in
@ -19,6 +19,7 @@
 #cmakedefine HAVE_LIMITS_H 1
 #cmakedefine HAVE_MACHINE_ENDIAN_H 1
 #cmakedefine HAVE_MALLOC_H 1
 #cmakedefine HAVE_MALLOC_MALLOC_H 1
 #cmakedefine HAVE_PTHREAD_H 1
 #cmakedefine HAVE_STDINT_H 1
 #cmakedefine HAVE_STDLIB_H 1
--- a/utils/CMakeLists.txt
+++ b/utils/CMakeLists.txt
@ -10,8 +10,7 @@ foreach(util ${utils})
  add_executable(${util}_static ${util})
  set_target_properties(${util}_static PROPERTIES
    COMPILE_DEFINITIONS "IS_TDB=1;USE_TDB=1;TDB_IS_STATIC=1")
  target_link_libraries(${util}_static ${LIBTOKUDB}_static lock_tree_static range_tree_static ft_static z lzma ${LIBTOKUPORTABILITY}_static ${CMAKE_THREAD_LIBS_INIT} dl)
  set_targets_need_intel_libs(${util}_static)
  target_link_libraries(${util}_static ${LIBTOKUDB}_static z lzma ${LIBTOKUPORTABILITY}_static ${CMAKE_THREAD_LIBS_INIT} dl)
  add_common_options_to_binary_targets(${util} ${util}_static)
@ -22,7 +21,6 @@ foreach(util ${utils})
    set_target_properties(${util}.bdb PROPERTIES
      INCLUDE_DIRECTORIES "${BDB_INCLUDE_DIR};${CMAKE_CURRENT_BINARY_DIR}/../toku_include;${CMAKE_CURRENT_SOURCE_DIR}/../toku_include;${CMAKE_CURRENT_SOURCE_DIR}/../portability;${CMAKE_CURRENT_SOURCE_DIR}/..")
    target_link_libraries(${util}.bdb ${LIBTOKUPORTABILITY} ${BDB_LIBRARIES})
    set_targets_need_intel_libs(${util}.bdb)
    add_common_options_to_binary_targets(${util}.bdb)
  endif()
 endforeach(util)