Enable standalone GWP-ASan unit tests (#4)

Author: fanyang89

.github/workflows/ci.yml

@@ -30,10 +30,13 @@ jobs:
       - name: Install dependencies
         run: |
           sudo apt-get update
-          sudo apt-get install -y cmake ninja-build libjemalloc-dev
+          sudo apt-get install -y cmake ninja-build libjemalloc-dev libgtest-dev
 
       - name: Configure
-        run: cmake -S . -B build -G Ninja -DBUILD_EXAMPLE=ON
+        run: cmake -S . -B build -G Ninja -DGWP_ASAN_BUILD_EXAMPLE=ON -DGWP_ASAN_BUILD_TESTING=ON
 
       - name: Build
         run: cmake --build build --parallel
+
+      - name: Test
+        run: ctest --test-dir build --output-on-failure

CMakeLists.txt

@@ -2,12 +2,28 @@ cmake_minimum_required(VERSION 3.17)
 project(gwp-asan)
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-option(BUILD_EXAMPLE "Build examples" OFF)
+
+if (DEFINED BUILD_EXAMPLE AND NOT DEFINED GWP_ASAN_BUILD_EXAMPLE)
+    set(GWP_ASAN_BUILD_EXAMPLE "${BUILD_EXAMPLE}" CACHE BOOL "Build examples")
+endif ()
+if (DEFINED BUILD_EXAMPLE)
+    message(DEPRECATION
+        "BUILD_EXAMPLE is deprecated; use GWP_ASAN_BUILD_EXAMPLE instead.")
+endif ()
+
+option(GWP_ASAN_BUILD_EXAMPLE "Build examples" OFF)
+option(GWP_ASAN_BUILD_TESTING "Build tests" OFF)
+set(GWP_ASAN_GTEST_SOURCE_DIR "" CACHE PATH
+    "Path to a googletest checkout used when GTest is not installed")
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
+if (GWP_ASAN_BUILD_TESTING)
+    enable_testing()
+endif ()
+
 add_subdirectory(gwp_asan)
 
-if (BUILD_EXAMPLE)
+if (GWP_ASAN_BUILD_EXAMPLE)
     add_subdirectory(example)
 endif ()

README.md

@@ -16,6 +16,32 @@ This repo contains a standalone gwp-asan, you can easily use it with CMake.
 
 Check the documents here: [gwp-asan](https://llvm.org/docs/GwpAsan.html)
 
+## Build
+
+```bash
+cmake -S . -B build -G Ninja
+cmake --build build --parallel
+```
+
+Build the example:
+
+```bash
+cmake -S . -B build -G Ninja -DGWP_ASAN_BUILD_EXAMPLE=ON
+cmake --build build --parallel
+```
+
+Run the upstream GWP-ASan unit tests:
+
+```bash
+cmake -S . -B build -G Ninja -DGWP_ASAN_BUILD_TESTING=ON
+cmake --build build --parallel
+ctest --test-dir build --output-on-failure
+```
+
+The tests require GoogleTest. Install `libgtest-dev` on Ubuntu or
+`gtest-devel` on Fedora/RHEL. If GoogleTest is not installed system-wide, pass
+`-DGWP_ASAN_GTEST_SOURCE_DIR=/path/to/googletest`.
+
 ## Integration
 
 TL;DR read the [example](https://github.com/fanyang89/gwp-asan/blob/main/example/helloworld/main.cc)

gwp_asan/CMakeLists.txt

@@ -77,6 +77,6 @@ add_library(RTGwpAsanSegvHandler STATIC
     optional/segv_handler_posix.cpp
 )
 
-if (COMPILER_RT_INCLUDE_TESTS)
+if (GWP_ASAN_BUILD_TESTING)
   add_subdirectory(tests)
 endif ()

gwp_asan/optional/backtrace_linux_libc.cpp

@@ -45,7 +45,7 @@ static void PrintBacktrace(uintptr_t *Trace, size_t TraceLength,
 
   for (size_t i = 0; i < TraceLength; ++i) {
     if (!BacktraceSymbols)
-      Printf("  #%zu %p\n", i, Trace[i]);
+      Printf("  #%zu 0x%zx\n", i, Trace[i]);
     else
       Printf("  #%zu %s\n", i, BacktraceSymbols[i]);
   }

gwp_asan/tests/CMakeLists.txt

@@ -1,18 +1,5 @@
-include(CompilerRTCompile)
-
-set(GWP_ASAN_UNITTEST_CFLAGS
-  ${COMPILER_RT_UNITTEST_CFLAGS}
-  ${COMPILER_RT_GTEST_CFLAGS}
-  ${SANITIZER_TEST_CXX_CFLAGS}
-  -std=c++17
-  -I${COMPILER_RT_SOURCE_DIR}/lib/
-  -O2
-  -g
-  -fno-omit-frame-pointer)
-
-file(GLOB GWP_ASAN_HEADERS ../*.h)
 set(GWP_ASAN_UNITTESTS
-  platform_specific/printf_sanitizer_common.cpp
+  platform_specific/printf_standalone.cpp
   alignment.cpp
   backtrace.cpp
   basic.cpp
@@ -32,53 +19,63 @@ set(GWP_ASAN_UNITTESTS
   utilities.cpp
 )
 
-set(GWP_ASAN_UNIT_TEST_HEADERS
-  ${GWP_ASAN_HEADERS}
-  harness.h)
-
-add_custom_target(GwpAsanUnitTests)
-set_target_properties(GwpAsanUnitTests PROPERTIES FOLDER "Compiler-RT/Tests")
+if (GWP_ASAN_GTEST_SOURCE_DIR)
+  set(GWP_ASAN_GTEST_ROOT "${GWP_ASAN_GTEST_SOURCE_DIR}")
+  if (EXISTS "${GWP_ASAN_GTEST_ROOT}/googletest")
+    set(GWP_ASAN_GTEST_ROOT "${GWP_ASAN_GTEST_ROOT}/googletest")
+  endif ()
+  if (NOT EXISTS "${GWP_ASAN_GTEST_ROOT}/include/gtest/gtest.h" OR
+      NOT EXISTS "${GWP_ASAN_GTEST_ROOT}/src/gtest-all.cc")
+    message(FATAL_ERROR
+      "GWP_ASAN_GTEST_SOURCE_DIR must point to a googletest checkout")
+  endif ()
 
-set(GWP_ASAN_UNITTEST_LINK_FLAGS
-  ${COMPILER_RT_UNITTEST_LINK_FLAGS} -ldl
-  ${COMPILER_RT_UNWINDER_LINK_LIBS}
-  ${SANITIZER_TEST_CXX_LIBRARIES})
-list(APPEND GWP_ASAN_UNITTEST_LINK_FLAGS --driver-mode=g++)
-if(NOT WIN32)
-  list(APPEND GWP_ASAN_UNITTEST_LINK_FLAGS -pthread)
-endif()
+  add_library(gwp_asan_gtest STATIC
+    "${GWP_ASAN_GTEST_ROOT}/src/gtest-all.cc"
+  )
+  target_include_directories(gwp_asan_gtest PUBLIC
+    "${GWP_ASAN_GTEST_ROOT}/include"
+    "${GWP_ASAN_GTEST_ROOT}"
+  )
+  set(GWP_ASAN_GTEST_TARGET gwp_asan_gtest)
+else ()
+  find_package(GTest REQUIRED)
+  if (TARGET GTest::gtest)
+    set(GWP_ASAN_GTEST_TARGET GTest::gtest)
+  elseif (TARGET GTest::GTest)
+    set(GWP_ASAN_GTEST_TARGET GTest::GTest)
+  else ()
+    message(FATAL_ERROR "Could not find a usable GTest target")
+  endif ()
+endif ()
 
-if(COMPILER_RT_DEFAULT_TARGET_ARCH IN_LIST GWP_ASAN_SUPPORTED_ARCH)
-  # GWP-ASan unit tests are only run on the host machine.
-  set(arch ${COMPILER_RT_DEFAULT_TARGET_ARCH})
+add_executable(gwp_asan_tests
+  ${GWP_ASAN_UNITTESTS}
+)
 
-  set(GWP_ASAN_TEST_RUNTIME RTGwpAsanTest.${arch})
+target_link_libraries(gwp_asan_tests PRIVATE
+  RTGwpAsan
+  RTGwpAsanOptionsParser
+  RTGwpAsanBacktraceLibc
+  RTGwpAsanSegvHandler
+  ${GWP_ASAN_GTEST_TARGET}
+)
 
-  set(GWP_ASAN_TEST_RUNTIME_OBJECTS
-    $<TARGET_OBJECTS:RTGwpAsan.${arch}>
-    $<TARGET_OBJECTS:RTGwpAsanBacktraceSanitizerCommon.${arch}>
-    $<TARGET_OBJECTS:RTGwpAsanSegvHandler.${arch}>
-    $<TARGET_OBJECTS:RTGwpAsanOptionsParser.${arch}>
-    $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
-    $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
-    $<TARGET_OBJECTS:RTSanitizerCommonSymbolizer.${arch}>
-    $<TARGET_OBJECTS:RTSanitizerCommonSymbolizerInternal.${arch}>)
+target_compile_features(gwp_asan_tests PRIVATE cxx_std_17)
+target_compile_options(gwp_asan_tests PRIVATE
+  -O0
+  -g
+  -fno-omit-frame-pointer
+  -fno-optimize-sibling-calls
+)
 
-  add_library(${GWP_ASAN_TEST_RUNTIME} STATIC
-    ${GWP_ASAN_TEST_RUNTIME_OBJECTS})
+if (NOT WIN32)
+  target_link_libraries(gwp_asan_tests PRIVATE dl pthread)
+endif ()
 
-  set_target_properties(${GWP_ASAN_TEST_RUNTIME} PROPERTIES
-    ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-    FOLDER "Compiler-RT/Tests/Runtime")
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
+  target_link_options(gwp_asan_tests PRIVATE -rdynamic)
+endif ()
 
-  set(GwpAsanTestObjects)
-  generate_compiler_rt_tests(GwpAsanTestObjects
-    GwpAsanUnitTests "GwpAsan-${arch}-Test" ${arch}
-    SOURCES ${GWP_ASAN_UNITTESTS} ${COMPILER_RT_GTEST_SOURCE}
-    RUNTIME ${GWP_ASAN_TEST_RUNTIME}
-    DEPS ${GWP_ASAN_UNIT_TEST_HEADERS}
-    CFLAGS ${GWP_ASAN_UNITTEST_CFLAGS}
-    LINK_FLAGS ${GWP_ASAN_UNITTEST_LINK_FLAGS})
-  set_target_properties(GwpAsanUnitTests PROPERTIES
-    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-endif()
+include(GoogleTest)
+gtest_discover_tests(gwp_asan_tests)

gwp_asan/tests/harness.cpp

@@ -10,24 +10,33 @@
 
 #include <string>
 
-// Optnone to ensure that the calls to these functions are not optimized away,
-// as we're looking for them in the backtraces.
-__attribute__((optnone)) char *
+#if defined(__clang__)
+#define GWP_ASAN_TEST_NOINLINE __attribute__((noinline, optnone))
+#elif defined(__GNUC__)
+#define GWP_ASAN_TEST_NOINLINE __attribute__((noinline))
+#else
+#define GWP_ASAN_TEST_NOINLINE
+#endif
+
+// Keep these calls visible in backtraces.
+GWP_ASAN_TEST_NOINLINE char *
 AllocateMemory(gwp_asan::GuardedPoolAllocator &GPA) {
   return static_cast<char *>(GPA.allocate(1));
 }
-__attribute__((optnone)) void
+GWP_ASAN_TEST_NOINLINE void
 DeallocateMemory(gwp_asan::GuardedPoolAllocator &GPA, void *Ptr) {
   GPA.deallocate(Ptr);
 }
-__attribute__((optnone)) void
+GWP_ASAN_TEST_NOINLINE void
 DeallocateMemory2(gwp_asan::GuardedPoolAllocator &GPA, void *Ptr) {
   GPA.deallocate(Ptr);
 }
-__attribute__((optnone)) void TouchMemory(void *Ptr) {
+GWP_ASAN_TEST_NOINLINE void TouchMemory(void *Ptr) {
   *(reinterpret_cast<volatile char *>(Ptr)) = 7;
 }
 
+#undef GWP_ASAN_TEST_NOINLINE
+
 void CheckOnlyOneGwpAsanCrash(const std::string &OutputBuffer) {
   const char *kGwpAsanErrorString = "GWP-ASan detected a memory error";
   size_t FirstIndex = OutputBuffer.find(kGwpAsanErrorString);

gwp_asan/tests/platform_specific/printf_standalone.cpp

@@ -0,0 +1,83 @@
+//===-- printf_standalone.cpp ----------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "gwp_asan/optional/printf.h"
+
+#include <errno.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <unistd.h>
+
+#define NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS 1
+#define NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS 1
+#define NANOPRINTF_USE_FLOAT_FORMAT_SPECIFIERS 0
+#define NANOPRINTF_USE_FLOAT_HEX_FORMAT_SPECIFIER 0
+#define NANOPRINTF_USE_SMALL_FORMAT_SPECIFIERS 0
+#define NANOPRINTF_USE_LARGE_FORMAT_SPECIFIERS 1
+#define NANOPRINTF_USE_BINARY_FORMAT_SPECIFIERS 0
+#define NANOPRINTF_USE_WRITEBACK_FORMAT_SPECIFIERS 0
+#define NANOPRINTF_USE_ALT_FORM_FLAG 0
+#define NANOPRINTF_VISIBILITY_STATIC
+#define NANOPRINTF_IMPLEMENTATION
+#include "third_party/nanoprintf/nanoprintf.h"
+
+namespace gwp_asan {
+namespace test {
+namespace {
+
+constexpr size_t kWriteBufferSize = 256;
+
+struct BufferedWriter {
+  char Buffer[kWriteBufferSize];
+  size_t Length = 0;
+};
+
+void writeAll(const char *Data, size_t Length) {
+  while (Length > 0) {
+    ssize_t Written = write(STDERR_FILENO, Data, Length);
+    if (Written > 0) {
+      Data += Written;
+      Length -= static_cast<size_t>(Written);
+      continue;
+    }
+
+    if (Written < 0 && errno == EINTR)
+      continue;
+
+    return;
+  }
+}
+
+void flushBufferedWriter(BufferedWriter *Writer) {
+  writeAll(Writer->Buffer, Writer->Length);
+  Writer->Length = 0;
+}
+
+void bufferedPutc(int C, void *Ctx) {
+  auto *Writer = static_cast<BufferedWriter *>(Ctx);
+  Writer->Buffer[Writer->Length++] = static_cast<char>(C);
+  if (Writer->Length == sizeof(Writer->Buffer))
+    flushBufferedWriter(Writer);
+}
+
+void TestPrintf(const char *Format, ...) {
+  BufferedWriter Writer = {};
+  va_list AP;
+  va_start(AP, Format);
+  npf_vpprintf(bufferedPutc, &Writer, Format, AP);
+  va_end(AP);
+
+  flushBufferedWriter(&Writer);
+}
+
+} // anonymous namespace
+
+Printf_t getPrintfFunction() { return TestPrintf; }
+
+} // namespace test
+} // namespace gwp_asan