Rename Sanitizer Coverage => Coverage Sanitizer

This is so that we are consistent with other sanitizers.
Importantly, this makes the docs clearer.

Driver flags are left unchanged. The good thing is that flags
were already consistent with other sanitizers so there
would not be any motivation to change them,
even if we were feeling disruptive.

Author: cor3ntin

clang/docs/SanitizerCoverage.rst renamed to 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.

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.

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
 

clang/docs/index.rst

@@ -33,7 +33,7 @@ Using Clang as a Compiler
    DataFlowSanitizer
    LeakSanitizer
    RealtimeSanitizer
-   SanitizerCoverage
+   CoverageSanitizer
    SanitizerStats
    SanitizerSpecialCaseList
    BoundsSafety

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

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.

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.

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

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<

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">,