Merge 7c2011e into 3924ee7

Author: EricWF

.gitignore

@@ -6,6 +6,7 @@
 *.dylib
 *.cmake
 !/cmake/*.cmake
+!/test/AssemblyTests.cmake
 *~
 *.pyc
 __pycache__

.travis.yml

@@ -131,23 +131,28 @@ matrix:
         - COMPILER=g++-7 C_COMPILER=gcc-7  BUILD_TYPE=Debug
 
 before_script:
-  - if [ -z "$BUILD_32_BITS" ]; then
-      export BUILD_32_BITS=OFF && echo disabling 32 bit build;
-    fi
   - if [ -n "${LIBCXX_BUILD}" ]; then
       source .travis-libcxx-setup.sh;
     fi
   - mkdir -p build && cd build
 
 before_install:
+  - if [ -z "$BUILD_32_BITS" ]; then
+      export BUILD_32_BITS=OFF && echo disabling 32 bit build;
+    fi
   - if [ -n "${INSTALL_GCC6_FROM_PPA}" ]; then
       sudo add-apt-repository -y "ppa:ubuntu-toolchain-r/test";
       sudo apt-get update --option Acquire::Retries=100 --option Acquire::http::Timeout="60";
     fi
 
 install:
   - if [ -n "${INSTALL_GCC6_FROM_PPA}" ]; then
-      sudo -E apt-get -yq --no-install-suggests --no-install-recommends --force-yes install g++-6;
+      sudo -E apt-get -yq --no-install-suggests --no-install-recommends install g++-6;
+    fi
+  - if [ "${TRAVIS_OS_NAME}" == "linux" -a "${BUILD_32_BITS}" == "OFF" ]; then
+      sudo -E apt-get -y --no-install-suggests --no-install-recommends install llvm-3.5-tools;
+      ls /usr/lib/llvm-3.5/bin;
+      sudo cp /usr/lib/llvm-3.5/bin/FileCheck /usr/local/bin;
     fi
   - if [ "${BUILD_TYPE}" == "Coverage" -a "${TRAVIS_OS_NAME}" == "linux" ]; then
       PATH=~/.local/bin:${PATH};

CMakeLists.txt

@@ -27,10 +27,40 @@ option(BENCHMARK_DOWNLOAD_DEPENDENCIES "Allow the downloading and in-tree buildi
 # in cases where it is not possible to build or find a valid version of gtest.
 option(BENCHMARK_ENABLE_GTEST_TESTS "Enable building the unit tests which depend on gtest" ON)
 
+set(ENABLE_ASSEMBLY_TESTS_DEFAULT OFF)
+function(should_enable_assembly_tests)
+  if (MSVC)
+    return()
+  elseif(NOT CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
+    return()
+  elseif(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
+    # FIXME: Make these work on 32 bit builds
+    return()
+  elseif(BENCHMARK_BUILD_32_BITS)
+     # FIXME: Make these work on 32 bit builds
+    return()
+  endif()
+  find_program(LLVM_FILECHECK_EXE FileCheck)
+  if (LLVM_FILECHECK_EXE)
+    set(LLVM_FILECHECK_EXE "${LLVM_FILECHECK_EXE}" CACHE PATH "llvm filecheck" FORCE)
+    message(STATUS "LLVM FileCheck Found: ${LLVM_FILECHECK_EXE}")
+  else()
+    message(STATUS "Failed to find LLVM FileCheck")
+    return()
+  endif()
+  set(ENABLE_ASSEMBLY_TESTS_DEFAULT ON PARENT_SCOPE)
+endfunction()
+should_enable_assembly_tests()
+
+# This option disables the building and running of the assembly verification tests
+option(BENCHMARK_ENABLE_ASSEMBLY_TESTS "Enable building and running the assembly tests"
+    ${ENABLE_ASSEMBLY_TESTS_DEFAULT})
+
 # Make sure we can import out CMake functions
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules")
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
+
 # Read the git tags to determine the project version
 include(GetGitVersion)
 get_git_version(GIT_VERSION)

include/benchmark/benchmark.h

@@ -302,16 +302,97 @@ BENCHMARK_UNUSED static int stream_init_anchor = InitializeStreams();
 // intended to add little to no overhead.
 // See: https://youtu.be/nXaxk27zwlk?t=2441
 #ifndef BENCHMARK_HAS_NO_INLINE_ASSEMBLY
-template <class Tp>
-inline BENCHMARK_ALWAYS_INLINE void DoNotOptimize(Tp const& value) {
-  // Clang doesn't like the 'X' constraint on `value` and certain GCC versions
-  // don't like the 'g' constraint. Attempt to placate them both.
 #if defined(__clang__)
-  asm volatile("" : : "g"(value) : "memory");
+  template <class Tp>
+  struct CanUseRegisterOperandImp {
+#ifdef BENCHMARK_HAS_CXX11
+    using DecayT = typename std::decay<Tp>::type;
+    static const bool value =
+        sizeof(DecayT) <= sizeof(long);
 #else
-  asm volatile("" : : "i,r,m"(value) : "memory");
+    static const bool value = false;
+#endif
+  };
+  template <class InputTp, bool = CanUseRegisterOperandImp<InputTp>::value>
+  struct InlineAsmHelper {
+    template <class Tp>
+    static inline BENCHMARK_ALWAYS_INLINE
+    void DoNotOptimize(Tp const& value) {
+      asm volatile("" : : "r,m"(value) : "memory");
+    }
+    template <class Tp>
+    static inline BENCHMARK_ALWAYS_INLINE
+    void DoNotOptimize(Tp& value) {
+      asm volatile("" : "=g"(value) : : "memory");
+    }
+#ifdef BENCHMARK_HAS_CXX11
+    template <class Tp>
+    static inline BENCHMARK_ALWAYS_INLINE
+    void DoNotOptimize(Tp&& value) {
+       asm volatile("" : : "r"(value) : "memory");
+    }
 #endif
+  };
+template <class InputTp>
+  struct InlineAsmHelper<InputTp, false> {
+    template <class Tp>
+    static inline BENCHMARK_ALWAYS_INLINE
+    void DoNotOptimize(Tp const& value) {
+      asm volatile("" : : "m"(value) : "memory");
+    }
+    template <class Tp>
+    static inline BENCHMARK_ALWAYS_INLINE
+    void DoNotOptimize(Tp& value) {
+      asm volatile("" : "+m"(value) : : "memory");
+    }
+#ifdef BENCHMARK_HAS_CXX11
+    template <class Tp>
+    static inline BENCHMARK_ALWAYS_INLINE
+    void DoNotOptimize(Tp&& value) {
+       asm volatile("" : : "r,m"(value) : "memory");
+    }
+#endif
+  };
+#else
+  template <class InputTp>
+  struct InlineAsmHelper {
+    template <class Tp>
+    static inline BENCHMARK_ALWAYS_INLINE
+    void DoNotOptimize(Tp const& value) {
+      asm volatile("" : : "r,m"(value) : "memory");
+    }
+    template <class Tp>
+    static inline BENCHMARK_ALWAYS_INLINE
+    void DoNotOptimize(Tp& value) {
+      asm volatile("" : "+m,r"(value) : : "memory");
+    }
+#ifdef BENCHMARK_HAS_CXX11
+    template <class Tp>
+    static inline BENCHMARK_ALWAYS_INLINE
+    void DoNotOptimize(Tp&& value) {
+       asm volatile("" : : "r,m"(value) : "memory");
+    }
+#endif
+  };
+#endif
+
+template <class Tp>
+inline BENCHMARK_ALWAYS_INLINE void DoNotOptimize(Tp& value) {
+  InlineAsmHelper<Tp>::DoNotOptimize(value);
+}
+
+#if defined(BENCHMARK_HAS_CXX11)
+template <class Tp>
+inline BENCHMARK_ALWAYS_INLINE
+typename std::enable_if<!std::is_lvalue_reference<Tp>::value, void>::type
+DoNotOptimize(Tp&& value) {
+  static_assert(!std::is_lvalue_reference<Tp>::value, "");
+  static_assert(!std::is_const<Tp>::value, "");
+  InlineAsmHelper<Tp>::DoNotOptimize(static_cast<Tp&&>(value));
 }
+
+template <class Tp> void DoNotOptimize(Tp const&& value) = delete;
+#endif
 // Force the compiler to flush pending writes to global memory. Acts as an
 // effective read/write barrier
 inline BENCHMARK_ALWAYS_INLINE void ClobberMemory() {

test/AssemblyTests.cmake

@@ -0,0 +1,46 @@
+
+
+set(ASM_TEST_FLAGS "")
+check_cxx_compiler_flag(-O3 BENCHMARK_HAS_O3_FLAG)
+if (BENCHMARK_HAS_O3_FLAG)
+  list(APPEND ASM_TEST_FLAGS -O3)
+endif()
+
+check_cxx_compiler_flag(-g0 BENCHMARK_HAS_G0_FLAG)
+if (BENCHMARK_HAS_G0_FLAG)
+  list(APPEND ASM_TEST_FLAGS -g0)
+endif()
+
+check_cxx_compiler_flag(-fno-stack-protector BENCHMARK_HAS_FNO_STACK_PROTECTOR_FLAG)
+if (BENCHMARK_HAS_FNO_STACK_PROTECTOR_FLAG)
+  list(APPEND ASM_TEST_FLAGS -fno-stack-protector)
+endif()
+
+split_list(ASM_TEST_FLAGS)
+string(TOUPPER "${CMAKE_CXX_COMPILER_ID}" ASM_TEST_COMPILER)
+
+macro(add_filecheck_test name)
+  cmake_parse_arguments(ARG "" "" "CHECK_PREFIXES" ${ARGV})
+  add_library(${name} OBJECT ${name}.cc)
+  set_target_properties(${name} PROPERTIES COMPILE_FLAGS "-S ${ASM_TEST_FLAGS}")
+  set(ASM_OUTPUT_FILE "${CMAKE_CURRENT_BINARY_DIR}/${name}.s")
+  add_custom_command(OUTPUT ${ASM_OUTPUT_FILE}
+      COMMAND ${PROJECT_SOURCE_DIR}/tools/strip_asm.py
+        $<TARGET_OBJECTS:${name}>
+        ${ASM_OUTPUT_FILE}
+      DEPENDS ${name})
+  add_custom_target(copy_${name} ALL
+      SOURCES ${ASM_OUTPUT_FILE})
+  if (NOT ARG_CHECK_PREFIXES)
+    set(ARG_CHECK_PREFIXES "CHECK")
+  endif()
+  foreach(prefix ${ARG_CHECK_PREFIXES})
+    add_test(NAME run_${name}_${prefix}
+        COMMAND
+          ${LLVM_FILECHECK_EXE} ${name}.cc
+          --input-file=${ASM_OUTPUT_FILE}
+          --check-prefixes=CHECK,CHECK-${ASM_TEST_COMPILER}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  endforeach()
+endmacro()
+

test/CMakeLists.txt

@@ -22,6 +22,12 @@ if( NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" )
   endforeach()
 endif()
 
+check_cxx_compiler_flag(-O3 BENCHMARK_HAS_O3_FLAG)
+set(BENCHMARK_O3_FLAG "")
+if (BENCHMARK_HAS_O3_FLAG)
+  set(BENCHMARK_O3_FLAG "-O3")
+endif()
+
 # NOTE: These flags must be added after find_package(Threads REQUIRED) otherwise
 # they will break the configuration check.
 if (DEFINED BENCHMARK_CXX_LINKER_FLAGS)
@@ -156,6 +162,23 @@ if (BENCHMARK_ENABLE_GTEST_TESTS)
   add_gtest(statistics_test)
 endif(BENCHMARK_ENABLE_GTEST_TESTS)
 
+###############################################################################
+# Assembly Unit Tests
+###############################################################################
+
+if (BENCHMARK_ENABLE_ASSEMBLY_TESTS)
+  if (NOT LLVM_FILECHECK_EXE)
+    message(FATAL_ERROR "LLVM FileCheck is required when including this file")
+  endif()
+  include(AssemblyTests.cmake)
+  add_filecheck_test(donotoptimize_assembly_test)
+endif()
+
+
+
+###############################################################################
+# Code Coverage Configuration
+###############################################################################
 
 # Add the coverage command(s)
 if(CMAKE_BUILD_TYPE)

test/donotoptimize_assembly_test.cc

@@ -0,0 +1,90 @@
+#include <benchmark/benchmark.h>
+
+#ifdef __clang__
+#pragma clang diagnostic ignored "-Wreturn-type"
+#endif
+
+extern "C" {
+
+extern int ExternInt;
+extern int ExternInt2;
+extern int ExternInt3;
+
+inline int Add42(int x) { return x + 42; }
+
+struct NotTriviallyCopyable {
+  NotTriviallyCopyable();
+  explicit NotTriviallyCopyable(int x) : value(x) {}
+  NotTriviallyCopyable(NotTriviallyCopyable const&);
+  int value;
+};
+
+struct Large {
+  int value;
+  int data[2];
+};
+
+}
+// CHECK-LABEL: test_with_rvalue:
+extern "C" void test_with_rvalue() {
+  benchmark::DoNotOptimize(Add42(0));
+  // CHECK: movl $42, %eax
+  // CHECK: ret
+}
+
+// CHECK-LABEL: test_with_large_rvalue:
+extern "C" void test_with_large_rvalue() {
+  benchmark::DoNotOptimize(Large{ExternInt, {ExternInt, ExternInt}});
+  // CHECK: movl ExternInt(%rip), %eax
+  // CHECK: movl %eax, -{{[0-9]+}}(%rsp)
+  // CHECK: movl %eax, -{{[0-9]+}}(%rsp)
+  // CHECK: movl %eax, -{{[0-9]+}}(%rsp)
+  // CHECK: ret
+}
+
+// CHECK-LABEL: test_with_lvalue:
+extern "C" void test_with_lvalue() {
+  int x = 101;
+  benchmark::DoNotOptimize(x);
+  // CHECK-GNU: movl $101, %eax
+  // CHECK-CLANG: movl $101, -{{[0-9]+}}(%rsp)
+  // CHECK: ret
+}
+
+// CHECK-LABEL: test_with_const_lvalue:
+extern "C" void test_with_const_lvalue() {
+  const int x = 123;
+  benchmark::DoNotOptimize(x);
+  // CHECK: movl $123, %eax
+  // CHECK: ret
+}
+
+// CHECK-LABEL: test_with_large_const_lvalue:
+extern "C" void test_with_large_const_lvalue() {
+  const Large L{ExternInt, {ExternInt, ExternInt}};
+  benchmark::DoNotOptimize(L);
+  // CHECK: movl ExternInt(%rip), %eax
+  // CHECK: movl %eax, -{{[0-9]+}}(%rsp)
+  // CHECK: movl %eax, -{{[0-9]+}}(%rsp)
+  // CHECK: movl %eax, -{{[0-9]+}}(%rsp)
+  // CHECK: ret
+}
+
+// CHECK-LABEL: test_with_non_trivial_const_lvalue:
+extern "C" void test_with_non_trivial_const_lvalue() {
+  const NotTriviallyCopyable Obj(ExternInt);
+  benchmark::DoNotOptimize(Obj);
+  // CHECK: movl ExternInt(%rip), %eax
+  // CHECK: ret
+}
+
+// CHECK-LABEL: test_div_by_two:
+extern "C" int test_div_by_two(int input) {
+  int divisor = 2;
+  benchmark::DoNotOptimize(divisor);
+  return input / divisor;
+  // CHECK: movl $2, [[DEST:.*]]
+  // CHECK: idivl [[DEST]]
+  // CHECK: ret
+}
+

test/donotoptimize_test.cc

@@ -28,13 +28,13 @@ struct BitRef {
 int main(int, char*[]) {
   // this test verifies compilation of DoNotOptimize() for some types
 
-  char buffer8[8];
+  char buffer8[8] = {};
   benchmark::DoNotOptimize(buffer8);
 
-  char buffer20[20];
+  char buffer20[20] = {};
   benchmark::DoNotOptimize(buffer20);
 
-  char buffer1024[1024];
+  char buffer1024[1024] = {};
   benchmark::DoNotOptimize(buffer1024);
   benchmark::DoNotOptimize(&buffer1024[0]);