llvm · cor3ntin · Aug 29, 2024 · Sep 2, 2024
diff --git a/clang/docs/SanitizerCoverage.rst → clang/docs/CoverageSanitizer.rst b/clang/docs/SanitizerCoverage.rst → clang/docs/CoverageSanitizer.rst
@@ -1,5 +1,5 @@
 =================
-SanitizerCoverage
+CoverageSanitizer
 =================
 
 .. contents::
@@ -8,7 +8,7 @@ SanitizerCoverage
 Introduction
 ============
 
-LLVM has a simple code coverage instrumentation built in (SanitizerCoverage).
+LLVM has a simple code coverage instrumentation built in (CoverageSanitizer).
 It inserts calls to user-defined functions on function-, basic-block-, and edge- levels.
 Default implementations of those callbacks are provided and implement
 simple coverage reporting and visualization,
@@ -208,7 +208,7 @@ This mechanism is used for fuzzing the Linux kernel
 
 Instrumentation points
 ======================
-Sanitizer Coverage offers different levels of instrumentation.
+Coverage Sanitizer offers different levels of instrumentation.
 
 * ``edge`` (default): edges are instrumented (see below).
 * ``bb``: basic blocks are instrumented.
@@ -397,13 +397,13 @@ together with ``__has_feature(coverage_sanitizer)``.
 Disabling instrumentation without source modification
 =====================================================
 
-It is sometimes useful to tell SanitizerCoverage to instrument only a subset of the
+It is sometimes useful to tell CoverageSanitizer to instrument only a subset of the
 functions in your target without modifying source files.
 With ``-fsanitize-coverage-allowlist=allowlist.txt``
 and ``-fsanitize-coverage-ignorelist=blocklist.txt``,
 you can specify such a subset through the combination of an allowlist and a blocklist.
 
-SanitizerCoverage will only instrument functions that satisfy two conditions.
+CoverageSanitizer will only instrument functions that satisfy two conditions.
 First, the function should belong to a source file with a path that is both allowlisted
 and not blocklisted.
 Second, the function should have a mangled name that is both allowlisted and not blocklisted.
@@ -471,16 +471,16 @@ Example:
     % clang++ -g cov.cc -fsanitize=address -fsanitize-coverage=trace-pc-guard
     % ASAN_OPTIONS=coverage=1 ./a.out; wc -c *.sancov
     main
-    SanitizerCoverage: ./a.out.7312.sancov 2 PCs written
+    CoverageSanitizer: ./a.out.7312.sancov 2 PCs written
     24 a.out.7312.sancov
     % ASAN_OPTIONS=coverage=1 ./a.out foo ; wc -c *.sancov
     foo
     main
-    SanitizerCoverage: ./a.out.7316.sancov 3 PCs written
+    CoverageSanitizer: ./a.out.7316.sancov 3 PCs written
     24 a.out.7312.sancov
     32 a.out.7316.sancov
 
-Every time you run an executable instrumented with SanitizerCoverage
+Every time you run an executable instrumented with CoverageSanitizer
 one ``*.sancov`` file is created during the process shutdown.
 If the executable is dynamically linked against instrumented DSOs,
 one ``*.sancov`` file will be also created for every DSO.

diff --git a/clang/docs/SourceBasedCodeCoverage.rst b/clang/docs/SourceBasedCodeCoverage.rst
@@ -14,7 +14,7 @@ information directly. This allows it to generate very precise coverage data.
 
 Clang ships two other code coverage implementations:
 
-* :doc:`SanitizerCoverage` - A low-overhead tool meant for use alongside the
+* :doc:`CoverageSanitizer` - A low-overhead tool meant for use alongside the
   various sanitizers. It can provide up to edge-level coverage.
 
 * gcov - A GCC-compatible coverage implementation which operates on DebugInfo.

diff --git a/clang/docs/UsersManual.rst b/clang/docs/UsersManual.rst
@@ -2140,7 +2140,7 @@ are listed below.
 .. option:: -f[no-]sanitize-coverage=[type,features,...]
 
    Enable simple code coverage in addition to certain sanitizers.
-   See :doc:`SanitizerCoverage` for more details.
+   See :doc:`CoverageSanitizer` for more details.
 
 .. option:: -f[no-]sanitize-address-outline-instrumentation
 

diff --git a/clang/docs/index.rst b/clang/docs/index.rst
@@ -33,7 +33,7 @@ Using Clang as a Compiler
    DataFlowSanitizer
    LeakSanitizer
    RealtimeSanitizer
-   SanitizerCoverage
+   CoverageSanitizer
    SanitizerStats
    SanitizerSpecialCaseList
    BoundsSafety

diff --git a/clang/docs/tools/clang-formatted-files.txt b/clang/docs/tools/clang-formatted-files.txt
@@ -5560,7 +5560,7 @@ llvm/include/llvm/Transforms/Instrumentation/HWAddressSanitizer.h
 llvm/include/llvm/Transforms/Instrumentation/InstrOrderFile.h
 llvm/include/llvm/Transforms/Instrumentation/InstrProfiling.h
 llvm/include/llvm/Transforms/Instrumentation/MemProfiler.h
-llvm/include/llvm/Transforms/Instrumentation/SanitizerCoverage.h
+llvm/include/llvm/Transforms/Instrumentation/CoverageSanitizer.h
 llvm/include/llvm/Transforms/IPO/Annotation2Metadata.h
 llvm/include/llvm/Transforms/IPO/ArgumentPromotion.h
 llvm/include/llvm/Transforms/IPO/Attributor.h

diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td
@@ -3142,12 +3142,12 @@ instrumentations should not be applied.
 The attribute takes a list of string literals with the following accepted
 values:
 * all values accepted by ``-fno-sanitize=``;
-* ``coverage``, to disable SanitizerCoverage instrumentation.
+* ``coverage``, to disable CoverageSanitizer instrumentation.
 
 For example, ``__attribute__((no_sanitize("address", "thread")))`` specifies
 that AddressSanitizer and ThreadSanitizer should not be applied to the function
 or variable. Using ``__attribute__((no_sanitize("coverage")))`` specifies that
-SanitizerCoverage should not be applied to the function.
+CoverageSanitizer should not be applied to the function.
 
 See :ref:`Controlling Code Generation <controlling-code-generation>` for a
 full list of supported sanitizer flags.

diff --git a/clang/include/clang/Basic/CodeGenOptions.def b/clang/include/clang/Basic/CodeGenOptions.def
@@ -271,24 +271,24 @@ CODEGENOPT(SanitizeCfiICallNormalizeIntegers, 1, 0) ///< Normalize integer types
                                                     ///< CFI icall function signatures
 CODEGENOPT(SanitizeCfiCanonicalJumpTables, 1, 0) ///< Make jump table symbols canonical
                                                  ///< instead of creating a local jump table.
-CODEGENOPT(SanitizeCoverageType, 2, 0) ///< Type of sanitizer coverage
+CODEGENOPT(SanitizeCoverageType, 2, 0) ///< Type of coverage sanitizer
                                        ///< instrumentation.
-CODEGENOPT(SanitizeCoverageIndirectCalls, 1, 0) ///< Enable sanitizer coverage
+CODEGENOPT(SanitizeCoverageIndirectCalls, 1, 0) ///< Enable coverage sanitizer
                                                 ///< for indirect calls.
 CODEGENOPT(SanitizeCoverageTraceBB, 1, 0) ///< Enable basic block tracing in
-                                          ///< in sanitizer coverage.
+                                          ///< in coverage sanitizer.
 CODEGENOPT(SanitizeCoverageTraceCmp, 1, 0) ///< Enable cmp instruction tracing
-                                           ///< in sanitizer coverage.
+                                           ///< in coverage sanitizer.
 CODEGENOPT(SanitizeCoverageTraceDiv, 1, 0) ///< Enable div instruction tracing
-                                           ///< in sanitizer coverage.
+                                           ///< in coverage sanitizer.
 CODEGENOPT(SanitizeCoverageTraceGep, 1, 0) ///< Enable GEP instruction tracing
-                                           ///< in sanitizer coverage.
+                                           ///< in coverage sanitizer.
 CODEGENOPT(SanitizeCoverage8bitCounters, 1, 0) ///< Use 8-bit frequency counters
-                                               ///< in sanitizer coverage.
+                                               ///< in coverage sanitizer.
 CODEGENOPT(SanitizeCoverageTracePC, 1, 0) ///< Enable PC tracing
-                                          ///< in sanitizer coverage.
+                                          ///< in coverage sanitizer.
 CODEGENOPT(SanitizeCoverageTracePCGuard, 1, 0) ///< Enable PC tracing with guard
-                                               ///< in sanitizer coverage.
+                                               ///< in coverage sanitizer.
 CODEGENOPT(SanitizeCoverageInline8bitCounters, 1, 0) ///< Use inline 8bit counters.
 CODEGENOPT(SanitizeCoverageInlineBoolFlag, 1, 0) ///< Use inline bool flag.
 CODEGENOPT(SanitizeCoveragePCTable, 1, 0) ///< Create a PC Table.

diff --git a/clang/include/clang/Basic/CodeGenOptions.h b/clang/include/clang/Basic/CodeGenOptions.h
@@ -419,7 +419,7 @@ class CodeGenOptions : public CodeGenOptionsBase {
 
   /// Path to allowlist file specifying which objects
   /// (files, functions) should exclusively be instrumented
-  /// by sanitizer coverage pass.
+  /// by coverage sanitizer pass.
   std::vector<std::string> SanitizeCoverageAllowlistFiles;
 
   /// The guard style used for stack protector to get a initial value, this

diff --git a/clang/include/clang/Basic/DiagnosticDriverKinds.td b/clang/include/clang/Basic/DiagnosticDriverKinds.td
@@ -247,10 +247,10 @@ def err_drv_missing_sanitizer_ignorelist : Error<
   "missing sanitizer ignorelist: '%0'">;
 def err_drv_malformed_sanitizer_ignorelist : Error<
   "malformed sanitizer ignorelist: '%0'">;
-def err_drv_malformed_sanitizer_coverage_allowlist : Error<
-  "malformed sanitizer coverage allowlist: '%0'">;
-def err_drv_malformed_sanitizer_coverage_ignorelist : Error<
-  "malformed sanitizer coverage ignorelist: '%0'">;
+def err_drv_malformed_coverage_sanitizer_allowlist : Error<
+  "malformed coverage sanitizer allowlist: '%0'">;
+def err_drv_malformed_coverage_sanitizer_ignorelist : Error<
+  "malformed coverage sanitizer ignorelist: '%0'">;
 def err_drv_malformed_sanitizer_metadata_ignorelist : Error<
   "malformed sanitizer metadata ignorelist: '%0'">;
 def err_drv_unsupported_static_sanitizer_darwin : Error<

diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
@@ -2366,11 +2366,11 @@ def fno_sanitize_coverage : CommaJoined<["-"], "fno-sanitize-coverage=">,
          "inline-bool-flag">;
 def fsanitize_coverage_allowlist : Joined<["-"], "fsanitize-coverage-allowlist=">,
     Group<f_clang_Group>, Visibility<[ClangOption, CLOption]>,
-    HelpText<"Restrict sanitizer coverage instrumentation exclusively to modules and functions that match the provided special case list, except the blocked ones">,
+    HelpText<"Restrict coverage sanitizer instrumentation exclusively to modules and functions that match the provided special case list, except the blocked ones">,
     MarshallingInfoStringVector<CodeGenOpts<"SanitizeCoverageAllowlistFiles">>;
 def fsanitize_coverage_ignorelist : Joined<["-"], "fsanitize-coverage-ignorelist=">,
     Group<f_clang_Group>, Visibility<[ClangOption, CLOption]>,
-    HelpText<"Disable sanitizer coverage instrumentation for modules and functions "
+    HelpText<"Disable coverage sanitizer instrumentation for modules and functions "
              "that match the provided special case list, even the allowed ones">,
     MarshallingInfoStringVector<CodeGenOpts<"SanitizeCoverageIgnorelistFiles">>;
 def fexperimental_sanitize_metadata_EQ : CommaJoined<["-"], "fexperimental-sanitize-metadata=">,
@@ -7311,39 +7311,39 @@ def linker_option : Joined<["--"], "linker-option=">,
   HelpText<"Add linker option">,
   MarshallingInfoStringVector<CodeGenOpts<"LinkerOptions">>;
 def fsanitize_coverage_type : Joined<["-"], "fsanitize-coverage-type=">,
-                              HelpText<"Sanitizer coverage type">,
+                              HelpText<"Coverage sanitizer type">,
                               MarshallingInfoInt<CodeGenOpts<"SanitizeCoverageType">>;
 def fsanitize_coverage_indirect_calls
     : Flag<["-"], "fsanitize-coverage-indirect-calls">,
-      HelpText<"Enable sanitizer coverage for indirect calls">,
+      HelpText<"Enable coverage sanitizer for indirect calls">,
       MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageIndirectCalls">>;
 def fsanitize_coverage_trace_bb
     : Flag<["-"], "fsanitize-coverage-trace-bb">,
-      HelpText<"Enable basic block tracing in sanitizer coverage">,
+      HelpText<"Enable basic block tracing in coverage sanitizer">,
       MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTraceBB">>;
 def fsanitize_coverage_trace_cmp
     : Flag<["-"], "fsanitize-coverage-trace-cmp">,
-      HelpText<"Enable cmp instruction tracing in sanitizer coverage">,
+      HelpText<"Enable cmp instruction tracing in coverage sanitizer">,
       MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTraceCmp">>;
 def fsanitize_coverage_trace_div
     : Flag<["-"], "fsanitize-coverage-trace-div">,
-      HelpText<"Enable div instruction tracing in sanitizer coverage">,
+      HelpText<"Enable div instruction tracing in coverage sanitizer">,
       MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTraceDiv">>;
 def fsanitize_coverage_trace_gep
     : Flag<["-"], "fsanitize-coverage-trace-gep">,
-      HelpText<"Enable gep instruction tracing in sanitizer coverage">,
+      HelpText<"Enable gep instruction tracing in coverage sanitizer">,
       MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTraceGep">>;
 def fsanitize_coverage_8bit_counters
     : Flag<["-"], "fsanitize-coverage-8bit-counters">,
-      HelpText<"Enable frequency counters in sanitizer coverage">,
+      HelpText<"Enable frequency counters in coverage sanitizer">,
       MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverage8bitCounters">>;
 def fsanitize_coverage_inline_8bit_counters
     : Flag<["-"], "fsanitize-coverage-inline-8bit-counters">,
-      HelpText<"Enable inline 8-bit counters in sanitizer coverage">,
+      HelpText<"Enable inline 8-bit counters in coverage sanitizer">,
       MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageInline8bitCounters">>;
 def fsanitize_coverage_inline_bool_flag
     : Flag<["-"], "fsanitize-coverage-inline-bool-flag">,
-      HelpText<"Enable inline bool flag in sanitizer coverage">,
+      HelpText<"Enable inline bool flag in coverage sanitizer">,
       MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageInlineBoolFlag">>;
 def fsanitize_coverage_pc_table
     : Flag<["-"], "fsanitize-coverage-pc-table">,
@@ -7355,11 +7355,11 @@ def fsanitize_coverage_control_flow
       MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageControlFlow">>;
 def fsanitize_coverage_trace_pc
     : Flag<["-"], "fsanitize-coverage-trace-pc">,
-      HelpText<"Enable PC tracing in sanitizer coverage">,
+      HelpText<"Enable PC tracing in coverage sanitizer">,
       MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTracePC">>;
 def fsanitize_coverage_trace_pc_guard
     : Flag<["-"], "fsanitize-coverage-trace-pc-guard">,
-      HelpText<"Enable PC tracing with guard in sanitizer coverage">,
+      HelpText<"Enable PC tracing with guard in coverage sanitizer">,
       MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTracePCGuard">>;
 def fsanitize_coverage_no_prune
     : Flag<["-"], "fsanitize-coverage-no-prune">,

diff --git a/clang/lib/CodeGen/BackendUtil.cpp b/clang/lib/CodeGen/BackendUtil.cpp
@@ -80,7 +80,7 @@
 #include "llvm/Transforms/Instrumentation/PGOInstrumentation.h"
 #include "llvm/Transforms/Instrumentation/RealtimeSanitizer.h"
 #include "llvm/Transforms/Instrumentation/SanitizerBinaryMetadata.h"
-#include "llvm/Transforms/Instrumentation/SanitizerCoverage.h"
+#include "llvm/Transforms/Instrumentation/CoverageSanitizer.h"
 #include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"
 #include "llvm/Transforms/ObjCARC.h"
 #include "llvm/Transforms/Scalar/EarlyCSE.h"
@@ -231,11 +231,11 @@ class EmitAssemblyHelper {
 };
 } // namespace
 
-static SanitizerCoverageOptions
+static CoverageSanitizerOptions
 getSancovOptsFromCGOpts(const CodeGenOptions &CGOpts) {
-  SanitizerCoverageOptions Opts;
+  CoverageSanitizerOptions Opts;
   Opts.CoverageType =
-      static_cast<SanitizerCoverageOptions::Type>(CGOpts.SanitizeCoverageType);
+      static_cast<CoverageSanitizerOptions::Type>(CGOpts.SanitizeCoverageType);
   Opts.IndirectCalls = CGOpts.SanitizeCoverageIndirectCalls;
   Opts.TraceBB = CGOpts.SanitizeCoverageTraceBB;
   Opts.TraceCmp = CGOpts.SanitizeCoverageTraceCmp;
@@ -662,7 +662,7 @@ static void addSanitizers(const Triple &TargetTriple,
                                 OptimizationLevel Level) {
     if (CodeGenOpts.hasSanitizeCoverage()) {
       auto SancovOpts = getSancovOptsFromCGOpts(CodeGenOpts);
-      MPM.addPass(SanitizerCoveragePass(
+      MPM.addPass(CoverageSanitizerPass(
           SancovOpts, CodeGenOpts.SanitizeCoverageAllowlistFiles,
           CodeGenOpts.SanitizeCoverageIgnorelistFiles));
     }

diff --git a/clang/lib/Driver/SanitizerArgs.cpp b/clang/lib/Driver/SanitizerArgs.cpp
@@ -894,12 +894,12 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC,
     parseSpecialCaseListArg(
         D, Args, CoverageAllowlistFiles,
         options::OPT_fsanitize_coverage_allowlist, OptSpecifier(),
-        clang::diag::err_drv_malformed_sanitizer_coverage_allowlist,
+        clang::diag::err_drv_malformed_coverage_sanitizer_allowlist,
         DiagnoseErrors);
     parseSpecialCaseListArg(
         D, Args, CoverageIgnorelistFiles,
         options::OPT_fsanitize_coverage_ignorelist, OptSpecifier(),
-        clang::diag::err_drv_malformed_sanitizer_coverage_ignorelist,
+        clang::diag::err_drv_malformed_coverage_sanitizer_ignorelist,
         DiagnoseErrors);
   }
 

diff --git a/clang/test/CodeGen/Inputs/memprof.exe b/clang/test/CodeGen/Inputs/memprof.exe
diff --git a/clang/test/CodeGen/sancov-new-pm.c b/clang/test/CodeGen/sancov-new-pm.c
@@ -1,4 +1,4 @@
-// Test that SanitizerCoverage works under the new pass manager.
+// Test that CoverageSanitizer works under the new pass manager.
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=fuzzer %s -S -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK,CHECK-O0
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=fuzzer %s -O2 -S -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK,CHECK-O2
 

diff --git a/clang/test/Driver/sancov.c b/clang/test/Driver/sancov.c
@@ -7,7 +7,7 @@
 // RUN: %clang     -target x86_64-unknown-linux -fsanitize-coverage=trace-pc-guard %s -S -emit-llvm -flto -o - | FileCheck %s
 // RUN: %clang -O2 -target x86_64-unknown-linux -fsanitize-coverage=trace-pc-guard %s -S -emit-llvm -flto -o - | FileCheck %s
 
-// Verify that -fsanitize-coverage invokes SanitizerCoveragePass instrumentation.
+// Verify that -fsanitize-coverage invokes CoverageSanitizerPass instrumentation.
 
 int foo(int *a) { return *a; }
 // CHECK: _sancov_
diff --git a/compiler-rt/include/sanitizer/common_interface_defs.h b/compiler-rt/include/sanitizer/common_interface_defs.h
@@ -28,7 +28,7 @@ extern "C" {
 #endif
 // Arguments for __sanitizer_sandbox_on_notify() below.
 typedef struct {
-  // Enable sandbox support in sanitizer coverage.
+  // Enable sandbox support in coverage sanitizer.
   int coverage_sandboxed;
   // File descriptor to write coverage data to. If -1 is passed, a file will
   // be pre-opened by __sanitizer_sandbox_on_notify(). This field has no

diff --git a/compiler-rt/include/sanitizer/coverage_interface.h b/compiler-rt/include/sanitizer/coverage_interface.h
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// Public interface for sanitizer coverage.
+// Public interface for coverage sanitizer.
 //===----------------------------------------------------------------------===//
 
 #ifndef SANITIZER_COVERAG_INTERFACE_H

diff --git a/compiler-rt/lib/fuzzer/dataflow/DataFlow.cpp b/compiler-rt/lib/fuzzer/dataflow/DataFlow.cpp
@@ -6,9 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 // An experimental data-flow tracer for fuzz targets.
-// It is based on DFSan and SanitizerCoverage.
+// It is based on DFSan and CoverageSanitizer.
 // https://clang.llvm.org/docs/DataFlowSanitizer.html
-// https://clang.llvm.org/docs/SanitizerCoverage.html#tracing-data-flow
+// https://clang.llvm.org/docs/CoverageSanitizer.html#tracing-data-flow
 //
 // It executes the fuzz target on the given input while monitoring the
 // data flow for every instrumented comparison instruction.

diff --git a/compiler-rt/lib/sanitizer_common/CMakeLists.txt b/compiler-rt/lib/sanitizer_common/CMakeLists.txt
@@ -69,9 +69,9 @@ set(SANITIZER_LIBCDEP_SOURCES
 
 set(SANITIZER_COVERAGE_SOURCES
   sancov_flags.cpp
-  sanitizer_coverage_fuchsia.cpp
-  sanitizer_coverage_libcdep_new.cpp
-  sanitizer_coverage_win_sections.cpp
+  coverage_sanitizer_fuchsia.cpp
+  coverage_sanitizer_libcdep_new.cpp
+  coverage_sanitizer_win_sections.cpp
   )
 
 set(SANITIZER_SYMBOLIZER_SOURCES
@@ -134,7 +134,7 @@ set(SANITIZER_IMPL_HEADERS
   sanitizer_common_interface.inc
   sanitizer_common_interface_posix.inc
   sanitizer_common_syscalls.inc
-  sanitizer_coverage_interface.inc
+  coverage_sanitizer_interface.inc
   sanitizer_dbghelp.h
   sanitizer_deadlock_detector.h
   sanitizer_deadlock_detector_interface.h
@@ -312,7 +312,7 @@ if(WIN32)
     ${SANITIZER_COMMON_SUPPORTED_OS}
     ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
     SOURCES
-      sanitizer_coverage_win_weak_interception.cpp
+      coverage_sanitizer_win_weak_interception.cpp
     CFLAGS ${SANITIZER_CFLAGS} -DSANITIZER_DYNAMIC
     DEFS ${SANITIZER_COMMON_DEFINITIONS})
 
@@ -327,8 +327,8 @@ if(WIN32)
     ${SANITIZER_COMMON_SUPPORTED_OS}
     ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
     SOURCES
-      sanitizer_coverage_win_dll_thunk.cpp
-      sanitizer_coverage_win_sections.cpp
+      coverage_sanitizer_win_dll_thunk.cpp
+      coverage_sanitizer_win_sections.cpp
     CFLAGS ${SANITIZER_CFLAGS} -DSANITIZER_DLL_THUNK
     DEFS ${SANITIZER_COMMON_DEFINITIONS})
 
@@ -349,8 +349,8 @@ if(WIN32)
     ${SANITIZER_COMMON_SUPPORTED_OS}
     ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
     SOURCES
-      sanitizer_coverage_win_dynamic_runtime_thunk.cpp
-      sanitizer_coverage_win_sections.cpp
+      coverage_sanitizer_win_dynamic_runtime_thunk.cpp
+      coverage_sanitizer_win_sections.cpp
     CFLAGS ${SANITIZER_CFLAGS} ${DYNAMIC_RUNTIME_THUNK_CFLAGS}
     DEFS ${SANITIZER_COMMON_DEFINITIONS})
 endif()