[sancov] moving sancov rt to sancov/ directory

[aizatsky]

Kostya,

Is this what you had in mind?

[kcc]

Yep. LGTM (assuming tests pass)

[aizatsky]

adding rtti options (for sanitizer flags).

compiler-rt/trunk/lib/CMakeLists.txt

function(compiler_rt_build_sanitizer sanitizer)
   string(TOUPPER ${sanitizer} sanitizer_uppercase)
   string(TOLOWER ${sanitizer} sanitizer_lowercase)
   list(FIND COMPILER_RT_SANITIZERS_TO_BUILD ${sanitizer_lowercase} result)
   if(NOT ${result} EQUAL -1)
     compiler_rt_build_runtime(${sanitizer} ${ARGN})
   endif()
 endfunction()
 
+if(COMPILER_RT_HAS_SANITIZER_COMMON)
+  add_subdirectory(sancov)
+endif()
+
 if(COMPILER_RT_BUILD_SANITIZERS)
   compiler_rt_build_runtime(interception)
 
   if(COMPILER_RT_HAS_SANITIZER_COMMON)
     add_subdirectory(stats)
     add_subdirectory(lsan)
     add_subdirectory(ubsan)
   endif()

compiler-rt/trunk/lib/asan/CMakeLists.txt

if(APPLE)
   add_compiler_rt_runtime(clang_rt.asan
     SHARED
     OS ${SANITIZER_COMMON_SUPPORTED_OS}
     ARCHS ${ASAN_SUPPORTED_ARCH}
     OBJECT_LIBS RTAsan_dynamic
                 RTInterception
                 RTSanitizerCommon
                 RTSanitizerCommonLibc
+                RTSancovLibc
                 RTLSanCommon
                 RTUbsan
     CFLAGS ${ASAN_DYNAMIC_CFLAGS}
     LINK_FLAGS ${WEAK_SYMBOL_LINK_FLAGS}
     DEFS ${ASAN_DYNAMIC_DEFINITIONS}
     PARENT_TARGET asan)
 else()
   # Build separate libraries for each target.
 
   set(ASAN_COMMON_RUNTIME_OBJECT_LIBS
     RTInterception
     RTSanitizerCommon
     RTSanitizerCommonLibc
+    RTSancovLibc
     RTLSanCommon
     RTUbsan)
 
   add_compiler_rt_runtime(clang_rt.asan
     STATIC
     ARCHS ${ASAN_SUPPORTED_ARCH}
     OBJECT_LIBS RTAsan_preinit
                 RTAsan

compiler-rt/trunk/lib/asan/tests/CMakeLists.txt

macro(add_asan_tests_for_arch_and_kind arch kind)
   # Add static ASan runtime that will be linked with uninstrumented tests.
   set(ASAN_TEST_RUNTIME RTAsanTest.${arch}${kind})
   if(APPLE)
     set(ASAN_TEST_RUNTIME_OBJECTS
       $<TARGET_OBJECTS:RTAsan_dynamic.osx>
       $<TARGET_OBJECTS:RTInterception.osx>
       $<TARGET_OBJECTS:RTSanitizerCommon.osx>
       $<TARGET_OBJECTS:RTSanitizerCommonLibc.osx>
+      $<TARGET_OBJECTS:RTSancovLibc.osx>
       $<TARGET_OBJECTS:RTLSanCommon.osx>
       $<TARGET_OBJECTS:RTUbsan.osx>)
   else()
     set(ASAN_TEST_RUNTIME_OBJECTS
       $<TARGET_OBJECTS:RTAsan.${arch}>
       $<TARGET_OBJECTS:RTAsan_cxx.${arch}>
       $<TARGET_OBJECTS:RTInterception.${arch}>
       $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
       $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+      $<TARGET_OBJECTS:RTSancovLibc.${arch}>
       $<TARGET_OBJECTS:RTLSanCommon.${arch}>
       $<TARGET_OBJECTS:RTUbsan.${arch}>
       $<TARGET_OBJECTS:RTUbsan_cxx.${arch}>)
   endif()
   add_library(${ASAN_TEST_RUNTIME} STATIC ${ASAN_TEST_RUNTIME_OBJECTS})
   set_target_properties(${ASAN_TEST_RUNTIME} PROPERTIES
     ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
     FOLDER "Compiler-RT Runtime tests")

 if(ANDROID)
   foreach(arch ${ASAN_SUPPORTED_ARCH})
     # Test w/o ASan instrumentation. Link it with ASan statically.
     add_executable(AsanNoinstTest # FIXME: .arch?
       $<TARGET_OBJECTS:RTAsan.${arch}>
       $<TARGET_OBJECTS:RTInterception.${arch}>
       $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
       $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+      $<TARGET_OBJECTS:RTSancovLibc.${arch}>
       $<TARGET_OBJECTS:RTUbsan.${arch}>
       $<TARGET_OBJECTS:RTUbsan_cxx.${arch}>
       ${COMPILER_RT_GTEST_SOURCE}
       ${ASAN_NOINST_TEST_SOURCES})
     set_target_compile_flags(AsanNoinstTest ${ASAN_UNITTEST_COMMON_CFLAGS})
     set_target_link_flags(AsanNoinstTest ${ASAN_UNITTEST_NOINST_LINK_FLAGS})
     target_link_libraries(AsanNoinstTest ${ASAN_UNITTEST_NOINST_LIBS})
 

compiler-rt/trunk/lib/cfi/CMakeLists.txt

 foreach(arch ${CFI_SUPPORTED_ARCH})
   add_compiler_rt_runtime(clang_rt.cfi
     STATIC
     ARCHS ${arch}
     SOURCES ${CFI_SOURCES}
     OBJECT_LIBS RTInterception
                 RTSanitizerCommon
                 RTSanitizerCommonLibc
+                RTSancovLibc
     CFLAGS ${CFI_CFLAGS}
     PARENT_TARGET cfi)
   add_compiler_rt_runtime(clang_rt.cfi_diag
     STATIC
     ARCHS ${arch}
     SOURCES ${CFI_SOURCES}
     OBJECT_LIBS RTInterception
                 RTSanitizerCommon
                 RTSanitizerCommonLibc
+                RTSancovLibc
     RTUbsan
     CFLAGS ${CFI_CFLAGS} ${CFI_DIAG_CFLAGS}
     PARENT_TARGET cfi)
 endforeach()
 
 add_compiler_rt_resource_file(cfi_blacklist cfi_blacklist.txt cfi)

compiler-rt/trunk/lib/dfsan/CMakeLists.txt

foreach(arch ${DFSAN_SUPPORTED_ARCH})
   append_list_if(COMPILER_RT_HAS_FPIE_FLAG -fPIE DFSAN_CFLAGS)
   add_compiler_rt_runtime(clang_rt.dfsan
     STATIC
     ARCHS ${arch}
     SOURCES ${DFSAN_RTL_SOURCES}
             $<TARGET_OBJECTS:RTInterception.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+            $<TARGET_OBJECTS:RTSancovLibc.${arch}>
     CFLAGS ${DFSAN_CFLAGS}
     PARENT_TARGET dfsan)
   add_sanitizer_rt_symbols(clang_rt.dfsan
     ARCHS ${arch}
     EXTRA dfsan.syms.extra)
   add_dependencies(dfsan
     clang_rt.dfsan-${arch}-symbols)
 endforeach()

compiler-rt/trunk/lib/esan/CMakeLists.txt

 foreach (arch ${ESAN_SUPPORTED_ARCH})
   add_compiler_rt_runtime(clang_rt.esan
     STATIC
     ARCHS ${arch}
     SOURCES ${ESAN_SOURCES}
             $<TARGET_OBJECTS:RTInterception.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+            $<TARGET_OBJECTS:RTSancovLibc.${arch}>
     CFLAGS ${ESAN_RTL_CFLAGS})
   add_sanitizer_rt_symbols(clang_rt.esan
     ARCHS ${arch}
     EXTRA esan.syms.extra)
   add_dependencies(esan
     clang_rt.esan-${arch}
     clang_rt.esan-${arch}-symbols)
 endforeach()
 
 if (COMPILER_RT_INCLUDE_TESTS)
   # TODO(bruening): add tests via add_subdirectory(tests)
 endif()

compiler-rt/trunk/lib/lsan/CMakeLists.txt

if(COMPILER_RT_HAS_LSAN)
   foreach(arch ${LSAN_SUPPORTED_ARCH})
     add_compiler_rt_runtime(clang_rt.lsan
       STATIC
       ARCHS ${arch}
       SOURCES ${LSAN_SOURCES}
               $<TARGET_OBJECTS:RTInterception.${arch}>
               $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
               $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+              $<TARGET_OBJECTS:RTSancovLibc.${arch}>
               $<TARGET_OBJECTS:RTLSanCommon.${arch}>
       CFLAGS ${LSAN_CFLAGS}
       PARENT_TARGET lsan)
   endforeach()
 endif()

compiler-rt/trunk/lib/msan/CMakeLists.txt

 foreach(arch ${MSAN_SUPPORTED_ARCH})
   add_compiler_rt_runtime(clang_rt.msan
     STATIC
     ARCHS ${arch}
     SOURCES ${MSAN_RTL_SOURCES}
             $<TARGET_OBJECTS:RTInterception.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+            $<TARGET_OBJECTS:RTSancovLibc.${arch}>
             $<TARGET_OBJECTS:RTUbsan.${arch}>
     CFLAGS ${MSAN_RTL_CFLAGS}
     PARENT_TARGET msan)
   add_compiler_rt_runtime(clang_rt.msan_cxx
     STATIC
     ARCHS ${arch}
     SOURCES ${MSAN_RTL_CXX_SOURCES}
             $<TARGET_OBJECTS:RTUbsan_cxx.${arch}>

compiler-rt/trunk/lib/sancov/CMakeLists.txt

+set(SANITIZER_CFLAGS ${SANITIZER_COMMON_CFLAGS})
+append_rtti_flag(OFF SANITIZER_CFLAGS)
+
+set(SANCOV_LIBCDEP_SOURCES
+  sancov_flags.cc
+  sanitizer_coverage_libcdep.cc)
+
+add_compiler_rt_object_libraries(RTSancovLibc
+  ${OS_OPTION}
+  ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
+  SOURCES ${SANCOV_LIBCDEP_SOURCES}
+  CFLAGS ${SANITIZER_CFLAGS}
+  DEFS ${SANITIZER_COMMON_DEFINITIONS})
+
+include_directories(..)
+

compiler-rt/trunk/lib/sancov/sancov_flags.h

+//===-- sancov_flags.h ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Sanitizer Coverage runtime flags.
+//
+//===----------------------------------------------------------------------===//
+#ifndef SANCOV_FLAGS_H
+#define SANCOV_FLAGS_H
+
+#include "sanitizer_common/sanitizer_flag_parser.h"
+#include "sanitizer_common/sanitizer_internal_defs.h"
+
+namespace __sancov {
+
+struct SancovFlags {
+#define SANCOV_FLAG(Type, Name, DefaultValue, Description) Type Name;
+#include "sancov_flags.inc"
+#undef SANCOV_FLAG
+
+  void SetDefaults();
+};
+
+extern SancovFlags sancov_flags_dont_use_directly;
+
+inline SancovFlags* sancov_flags() { return &sancov_flags_dont_use_directly; }
+
+void InitializeSancovFlags();
+
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE const char*
+__sancov_default_options();
+
+}  // namespace __sancov
+
+#endif

compiler-rt/trunk/lib/sancov/sancov_flags.cc

+//===-- sancov_flags.cc -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Sanitizer Coverage runtime flags.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sancov_flags.h"
+#include "sanitizer_common/sanitizer_flag_parser.h"
+#include "sanitizer_common/sanitizer_platform.h"
+
+#if !SANITIZER_LINUX
+// other platforms do not have weak symbols out of the box.
+extern "C" const char* __sancov_default_options() { return ""; }
+#endif
+
+using namespace __sanitizer;
+
+namespace __sancov {
+
+SancovFlags sancov_flags_dont_use_directly;  // use via flags();
+
+void SancovFlags::SetDefaults() {
+#define SANCOV_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
+#include "sancov_flags.inc"
+#undef SANCOV_FLAG
+}
+
+static void RegisterSancovFlags(FlagParser *parser, SancovFlags *f) {
+#define SANCOV_FLAG(Type, Name, DefaultValue, Description) \
+  RegisterFlag(parser, #Name, Description, &f->Name);
+#include "sancov_flags.inc"
+#undef SANCOV_FLAG
+}
+
+static const char *MaybeCallSancovDefaultOptions() {
+  return (&__sancov_default_options) ? __sancov_default_options() : "";
+}
+
+void InitializeSancovFlags() {
+  SancovFlags *f = sancov_flags();
+  f->SetDefaults();
+
+  FlagParser parser;
+  RegisterSancovFlags(&parser, f);
+
+  parser.ParseString(MaybeCallSancovDefaultOptions());
+  parser.ParseString(GetEnv("SANCOV_OPTIONS"));
+
+  ReportUnrecognizedFlags();
+  if (f->help) parser.PrintFlagDescriptions();
+}
+
+}  // namespace __sancov

compiler-rt/trunk/lib/sancov/sancov_flags.inc

+//===-- sancov_flags.inc ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Sanitizer Coverage runtime flags.
+//
+//===----------------------------------------------------------------------===//
+#ifndef SANCOV_FLAG
+#error "Defnine SANCOV_FLAG prior to including this file!"
+#endif
+
+SANCOV_FLAG(bool, symbolize, true,
+            "If set, converage information will be symbolized by sancov tool "
+            "after dumping.")
+
+SANCOV_FLAG(bool, help, false, "Print flags help.")

compiler-rt/trunk/lib/sancov/sanitizer_coverage_libcdep.cc

+//===-- sanitizer_coverage_libcdep_new.cc ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// Sanitizer Coverage Controller for Trace PC Guard.
+
+#include "sancov_flags.h"
+#include "sanitizer_common/sanitizer_allocator_internal.h"
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_symbolizer.h"
+
+using namespace __sanitizer;
+
+using AddressRange = LoadedModule::AddressRange;
+
+namespace __sancov {
+namespace {
+
+static const u64 Magic64 = 0xC0BFFFFFFFFFFF64ULL;
+static const u64 Magic32 = 0xC0BFFFFFFFFFFF32ULL;
+static const u64 Magic = SANITIZER_WORDSIZE == 64 ? Magic64 : Magic32;
+
+static fd_t OpenFile(const char* path) {
+  error_t err;
+  fd_t fd = OpenFile(path, WrOnly, &err);
+  if (fd == kInvalidFd)
+    Report("SanitizerCoverage: failed to open %s for writing (reason: %d)\n",
+           path, err);
+  return fd;
+}
+
+static void GetCoverageFilename(char* path, const char* name,
+                                const char* extension) {
+  CHECK(name);
+  internal_snprintf(path, kMaxPathLength, "%s/%s.%zd.%s",
+                    common_flags()->coverage_dir, name, internal_getpid(),
+                    extension);
+}
+
+static void WriteModuleCoverage(char* file_path, const char* module_name,
+                                const uptr* pcs, uptr len) {
+  GetCoverageFilename(file_path, StripModuleName(module_name), "sancov");
+  fd_t fd = OpenFile(file_path);
+  WriteToFile(fd, &Magic, sizeof(Magic));
+  WriteToFile(fd, pcs, len * sizeof(*pcs));
+  CloseFile(fd);
+  Printf("SanitizerCoverage: %s %zd PCs written\n", file_path, len);
+}
+
+static void SanitizerDumpCoverage(const uptr* unsorted_pcs, uptr len) {
+  if (!len) return;
+
+  char* file_path = static_cast<char*>(InternalAlloc(kMaxPathLength));
+  char* module_name = static_cast<char*>(InternalAlloc(kMaxPathLength));
+  uptr* pcs = static_cast<uptr*>(InternalAlloc(len * sizeof(uptr)));
+
+  internal_memcpy(pcs, unsorted_pcs, len * sizeof(uptr));
+  SortArray(pcs, len);
+
+  bool module_found = false;
+  uptr last_base = 0;
+  uptr module_start_idx = 0;
+
+  for (uptr i = 0; i < len; ++i) {
+    const uptr pc = pcs[i];
+    if (!pc) continue;
+
+    if (!__sanitizer_get_module_and_offset_for_pc(pc, nullptr, 0, &pcs[i])) {
+      Printf("ERROR: bad pc %x\n", pc);
+      continue;
+    }
+    uptr module_base = pc - pcs[i];
+
+    if (module_base != last_base || !module_found) {
+      if (module_found) {
+        WriteModuleCoverage(file_path, module_name, &pcs[module_start_idx],
+                            i - module_start_idx);
+      }
+
+      last_base = module_base;
+      module_start_idx = i;
+      module_found = true;
+      __sanitizer_get_module_and_offset_for_pc(pc, module_name, kMaxPathLength,
+                                               &pcs[i]);
+    }
+  }
+
+  if (module_found) {
+    WriteModuleCoverage(file_path, module_name, &pcs[module_start_idx],
+                        len - module_start_idx);
+  }
+
+  InternalFree(file_path);
+  InternalFree(module_name);
+  InternalFree(pcs);
+
+  if (sancov_flags()->symbolize) {
+    Printf("TODO(aizatsky): call sancov to symbolize\n");
+  }
+}
+
+// Collects trace-pc guard coverage.
+// This class relies on zero-initialization.
+class TracePcGuardController {
+ public:
+  void Initialize() {
+    CHECK(!initialized);
+
+    initialized = true;
+    InitializeSancovFlags();
+
+    pc_vector.Initialize(0);
+  }
+
+  void InitTracePcGuard(u32* start, u32* end) {
+    if (!initialized) Initialize();
+    CHECK(!*start);
+    CHECK_NE(start, end);
+
+    u32 i = pc_vector.size();
+    for (u32* p = start; p < end; p++) *p = ++i;
+    pc_vector.resize(i);
+  }
+
+  void TracePcGuard(u32* guard, uptr pc) {
+    atomic_uint32_t* guard_ptr = reinterpret_cast<atomic_uint32_t*>(guard);
+    u32 idx = atomic_exchange(guard_ptr, 0, memory_order_relaxed);
+    if (!idx) return;
+    // we start indices from 1.
+    pc_vector[idx - 1] = pc;
+  }
+
+  void Dump() {
+    if (!initialized || !common_flags()->coverage) return;
+    __sanitizer_dump_coverage(pc_vector.data(), pc_vector.size());
+  }
+
+ private:
+  bool initialized;
+  InternalMmapVectorNoCtor<uptr> pc_vector;
+};
+
+static TracePcGuardController pc_guard_controller;
+
+}  // namespace
+}  // namespace __sancov
+
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_coverage(  // NOLINT
+    const uptr* pcs, uptr len) {
+  return __sancov::SanitizerDumpCoverage(pcs, len);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
+__sanitizer_cov_trace_pc_guard(u32* guard) {
+  if (!*guard) return;
+  __sancov::pc_guard_controller.TracePcGuard(guard, GET_CALLER_PC() - 1);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
+__sanitizer_cov_trace_pc_guard_init(u32* start, u32* end) {
+  if (start == end || *start) return;
+  __sancov::pc_guard_controller.InitTracePcGuard(start, end);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_trace_pc_guard_coverage() {
+  __sancov::pc_guard_controller.Dump();
+}
+}  // extern "C"

compiler-rt/trunk/lib/sanitizer_common/CMakeLists.txt

 # Libc functions stubs. These sources should be linked instead of
 # SANITIZER_LIBCDEP_SOURCES when sanitizer_common library must not depend on
 # libc.
 set(SANITIZER_NOLIBC_SOURCES
   sanitizer_common_nolibc.cc)
 
 set(SANITIZER_LIBCDEP_SOURCES
   sanitizer_common_libcdep.cc
-  sancov_flags.cc
   sanitizer_coverage_libcdep.cc
-  sanitizer_coverage_libcdep_new.cc
   sanitizer_coverage_mapping_libcdep.cc
   sanitizer_linux_libcdep.cc
   sanitizer_posix_libcdep.cc
   sanitizer_stacktrace_libcdep.cc
   sanitizer_stoptheworld_linux_libcdep.cc
   sanitizer_symbolizer_libcdep.cc
   sanitizer_symbolizer_posix_libcdep.cc
   sanitizer_unwind_linux_libcdep.cc)

compiler-rt/trunk/lib/sanitizer_common/sancov_flags.h

-//===-- sancov_flags.h ------------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// Sanitizer Coverage runtime flags.
-//
-//===----------------------------------------------------------------------===//
-#ifndef SANCOV_FLAGS_H
-#define SANCOV_FLAGS_H
-
-#include "sanitizer_flag_parser.h"
-#include "sanitizer_internal_defs.h"
-
-namespace __sancov {
-
-struct SancovFlags {
-#define SANCOV_FLAG(Type, Name, DefaultValue, Description) Type Name;
-#include "sancov_flags.inc"
-#undef SANCOV_FLAG
-
-  void SetDefaults();
-};
-
-extern SancovFlags sancov_flags_dont_use_directly;
-
-inline SancovFlags* sancov_flags() { return &sancov_flags_dont_use_directly; }
-
-void InitializeSancovFlags();
-
-extern "C" SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE const char*
-__sancov_default_options();
-
-}  // namespace __sancov
-
-#endif

compiler-rt/trunk/lib/sanitizer_common/sancov_flags.cc

-//===-- sancov_flags.cc -----------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// Sanitizer Coverage runtime flags.
-//
-//===----------------------------------------------------------------------===//
-
-#include "sancov_flags.h"
-#include "sanitizer_flag_parser.h"
-#include "sanitizer_platform.h"
-
-#if !SANITIZER_LINUX
-// other platforms do not have weak symbols out of the box.
-extern "C" const char* __sancov_default_options() { return ""; }
-#endif
-
-using namespace __sanitizer;
-
-namespace __sancov {
-
-SancovFlags sancov_flags_dont_use_directly;  // use via flags();
-
-void SancovFlags::SetDefaults() {
-#define SANCOV_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
-#include "sancov_flags.inc"
-#undef SANCOV_FLAG
-}
-
-static void RegisterSancovFlags(FlagParser *parser, SancovFlags *f) {
-#define SANCOV_FLAG(Type, Name, DefaultValue, Description) \
-  RegisterFlag(parser, #Name, Description, &f->Name);
-#include "sancov_flags.inc"
-#undef SANCOV_FLAG
-}
-
-static const char *MaybeCallSancovDefaultOptions() {
-  return (&__sancov_default_options) ? __sancov_default_options() : "";
-}
-
-void InitializeSancovFlags() {
-  SancovFlags *f = sancov_flags();
-  f->SetDefaults();
-
-  FlagParser parser;
-  RegisterSancovFlags(&parser, f);
-
-  parser.ParseString(MaybeCallSancovDefaultOptions());
-  parser.ParseString(GetEnv("SANCOV_OPTIONS"));
-
-  ReportUnrecognizedFlags();
-  if (f->help) parser.PrintFlagDescriptions();
-}
-
-}  // namespace __sancov

compiler-rt/trunk/lib/sanitizer_common/sancov_flags.inc

-//===-- sancov_flags.inc ----------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// Sanitizer Coverage runtime flags.
-//
-//===----------------------------------------------------------------------===//
-#ifndef SANCOV_FLAG
-#error "Defnine SANCOV_FLAG prior to including this file!"
-#endif
-
-SANCOV_FLAG(bool, symbolize, true,
-            "If set, converage information will be symbolized by sancov tool "
-            "after dumping.")
-
-SANCOV_FLAG(bool, help, false, "Print flags help.")

compiler-rt/trunk/lib/sanitizer_common/sanitizer_coverage_libcdep.cc

 }
 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_init() {
   coverage_enabled = true;
   coverage_dir = common_flags()->coverage_dir;
   coverage_data.Init();
 }
 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_dump() {
   coverage_data.DumpAll();
+#if SANITIZER_LINUX
   __sanitizer_dump_trace_pc_guard_coverage();
+#endif
 }
 SANITIZER_INTERFACE_ATTRIBUTE void
 __sanitizer_cov_module_init(s32 *guards, uptr npcs, u8 *counters,
                             const char *comp_unit_name) {
   coverage_data.InitializeGuards(guards, npcs, comp_unit_name, GET_CALLER_PC());
   coverage_data.InitializeCounters(counters, npcs);
   if (!common_flags()->coverage_direct) return;
   if (SANITIZER_ANDROID && coverage_enabled) {

compiler-rt/trunk/lib/sanitizer_common/sanitizer_coverage_libcdep_new.cc

-//===-- sanitizer_coverage_libcdep_new.cc ---------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Sanitizer Coverage Controller for Trace PC Guard.
-
-#include "sancov_flags.h"
-#include "sanitizer_allocator_internal.h"
-#include "sanitizer_atomic.h"
-#include "sanitizer_common.h"
-#include "sanitizer_symbolizer.h"
-
-using namespace __sanitizer;
-
-using AddressRange = LoadedModule::AddressRange;
-
-namespace __sancov {
-namespace {
-
-static const u64 Magic64 = 0xC0BFFFFFFFFFFF64ULL;
-static const u64 Magic32 = 0xC0BFFFFFFFFFFF32ULL;
-static const u64 Magic = SANITIZER_WORDSIZE == 64 ? Magic64 : Magic32;
-
-static fd_t OpenFile(const char* path) {
-  error_t err;
-  fd_t fd = OpenFile(path, WrOnly, &err);
-  if (fd == kInvalidFd)
-    Report("SanitizerCoverage: failed to open %s for writing (reason: %d)\n",
-           path, err);
-  return fd;
-}
-
-static void GetCoverageFilename(char* path, const char* name,
-                                const char* extension) {
-  CHECK(name);
-  internal_snprintf(path, kMaxPathLength, "%s/%s.%zd.%s",
-                    common_flags()->coverage_dir, name, internal_getpid(),
-                    extension);
-}
-
-static void WriteModuleCoverage(char* file_path, const char* module_name,
-                                const uptr* pcs, uptr len) {
-  GetCoverageFilename(file_path, StripModuleName(module_name), "sancov");
-  fd_t fd = OpenFile(file_path);
-  WriteToFile(fd, &Magic, sizeof(Magic));
-  WriteToFile(fd, pcs, len * sizeof(*pcs));
-  CloseFile(fd);
-  Printf("SanitizerCoverage: %s %zd PCs written\n", file_path, len);
-}
-
-static void SanitizerDumpCoverage(const uptr* unsorted_pcs, uptr len) {
-  if (!len) return;
-
-  char* file_path = static_cast<char*>(InternalAlloc(kMaxPathLength));
-  char* module_name = static_cast<char*>(InternalAlloc(kMaxPathLength));
-  uptr* pcs = static_cast<uptr*>(InternalAlloc(len * sizeof(uptr)));
-
-  internal_memcpy(pcs, unsorted_pcs, len * sizeof(uptr));
-  SortArray(pcs, len);
-
-  bool module_found = false;
-  uptr last_base = 0;
-  uptr module_start_idx = 0;
-
-  for (uptr i = 0; i < len; ++i) {
-    const uptr pc = pcs[i];
-    if (!pc) continue;
-
-    if (!__sanitizer_get_module_and_offset_for_pc(pc, nullptr, 0, &pcs[i])) {
-      Printf("ERROR: bad pc %x\n", pc);
-      continue;
-    }
-    uptr module_base = pc - pcs[i];
-
-    if (module_base != last_base || !module_found) {
-      if (module_found) {
-        WriteModuleCoverage(file_path, module_name, &pcs[module_start_idx],
-                            i - module_start_idx);
-      }
-
-      last_base = module_base;
-      module_start_idx = i;
-      module_found = true;
-      __sanitizer_get_module_and_offset_for_pc(pc, module_name, kMaxPathLength,
-                                               &pcs[i]);
-    }
-  }
-
-  if (module_found) {
-    WriteModuleCoverage(file_path, module_name, &pcs[module_start_idx],
-                        len - module_start_idx);
-  }
-
-  InternalFree(file_path);
-  InternalFree(module_name);
-  InternalFree(pcs);
-
-  if (sancov_flags()->symbolize) {
-    Printf("TODO(aizatsky): call sancov to symbolize\n");
-  }
-}
-
-// Collects trace-pc guard coverage.
-// This class relies on zero-initialization.
-class TracePcGuardController {
- public:
-  void Initialize() {
-    CHECK(!initialized);
-
-    initialized = true;
-    InitializeSancovFlags();
-
-    pc_vector.Initialize(0);
-  }
-
-  void InitTracePcGuard(u32* start, u32* end) {
-    if (!initialized) Initialize();
-    CHECK(!*start);
-    CHECK_NE(start, end);
-
-    u32 i = pc_vector.size();
-    for (u32* p = start; p < end; p++) *p = ++i;
-    pc_vector.resize(i);
-  }
-
-  void TracePcGuard(u32* guard, uptr pc) {
-    atomic_uint32_t* guard_ptr = reinterpret_cast<atomic_uint32_t*>(guard);
-    u32 idx = atomic_exchange(guard_ptr, 0, memory_order_relaxed);
-    if (!idx) return;
-    // we start indices from 1.
-    pc_vector[idx - 1] = pc;
-  }
-
-  void Dump() {
-    if (!initialized || !common_flags()->coverage) return;
-    __sanitizer_dump_coverage(pc_vector.data(), pc_vector.size());
-  }
-
- private:
-  bool initialized;
-  InternalMmapVectorNoCtor<uptr> pc_vector;
-};
-
-static TracePcGuardController pc_guard_controller;
-
-}  // namespace
-}  // namespace __sancov
-
-extern "C" {
-SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_coverage(  // NOLINT
-    const uptr* pcs, uptr len) {
-  return __sancov::SanitizerDumpCoverage(pcs, len);
-}
-
-SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
-__sanitizer_cov_trace_pc_guard(u32* guard) {
-  if (!*guard) return;
-  __sancov::pc_guard_controller.TracePcGuard(guard, GET_CALLER_PC() - 1);
-}
-
-SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
-__sanitizer_cov_trace_pc_guard_init(u32* start, u32* end) {
-  if (start == end || *start) return;
-  __sancov::pc_guard_controller.InitTracePcGuard(start, end);
-}
-
-SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_trace_pc_guard_coverage() {
-  __sancov::pc_guard_controller.Dump();
-}
-}  // extern "C"

compiler-rt/trunk/lib/sanitizer_common/tests/CMakeLists.txt

 endmacro()
 
 if(COMPILER_RT_CAN_EXECUTE_TESTS AND NOT ANDROID)
   # We use just-built clang to build sanitizer_common unittests, so we must
   # be sure that produced binaries would work.
   if(APPLE)
     add_sanitizer_common_lib("RTSanitizerCommon.test.osx"
                              $<TARGET_OBJECTS:RTSanitizerCommon.osx>
-                             $<TARGET_OBJECTS:RTSanitizerCommonLibc.osx>)
+                             $<TARGET_OBJECTS:RTSanitizerCommonLibc.osx>
+                             $<TARGET_OBJECTS:RTSancovLibc.osx>)
   else()
     if(CAN_TARGET_x86_64)
       add_sanitizer_common_lib("RTSanitizerCommon.test.nolibc.x86_64"
                                $<TARGET_OBJECTS:RTSanitizerCommon.x86_64>
                                $<TARGET_OBJECTS:RTSanitizerCommonNoLibc.x86_64>)
     endif()
     foreach(arch ${SANITIZER_UNITTEST_SUPPORTED_ARCH})
       add_sanitizer_common_lib("RTSanitizerCommon.test.${arch}"
                                $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
-                               $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>)
+                               $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+                               $<TARGET_OBJECTS:RTSancovLibc.${arch}>)
     endforeach()
   endif()
   foreach(arch ${SANITIZER_UNITTEST_SUPPORTED_ARCH})
     add_sanitizer_tests_for_arch(${arch})
   endforeach()
 endif()
 
 if(ANDROID)
   foreach(arch ${SANITIZER_COMMON_SUPPORTED_ARCH})
     add_executable(SanitizerTest
       ${SANITIZER_UNITTESTS}
       ${COMPILER_RT_GTEST_SOURCE}
       $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
-      $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>)
+      $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+      $<TARGET_OBJECTS:RTSancovLibc.${arch}>)
     set_target_compile_flags(SanitizerTest
       ${SANITIZER_COMMON_CFLAGS}
       ${SANITIZER_TEST_CFLAGS_COMMON})
     # Setup correct output directory and link flags.
     set_target_properties(SanitizerTest PROPERTIES
       RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
     set_target_link_flags(SanitizerTest ${SANITIZER_TEST_LINK_FLAGS_COMMON})
     target_link_libraries(SanitizerTest ${SANITIZER_TEST_LINK_LIBS})
     # Add unit test to test suite.
     add_dependencies(SanitizerUnitTests SanitizerTest)
   endforeach()
 endif()

compiler-rt/trunk/lib/scudo/CMakeLists.txt

if(COMPILER_RT_HAS_SCUDO)
   foreach(arch ${SCUDO_SUPPORTED_ARCH})
     add_compiler_rt_runtime(clang_rt.scudo
       STATIC
       ARCHS ${arch}
       SOURCES ${SCUDO_SOURCES}
               $<TARGET_OBJECTS:RTInterception.${arch}>
               $<TARGET_OBJECTS:RTSanitizerCommonNoTermination.${arch}>
               $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+              $<TARGET_OBJECTS:RTSancovLibc.${arch}>
       CFLAGS ${SCUDO_CFLAGS}
       PARENT_TARGET scudo)
   endforeach()
 endif()

compiler-rt/trunk/lib/stats/CMakeLists.txt

 
 add_compiler_rt_runtime(clang_rt.stats
   ${STATS_LIB_FLAVOR}
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
   OS ${SANITIZER_COMMON_SUPPORTED_OS}
   SOURCES stats.cc
   OBJECT_LIBS RTSanitizerCommon
               RTSanitizerCommonLibc
+              RTSancovLibc
   CFLAGS ${SANITIZER_COMMON_CFLAGS}
   LINK_FLAGS ${WEAK_SYMBOL_LINK_FLAGS}
   PARENT_TARGET stats)
 
 add_compiler_rt_runtime(clang_rt.stats_client
   STATIC
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
   OS ${SANITIZER_COMMON_SUPPORTED_OS}
   SOURCES stats_client.cc
   CFLAGS ${SANITIZER_COMMON_CFLAGS}
   LINK_FLAGS ${WEAK_SYMBOL_LINK_FLAGS}
   PARENT_TARGET stats)

compiler-rt/trunk/lib/tsan/CMakeLists.txt

if(APPLE)
   add_compiler_rt_runtime(clang_rt.tsan
     SHARED
     OS ${TSAN_SUPPORTED_OS}
     ARCHS ${TSAN_SUPPORTED_ARCH}
     SOURCES ${TSAN_SOURCES} ${TSAN_CXX_SOURCES} ${TSAN_ASM_SOURCES}
     OBJECT_LIBS RTInterception
                 RTSanitizerCommon
                 RTSanitizerCommonLibc
+                RTSancovLibc
                 RTUbsan
     CFLAGS ${TSAN_RTL_CFLAGS}
     LINK_FLAGS ${WEAK_SYMBOL_LINK_FLAGS}
     PARENT_TARGET tsan)
   add_compiler_rt_object_libraries(RTTsan_dynamic
     OS ${TSAN_SUPPORTED_OS}
     ARCHS ${TSAN_SUPPORTED_ARCH}
     SOURCES ${TSAN_SOURCES} ${TSAN_CXX_SOURCES} ${TSAN_ASM_SOURCES}
elseif(arch MATCHES "powerpc64|powerpc64le")
     endif()
     add_compiler_rt_runtime(clang_rt.tsan
       STATIC
       ARCHS ${arch}
       SOURCES ${TSAN_SOURCES} ${TSAN_ASM_SOURCES}
               $<TARGET_OBJECTS:RTInterception.${arch}>
               $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
               $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+              $<TARGET_OBJECTS:RTSancovLibc.${arch}>
               $<TARGET_OBJECTS:RTUbsan.${arch}>
       CFLAGS ${TSAN_RTL_CFLAGS})
     add_compiler_rt_runtime(clang_rt.tsan_cxx
       STATIC
       ARCHS ${arch}
       SOURCES ${TSAN_CXX_SOURCES}
               $<TARGET_OBJECTS:RTUbsan_cxx.${arch}>
       CFLAGS ${TSAN_RTL_CFLAGS})

compiler-rt/trunk/lib/tsan/dd/CMakeLists.txt

if(CAN_TARGET_x86_64 AND UNIX AND NOT APPLE AND NOT ANDROID)
   set(arch "x86_64")
   add_compiler_rt_runtime(clang_rt.dd
     STATIC
     ARCHS ${arch}
     SOURCES ${DD_SOURCES}
             $<TARGET_OBJECTS:RTInterception.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+            $<TARGET_OBJECTS:RTSancovLibc.${arch}>
     CFLAGS ${DD_CFLAGS}
     PARENT_TARGET dd)
 
   add_compiler_rt_object_libraries(RTDD
     ARCHS ${arch}
     SOURCES ${DD_SOURCES} CFLAGS ${DD_CFLAGS})
 
   add_compiler_rt_runtime(clang_rt.dyndd
     SHARED
     ARCHS ${arch}
     SOURCES $<TARGET_OBJECTS:RTDD.${arch}>
             $<TARGET_OBJECTS:RTInterception.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+            $<TARGET_OBJECTS:RTSancovLibc.${arch}>
     LINK_LIBS ${DD_LINKLIBS}
     PARENT_TARGET dd)
 endif()
 
 add_dependencies(compiler-rt dd)

compiler-rt/trunk/lib/tsan/tests/CMakeLists.txt

foreach(arch ${TSAN_TEST_ARCH})
                            -fsanitize=thread
                            -lstdc++ -lm)
       else()
         set(TSAN_TEST_RUNTIME_OBJECTS
           $<TARGET_OBJECTS:RTTsan_dynamic.osx>
           $<TARGET_OBJECTS:RTInterception.osx>
           $<TARGET_OBJECTS:RTSanitizerCommon.osx>
           $<TARGET_OBJECTS:RTSanitizerCommonLibc.osx>
+          $<TARGET_OBJECTS:RTSancovLibc.osx>
           $<TARGET_OBJECTS:RTUbsan.osx>)
         set(TSAN_TEST_RUNTIME RTTsanTest.${testname}.${arch})
         add_library(${TSAN_TEST_RUNTIME} STATIC ${TSAN_TEST_RUNTIME_OBJECTS})
         set_target_properties(${TSAN_TEST_RUNTIME} PROPERTIES
           ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
         list(APPEND TEST_OBJECTS lib${TSAN_TEST_RUNTIME}.a)
         list(APPEND TEST_DEPS ${TSAN_TEST_RUNTIME})
 

compiler-rt/trunk/lib/ubsan/CMakeLists.txt

if(COMPILER_RT_HAS_UBSAN)
     add_compiler_rt_runtime(clang_rt.ubsan
       SHARED
       OS ${SANITIZER_COMMON_SUPPORTED_OS}
       ARCHS ${UBSAN_SUPPORTED_ARCH}
       OBJECT_LIBS RTUbsan
                   RTUbsan_standalone
                   RTSanitizerCommon
                   RTSanitizerCommonLibc
+                  RTSancovLibc
       LINK_FLAGS ${WEAK_SYMBOL_LINK_FLAGS}
       PARENT_TARGET ubsan)
   endif()
 
 else()
   # Common parts of UBSan runtime.
   add_compiler_rt_object_libraries(RTUbsan
     ARCHS ${UBSAN_COMMON_SUPPORTED_ARCH}
add_compiler_rt_object_libraries(RTUbsan_standalone
       SOURCES ${UBSAN_STANDALONE_SOURCES} CFLAGS ${UBSAN_STANDALONE_CFLAGS})
     
     # Standalone UBSan runtimes.
     add_compiler_rt_runtime(clang_rt.ubsan_standalone
       STATIC
       ARCHS ${UBSAN_SUPPORTED_ARCH}
       OBJECT_LIBS RTSanitizerCommon
               RTSanitizerCommonLibc
+              RTSancovLibc
               RTUbsan
               RTUbsan_standalone
       CFLAGS ${UBSAN_CFLAGS}
       PARENT_TARGET ubsan)
     
     add_compiler_rt_runtime(clang_rt.ubsan_standalone_cxx
       STATIC
       ARCHS ${UBSAN_SUPPORTED_ARCH}

compiler-rt/trunk/lib/xray/CMakeLists.txt

add_compiler_rt_object_libraries(RTXrayFDR
   SOURCES ${XRAY_FDR_SOURCES} CFLAGS ${XRAY_CFLAGS}
   DEFS ${XRAY_COMMON_DEFINITIONS})
 
 add_compiler_rt_component(xray)
 add_compiler_rt_component(xray-fdr)
 
 set(XRAY_COMMON_RUNTIME_OBJECT_LIBS
     RTSanitizerCommon
-    RTSanitizerCommonLibc)
+    RTSanitizerCommonLibc
+    RTSancovLibc)
 
 foreach(arch ${XRAY_SUPPORTED_ARCH})
   if(CAN_TARGET_${arch})
     add_compiler_rt_runtime(clang_rt.xray
      STATIC
      ARCHS ${arch}
      SOURCES ${${arch}_SOURCES}
      CFLAGS ${XRAY_CFLAGS}