[sanitizer coverage] add a basic default implementation of callbacks for -fsanitize-coverage=inline-8bit-counters,pc-table

[kcc]

Summary

[sanitizer coverage] add a basic default implementation of callbacks for -fsanitize-coverage=inline-8bit-counters,pc-table

[kcc]

fix dfsan build

[kcc]

fix a test

[kcc]

one more test fix (can't expect xxd to be present)

[kostik]

compiler-rt/lib/sanitizer_common/sanitizer_coverage_libcdep_new.cpp

172

do you need to check that fd!=-1 here (not sure about the llvm convention). Similarly below

compiler-rt/lib/sanitizer_common/sanitizer_flags.inc

163

are these flags generally documented somewhere? If so, consider updating documentation as well.
I only found https://github.com/google/sanitizers/wiki/AddressSanitizerFlags which does not look like the canonical location.

[kcc]

compiler-rt/lib/sanitizer_common/sanitizer_coverage_libcdep_new.cpp

172

Of OpenFile fails, it will write something like

==42028==SanitizerCoverage: failed to open /zz for writing (reason: 13)

and nothing else will break, so a check would be redundant.

compiler-rt/lib/sanitizer_common/sanitizer_flags.inc

163

These are documented in https://clang.llvm.org/docs/SanitizerCoverage.html but for the time being I am hesitant to document it there.
I want to first see how it's getting used by early adopters (like ourselves), if at all.

compiler-rt/lib/dfsan/dfsan_custom.cpp

pid_t __dfso_fork(dfsan_label *ret_label, dfsan_origin *ret_origin) {
   AfterFork();
   return pid;
 }
 
 // Default empty implementations (weak). Users should redefine them.
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard, u32 *) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard_init, u32 *,
                              u32 *) {}
-SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_pcs_init, void) {}
+SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_pcs_init, const uptr *beg,
+                             const uptr *end) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_indir, void) {}
 
 SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_cmp, void) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_cmp1, void) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_cmp2, void) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_cmp4, void) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_cmp8, void) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_const_cmp1,

compiler-rt/lib/sanitizer_common/sanitizer_coverage_libcdep_new.cpp

 
  private:
   bool initialized;
   InternalMmapVectorNoCtor<uptr> pc_vector;
 };
 
 static TracePcGuardController pc_guard_controller;
 
+// A basic default implementation of callbacks for
+// -fsanitize-coverage=inline-8bit-counters,pc-table.
+// Use TOOL_OPTIONS (UBSAN_OPTIONS, etc) to dump the coverage data:
+// * cov_8bit_counters_out=PATH to dump the 8bit counters.
+// * cov_pcs_out=PATH to dump the pc table.
+//
+// Most users will still need to define their own callbacks for greater
+// flexibility.
+namespace SingletonCounterCoverage {
+
+static char *counters_start, *counters_end;
+
+static void DumpCoverage() {
+  const char* file_path = common_flags()->cov_8bit_counters_out;
+  if (!file_path || !internal_strlen(file_path))
+    return;
+  fd_t fd = OpenFile(file_path);
+  FileCloser file_closer(fd);
+  WriteToFile(fd, counters_start, counters_end - counters_start);
+}
+
+static void Cov8bitCountersInit(char* beg, char* end) {
+  counters_start = beg;
+  counters_end = end;
+  Atexit(DumpCoverage);
+}
+
+static void CovPcsInit(const uptr* pcs_beg, const uptr* pcs_end) {
+  const char* file_path = common_flags()->cov_pcs_out;
+  if (!file_path || !internal_strlen(file_path))
+    return;
+  fd_t fd = OpenFile(file_path);
+  FileCloser file_closer(fd);
+  WriteToFile(fd, pcs_beg, (pcs_end - pcs_beg) * sizeof(uptr));
+}
+
+}  // namespace SingletonCounterCoverage
+
 }  // namespace
 }  // namespace __sancov
 
 namespace __sanitizer {
 void InitializeCoverage(bool enabled, const char *dir) {
   static bool coverage_enabled = false;
   if (coverage_enabled)
     return;  // May happen if two sanitizer enable coverage in the same process.
SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_trace_pc_guard_coverage() {
   __sancov::pc_guard_controller.Dump();
 }
 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_dump() {
   __sanitizer_dump_trace_pc_guard_coverage();
 }
 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_reset() {
   __sancov::pc_guard_controller.Reset();
 }
-// Default empty implementations (weak). Users should redefine them.
+// Default implementations (weak).
+// Either empty or very simple.
+// Most users should redefine them.
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp, void) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp1, void) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp2, void) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp4, void) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp8, void) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp1, void) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp2, void) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp4, void) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp8, void) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_switch, void) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_div4, void) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_div8, void) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_gep, void) {}
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_indir, void) {}
-SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_8bit_counters_init, void) {}
+SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_8bit_counters_init,
+                             char* start, char* end) {
+  __sancov::SingletonCounterCoverage::Cov8bitCountersInit(start, end);
+}
 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_bool_flag_init, void) {}
-SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_pcs_init, void) {}
+SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_pcs_init, const uptr* beg,
+                             const uptr* end) {
+  __sancov::SingletonCounterCoverage::CovPcsInit(beg, end);
+}
 }  // extern "C"
 // Weak definition for code instrumented with -fsanitize-coverage=stack-depth
 // and later linked with code containing a strong definition.
 // E.g., -fsanitize=fuzzer-no-link
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
 SANITIZER_TLS_INITIAL_EXEC_ATTRIBUTE uptr __sancov_lowest_stack;
 
 #endif  // !SANITIZER_FUCHSIA

compiler-rt/lib/sanitizer_common/sanitizer_flags.inc

 //===-- sanitizer_flags.h ---------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file describes common flags available in all sanitizers.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef COMMON_FLAG
 #error "Define COMMON_FLAG prior to including this file!"
 #endif
 
 // COMMON_FLAG(Type, Name, DefaultValue, Description)
 // Supported types: bool, const char *, int, uptr.
 // Default value must be a compile-time constant.
 // Description must be a string literal.
 
 COMMON_FLAG(
     bool, symbolize, true,
     "If set, use the online symbolizer from common sanitizer runtime to turn "
     "virtual addresses to file/line locations.")
 COMMON_FLAG(
     const char *, external_symbolizer_path, nullptr,
     "Path to external symbolizer. If empty, the tool will search $PATH for "
     "the symbolizer.")
 COMMON_FLAG(
     bool, allow_addr2line, false,
     "If set, allows online symbolizer to run addr2line binary to symbolize "
     "stack traces (addr2line will only be used if llvm-symbolizer binary is "
     "unavailable.")
COMMON_FLAG(bool, can_use_proc_maps_statm, true,
             " Mostly useful for testing sanitizers.")
 COMMON_FLAG(
     bool, coverage, false,
     "If set, coverage information will be dumped at program shutdown (if the "
     "coverage instrumentation was enabled at compile time).")
 COMMON_FLAG(const char *, coverage_dir, ".",
             "Target directory for coverage dumps. Defaults to the current "
             "directory.")
+COMMON_FLAG(const char *, cov_8bit_counters_out, "",
+    "If non-empty, write 8bit counters to this file. ")
+COMMON_FLAG(const char *, cov_pcs_out, "",
+    "If non-empty, write the coverage pc table to this file. ")
 COMMON_FLAG(bool, full_address_space, false,
             "Sanitize complete address space; "
             "by default kernel area on 32-bit platforms will not be sanitized")
 COMMON_FLAG(bool, print_suppressions, true,
             "Print matched suppressions at exit.")
 COMMON_FLAG(
     bool, disable_coredump, (SANITIZER_WORDSIZE == 64) && !SANITIZER_GO,
     "Disable core dumping. By default, disable_coredump=1 on 64-bit to avoid"

compiler-rt/lib/sanitizer_common/sanitizer_interface_internal.h

extern "C" {
   void __sanitizer_cov_trace_gep();
   SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
   void __sanitizer_cov_trace_pc_indir();
   SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
   void __sanitizer_cov_trace_pc_guard(__sanitizer::u32*);
   SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
   void __sanitizer_cov_trace_pc_guard_init(__sanitizer::u32*,
                                            __sanitizer::u32*);
-  SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
-  void __sanitizer_cov_8bit_counters_init();
+  SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
+  __sanitizer_cov_8bit_counters_init(char *, char *);
   SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
   __sanitizer_cov_bool_flag_init();
   SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
-  __sanitizer_cov_pcs_init();
+  __sanitizer_cov_pcs_init(const __sanitizer::uptr *,
+                           const __sanitizer::uptr *);
 } // extern "C"
 
 #endif  // SANITIZER_INTERFACE_INTERNAL_H

compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_inline8bit_counter_default_impl.cpp

+// Tests the default implementation of callbacks for
+// -fsanitize-coverage=inline-8bit-counters,pc-table
+
+// REQUIRES: has_sancovcc,stable-runtime,linux
+
+// RUN: %clangxx -O0 %s -fsanitize-coverage=inline-8bit-counters,pc-table -o %t
+// RUN: rm %t-counters %t-pcs
+// RUN: env %tool_options="cov_8bit_counters_out=%t-counters cov_pcs_out=%t-pcs" %run %t 2>&1 | FileCheck %s
+
+// Check that the files were created
+// RUN: ls %t-counters %t-pcs | count 2
+//
+// Check the contents of %t-counters
+// RUN: xxd %t-counters | grep '0102\|0201'
+
+#include <stdio.h>
+
+__attribute__((noinline)) void foo() {}
+int main() {
+  foo();
+  foo();
+  fprintf(stderr, "PASS\n");
+  // CHECK: PASS
+}