https://github.com/cor3ntin updated
https://github.com/llvm/llvm-project/pull/106505
>From adb4a0eb00972811343ff05eac6977512f01970a Mon Sep 17 00:00:00 2001
From: Corentin Jabot <corentinja...@gmail.com>
Date: Thu, 29 Aug 2024 09:43:56 +0200
Subject: [PATCH 1/2] 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.
---
...izerCoverage.rst => CoverageSanitizer.rst} | 16 ++--
clang/docs/SourceBasedCodeCoverage.rst | 2 +-
clang/docs/UsersManual.rst | 2 +-
clang/docs/index.rst | 2 +-
clang/docs/tools/clang-formatted-files.txt | 2 +-
clang/include/clang/Basic/AttrDocs.td | 4 +-
clang/include/clang/Basic/CodeGenOptions.def | 18 ++--
clang/include/clang/Basic/CodeGenOptions.h | 2 +-
.../clang/Basic/DiagnosticDriverKinds.td | 8 +-
clang/include/clang/Driver/Options.td | 26 +++---
clang/lib/CodeGen/BackendUtil.cpp | 10 +--
clang/lib/Driver/SanitizerArgs.cpp | 4 +-
clang/test/CodeGen/Inputs/memprof.exe | Bin 1394680 -> 1394680 bytes
clang/test/CodeGen/sancov-new-pm.c | 2 +-
clang/test/Driver/sancov.c | 2 +-
.../include/sanitizer/common_interface_defs.h | 2 +-
.../include/sanitizer/coverage_interface.h | 2 +-
compiler-rt/lib/fuzzer/dataflow/DataFlow.cpp | 4 +-
.../lib/sanitizer_common/CMakeLists.txt | 18 ++--
...sia.cpp => coverage_sanitizer_fuchsia.cpp} | 6 +-
...e.inc => coverage_sanitizer_interface.inc} | 4 +-
...cpp => coverage_sanitizer_libcdep_new.cpp} | 8 +-
...p => coverage_sanitizer_win_dll_thunk.cpp} | 6 +-
...e_sanitizer_win_dynamic_runtime_thunk.cpp} | 8 +-
...pp => coverage_sanitizer_win_sections.cpp} | 4 +-
...erage_sanitizer_win_weak_interception.cpp} | 6 +-
.../lib/sanitizer_common/sancov_flags.cpp | 2 +-
.../lib/sanitizer_common/sancov_flags.h | 2 +-
.../lib/sanitizer_common/sancov_flags.inc | 2 +-
.../Darwin/interface_symbols_darwin.cpp | 2 +-
.../Linux/interface_symbols_linux.cpp | 2 +-
.../asan/TestCases/Posix/coverage-reset.cpp | 14 +--
.../test/asan/TestCases/coverage-and-lsan.cpp | 2 +-
...verage_sanitizer_allowlist_ignorelist.cpp} | 0
...pp => coverage_sanitizer_control_flow.cpp} | 0
...coverage_sanitizer_inline8bit_counter.cpp} | 0
...tizer_inline8bit_counter_default_impl.cpp} | 0
...> coverage_sanitizer_inline_bool_flag.cpp} | 0
...ne.cpp => coverage_sanitizer_no_prune.cpp} | 0
...cpp => coverage_sanitizer_stack_depth.cpp} | 0
...e.cpp => coverage_sanitizer_symbolize.cpp} | 2 +-
...coverage_sanitizer_trace_loads_stores.cpp} | 0
...coverage_sanitizer_trace_pc_guard-dso.cpp} | 10 +--
...overage_sanitizer_trace_pc_guard-init.cpp} | 0
... => coverage_sanitizer_trace_pc_guard.cpp} | 8 +-
libcxx/docs/VendorDocumentation.rst | 2 +-
lldb/docs/resources/fuzzing.rst | 4 +-
llvm/docs/FuzzingLLVM.rst | 2 +-
llvm/docs/LangRef.rst | 2 +-
llvm/docs/LibFuzzer.rst | 12 +--
llvm/docs/SymbolizerMarkupFormat.rst | 2 +-
.../include/llvm/Transforms/Instrumentation.h | 6 +-
...anitizerCoverage.h => CoverageSanitizer.h} | 14 +--
llvm/lib/Passes/PassBuilder.cpp | 2 +-
llvm/lib/Passes/PassRegistry.def | 2 +-
.../Transforms/Instrumentation/CMakeLists.txt | 2 +-
...izerCoverage.cpp => CoverageSanitizer.cpp} | 82 +++++++++---------
.../SanitizerCoverage/crit-edge-sancov.ll | 4 +-
.../Transforms/PGOProfile/Inputs/memprof.exe | Bin 1606400 -> 1606400 bytes
.../PGOProfile/Inputs/memprof.nocolinfo.exe | Bin 1606168 -> 1606168 bytes
.../Inputs/memprof_internal_linkage.exe | Bin 1605160 -> 1605160 bytes
.../PGOProfile/Inputs/memprof_loop_unroll.exe | Bin 1605960 -> 1605960 bytes
.../Inputs/memprof_missing_leaf.exe | Bin 1605072 -> 1605072 bytes
.../Inputs/basic-histogram.memprofexe | Bin 1611256 -> 1611256 bytes
.../llvm-profdata/Inputs/basic.memprofexe | Bin 1604896 -> 1604896 bytes
.../llvm-profdata/Inputs/basic_v3.memprofexe | Bin 1379856 -> 1379856 bytes
.../llvm-profdata/Inputs/buildid.memprofexe | Bin 1604904 -> 1604904 bytes
.../llvm-profdata/Inputs/inline.memprofexe | Bin 1605480 -> 1605480 bytes
.../llvm-profdata/Inputs/multi.memprofexe | Bin 1604912 -> 1604912 bytes
.../Inputs/padding-histogram.memprofexe | Bin 1606576 -> 1606576 bytes
.../tools/llvm-profdata/Inputs/pic.memprofexe | Bin 1607856 -> 1607856 bytes
.../X86/Inputs/elf64-badentrysizes.bin | Bin 469664 -> 469664 bytes
.../llvm-xray/X86/Inputs/elf64-example.bin | Bin 469664 -> 469664 bytes
.../llvm-xray/X86/Inputs/elf64-sample-o2.bin | Bin 478375 -> 478375 bytes
.../tools/sancov/Inputs/test-linux_x86_64 | Bin 2452156 -> 2452156 bytes
.../tools/sancov/Inputs/test-windows_x86_64 | Bin 712704 -> 712704 bytes
llvm/tools/sancov/sancov.cpp | 4 +-
.../compiler-rt/lib/sanitizer_common/BUILD.gn | 16 ++--
.../lib/Transforms/Instrumentation/BUILD.gn | 2 +-
79 files changed, 186 insertions(+), 186 deletions(-)
rename clang/docs/{SanitizerCoverage.rst => CoverageSanitizer.rst} (97%)
rename compiler-rt/lib/sanitizer_common/{sanitizer_coverage_fuchsia.cpp =>
coverage_sanitizer_fuchsia.cpp} (98%)
rename compiler-rt/lib/sanitizer_common/{sanitizer_coverage_interface.inc =>
coverage_sanitizer_interface.inc} (95%)
rename compiler-rt/lib/sanitizer_common/{sanitizer_coverage_libcdep_new.cpp =>
coverage_sanitizer_libcdep_new.cpp} (97%)
rename compiler-rt/lib/sanitizer_common/{sanitizer_coverage_win_dll_thunk.cpp
=> coverage_sanitizer_win_dll_thunk.cpp} (85%)
rename
compiler-rt/lib/sanitizer_common/{sanitizer_coverage_win_dynamic_runtime_thunk.cpp
=> coverage_sanitizer_win_dynamic_runtime_thunk.cpp} (78%)
rename compiler-rt/lib/sanitizer_common/{sanitizer_coverage_win_sections.cpp
=> coverage_sanitizer_win_sections.cpp} (96%)
rename
compiler-rt/lib/sanitizer_common/{sanitizer_coverage_win_weak_interception.cpp
=> coverage_sanitizer_win_weak_interception.cpp} (85%)
rename
compiler-rt/test/sanitizer_common/TestCases/{sanitizer_coverage_allowlist_ignorelist.cpp
=> coverage_sanitizer_allowlist_ignorelist.cpp} (100%)
rename
compiler-rt/test/sanitizer_common/TestCases/{sanitizer_coverage_control_flow.cpp
=> coverage_sanitizer_control_flow.cpp} (100%)
rename
compiler-rt/test/sanitizer_common/TestCases/{sanitizer_coverage_inline8bit_counter.cpp
=> coverage_sanitizer_inline8bit_counter.cpp} (100%)
rename
compiler-rt/test/sanitizer_common/TestCases/{sanitizer_coverage_inline8bit_counter_default_impl.cpp
=> coverage_sanitizer_inline8bit_counter_default_impl.cpp} (100%)
rename
compiler-rt/test/sanitizer_common/TestCases/{sanitizer_coverage_inline_bool_flag.cpp
=> coverage_sanitizer_inline_bool_flag.cpp} (100%)
rename
compiler-rt/test/sanitizer_common/TestCases/{sanitizer_coverage_no_prune.cpp =>
coverage_sanitizer_no_prune.cpp} (100%)
rename
compiler-rt/test/sanitizer_common/TestCases/{sanitizer_coverage_stack_depth.cpp
=> coverage_sanitizer_stack_depth.cpp} (100%)
rename
compiler-rt/test/sanitizer_common/TestCases/{sanitizer_coverage_symbolize.cpp
=> coverage_sanitizer_symbolize.cpp} (91%)
rename
compiler-rt/test/sanitizer_common/TestCases/{sanitizer_coverage_trace_loads_stores.cpp
=> coverage_sanitizer_trace_loads_stores.cpp} (100%)
rename
compiler-rt/test/sanitizer_common/TestCases/{sanitizer_coverage_trace_pc_guard-dso.cpp
=> coverage_sanitizer_trace_pc_guard-dso.cpp} (83%)
rename
compiler-rt/test/sanitizer_common/TestCases/{sanitizer_coverage_trace_pc_guard-init.cpp
=> coverage_sanitizer_trace_pc_guard-init.cpp} (100%)
rename
compiler-rt/test/sanitizer_common/TestCases/{sanitizer_coverage_trace_pc_guard.cpp
=> coverage_sanitizer_trace_pc_guard.cpp} (81%)
rename llvm/include/llvm/Transforms/Instrumentation/{SanitizerCoverage.h =>
CoverageSanitizer.h} (81%)
rename llvm/lib/Transforms/Instrumentation/{SanitizerCoverage.cpp =>
CoverageSanitizer.cpp} (94%)
diff --git a/clang/docs/SanitizerCoverage.rst b/clang/docs/CoverageSanitizer.rst
similarity index 97%
rename from clang/docs/SanitizerCoverage.rst
rename to clang/docs/CoverageSanitizer.rst
index 45ad03cb43774c..a5dba0ec093950 100644
--- a/clang/docs/SanitizerCoverage.rst
+++ b/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
index 73910e134a5891..313063b976547c 100644
--- 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
index f27fa4ace917ea..738ba7fa4855a8 100644
--- 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
index 4a497f4d9bcc3c..8a1097cf3e19c7 100644
--- 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
index fc07357986d989..d105f530b5106c 100644
--- 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
index c2b9d7cb93c309..de4959277fa8e6 100644
--- 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
index b600198998d85b..28c91bdeec5b73 100644
--- 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
index f2a707a8ba8d76..44017a0c95d9a7 100644
--- 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
index ba90742fbdaabc..94464844afcad8 100644
--- 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
index 83cf753e824845..4b8e907317d617 100644
--- 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
index 026f16484c0949..3301a0f9b5bdee 100644
--- 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
index 18bb35a563167e..7f77fec0376762 100644
--- 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
index
bde5f3e29a3c2fecaff900fa230802c8ff171825..ca0e9b3ef980fb9098b08dfd3a80cf3b430178ac
100755
GIT binary patch
delta 292
zcmey-ANr#|v|$V5y{m%G`DLj^iRr1qiFuhNnN_Jp+uvVh?B>NH-u;+yovTnXRDFCg
zOhdc3CKC`d12GE_vjQ<25VHd@2M}`tF&7YXZ}-;ZF<g$#fW8Yn?R^(`ftU}7`M397
z5V*Jii^A=Ng@V<xSR~s2^$BkO*C!-7pA+uB=^vGZ#jvQ|?x82F%7jItz1~0=h()&7
J8;Dkl0|3b2a=QQk
delta 280
zcmey-ANr#|v|$V5y{m%3iFuhNnN_Jp&iQ4jMTzOD+uvVh?B>NH-u;+yo$K@mdQ3cQ
z5S8uTnoK~<48$xz%nHP8K+F!r96-zo#9Tnkz1>@r$8b4{&b|vg?R^(`ftU}7`M397
z5V*JiS;h9kLcwZTWRdoNeS+Kn^$AJNH!Oy^IX)Tc==ikK<c#9XM7`vK0tQU!?H+o<
Ws!T$d67BT{!ayvtz1~2yQXBwE{%igK
diff --git a/clang/test/CodeGen/sancov-new-pm.c
b/clang/test/CodeGen/sancov-new-pm.c
index 5ba82cc1cb22a6..a621f8a5a11a8e 100644
--- 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
index 44acfd3d8f3aaf..8d02140a6ca931 100644
--- 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
index f9fce595b37bb8..f5604d68925380 100644
--- 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
index 6235dfc2d4ba48..6a0b06121cdf28 100644
--- 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
index 7e5f041c91f21a..7494456dcf851d 100644
--- 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
index 66f2d259aa5fd4..1ab80900c8e5c1 100644
--- 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()
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_coverage_fuchsia.cpp
b/compiler-rt/lib/sanitizer_common/coverage_sanitizer_fuchsia.cpp
similarity index 98%
rename from compiler-rt/lib/sanitizer_common/sanitizer_coverage_fuchsia.cpp
rename to compiler-rt/lib/sanitizer_common/coverage_sanitizer_fuchsia.cpp
index 73668a56218cf0..9343079f78c38d 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_coverage_fuchsia.cpp
+++ b/compiler-rt/lib/sanitizer_common/coverage_sanitizer_fuchsia.cpp
@@ -1,4 +1,4 @@
-//===-- sanitizer_coverage_fuchsia.cpp
------------------------------------===//
+//===-- coverage_sanitizer_fuchsia.cpp
------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM
Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@@ -6,7 +6,7 @@
//
//===----------------------------------------------------------------------===//
//
-// Sanitizer Coverage Controller for Trace PC Guard, Fuchsia-specific version.
+// Coverage Sanitizer Controller for Trace PC Guard, Fuchsia-specific version.
//
// This Fuchsia-specific implementation uses the same basic scheme and the
// same simple '.sancov' file format as the generic implementation. The
@@ -105,7 +105,7 @@ class TracePcGuardController final {
// uses the `dumpfile` symbolizer markup element to highlight the
// dump. See the explanation for this in:
//
https://fuchsia.googlesource.com/zircon/+/master/docs/symbolizer_markup.md
- Printf("SanitizerCoverage: " FORMAT_DUMPFILE " with up to %u PCs\n",
+ Printf("CoverageSanitizer: " FORMAT_DUMPFILE " with up to %u PCs\n",
kSancovSinkName, vmo_name_, next_index_ - 1);
}
}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_coverage_interface.inc
b/compiler-rt/lib/sanitizer_common/coverage_sanitizer_interface.inc
similarity index 95%
rename from compiler-rt/lib/sanitizer_common/sanitizer_coverage_interface.inc
rename to compiler-rt/lib/sanitizer_common/coverage_sanitizer_interface.inc
index 9d36a40270d5a2..7cce23d3e5b838 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_coverage_interface.inc
+++ b/compiler-rt/lib/sanitizer_common/coverage_sanitizer_interface.inc
@@ -1,11 +1,11 @@
-//===-- sanitizer_coverage_interface.inc
----------------------------------===//
+//===-- coverage_sanitizer_interface.inc
----------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
-// Sanitizer Coverage interface list.
+// Coverage Sanitizer interface list.
//===----------------------------------------------------------------------===//
INTERFACE_FUNCTION(__sanitizer_cov_dump)
INTERFACE_FUNCTION(__sanitizer_cov_reset)
diff --git
a/compiler-rt/lib/sanitizer_common/sanitizer_coverage_libcdep_new.cpp
b/compiler-rt/lib/sanitizer_common/coverage_sanitizer_libcdep_new.cpp
similarity index 97%
rename from compiler-rt/lib/sanitizer_common/sanitizer_coverage_libcdep_new.cpp
rename to compiler-rt/lib/sanitizer_common/coverage_sanitizer_libcdep_new.cpp
index 506659a58c45ec..ab4d08053832cd 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_coverage_libcdep_new.cpp
+++ b/compiler-rt/lib/sanitizer_common/coverage_sanitizer_libcdep_new.cpp
@@ -1,11 +1,11 @@
-//===-- sanitizer_coverage_libcdep_new.cpp
--------------------------------===//
+//===-- coverage_sanitizer_libcdep_new.cpp
--------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
-// Sanitizer Coverage Controller for Trace PC Guard.
+// Coverage Sanitizer Controller for Trace PC Guard.
#include "sanitizer_platform.h"
@@ -33,7 +33,7 @@ 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",
+ Report("CoverageSanitizer: failed to open %s for writing (reason: %d)\n",
path, err);
return fd;
}
@@ -53,7 +53,7 @@ static void WriteModuleCoverage(char* file_path, const char*
module_name,
WriteToFile(fd, &Magic, sizeof(Magic));
WriteToFile(fd, pcs, len * sizeof(*pcs));
CloseFile(fd);
- Printf("SanitizerCoverage: %s: %zd PCs written\n", file_path, len);
+ Printf("CoverageSanitizer: %s: %zd PCs written\n", file_path, len);
}
static void SanitizerDumpCoverage(const uptr* unsorted_pcs, uptr len) {
diff --git
a/compiler-rt/lib/sanitizer_common/sanitizer_coverage_win_dll_thunk.cpp
b/compiler-rt/lib/sanitizer_common/coverage_sanitizer_win_dll_thunk.cpp
similarity index 85%
rename from
compiler-rt/lib/sanitizer_common/sanitizer_coverage_win_dll_thunk.cpp
rename to compiler-rt/lib/sanitizer_common/coverage_sanitizer_win_dll_thunk.cpp
index d0bf8a4556436c..7eb503da3710c3 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_coverage_win_dll_thunk.cpp
+++ b/compiler-rt/lib/sanitizer_common/coverage_sanitizer_win_dll_thunk.cpp
@@ -1,4 +1,4 @@
-//===-- sanitizer_coverage_win_dll_thunk.cpp
------------------------------===//
+//===-- coverage_sanitizer_win_dll_thunk.cpp
------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM
Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@@ -13,8 +13,8 @@
//===----------------------------------------------------------------------===//
#ifdef SANITIZER_DLL_THUNK
#include "sanitizer_win_dll_thunk.h"
-// Sanitizer Coverage interface functions.
+// Coverage Sanitizer interface functions.
#define INTERFACE_FUNCTION(Name) INTERCEPT_SANITIZER_FUNCTION(Name)
#define INTERFACE_WEAK_FUNCTION(Name) INTERCEPT_SANITIZER_WEAK_FUNCTION(Name)
-#include "sanitizer_coverage_interface.inc"
+#include "coverage_sanitizer_interface.inc"
#endif // SANITIZER_DLL_THUNK
diff --git
a/compiler-rt/lib/sanitizer_common/sanitizer_coverage_win_dynamic_runtime_thunk.cpp
b/compiler-rt/lib/sanitizer_common/coverage_sanitizer_win_dynamic_runtime_thunk.cpp
similarity index 78%
rename from
compiler-rt/lib/sanitizer_common/sanitizer_coverage_win_dynamic_runtime_thunk.cpp
rename to
compiler-rt/lib/sanitizer_common/coverage_sanitizer_win_dynamic_runtime_thunk.cpp
index 0bdf0c5aed418d..e7b024c7c4d135 100644
---
a/compiler-rt/lib/sanitizer_common/sanitizer_coverage_win_dynamic_runtime_thunk.cpp
+++
b/compiler-rt/lib/sanitizer_common/coverage_sanitizer_win_dynamic_runtime_thunk.cpp
@@ -1,4 +1,4 @@
-//===-- sanitizer_coverage_win_dynamic_runtime_thunk.cpp
------------------===//
+//===-- coverage_sanitizer_win_dynamic_runtime_thunk.cpp
------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM
Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@@ -7,16 +7,16 @@
//===----------------------------------------------------------------------===//
//
// This file defines things that need to be present in the application modules
-// to interact with Sanitizer Coverage, when it is included in a dll.
+// to interact with Coverage Sanitizer, when it is included in a dll.
//
//===----------------------------------------------------------------------===//
#ifdef SANITIZER_DYNAMIC_RUNTIME_THUNK
#define SANITIZER_IMPORT_INTERFACE 1
#include "sanitizer_win_defs.h"
-// Define weak alias for all weak functions imported from sanitizer coverage.
+// Define weak alias for all weak functions imported from coverage sanitizer.
#define INTERFACE_FUNCTION(Name)
#define INTERFACE_WEAK_FUNCTION(Name) WIN_WEAK_IMPORT_DEF(Name)
-#include "sanitizer_coverage_interface.inc"
+#include "coverage_sanitizer_interface.inc"
#endif // SANITIZER_DYNAMIC_RUNTIME_THUNK
namespace __sanitizer {
diff --git
a/compiler-rt/lib/sanitizer_common/sanitizer_coverage_win_sections.cpp
b/compiler-rt/lib/sanitizer_common/coverage_sanitizer_win_sections.cpp
similarity index 96%
rename from compiler-rt/lib/sanitizer_common/sanitizer_coverage_win_sections.cpp
rename to compiler-rt/lib/sanitizer_common/coverage_sanitizer_win_sections.cpp
index e7d6563393cfd5..5c4280341ae033 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_coverage_win_sections.cpp
+++ b/compiler-rt/lib/sanitizer_common/coverage_sanitizer_win_sections.cpp
@@ -1,4 +1,4 @@
-//===-- sanitizer_coverage_win_sections.cpp
-------------------------------===//
+//===-- coverage_sanitizer_win_sections.cpp
-------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM
Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@@ -6,7 +6,7 @@
//
//===----------------------------------------------------------------------===//
//
-// This file defines delimiters for Sanitizer Coverage's section. It contains
+// This file defines delimiters for Coverage Sanitizer's section. It contains
// Windows specific tricks to coax the linker into giving us the start and stop
// addresses of a section, as ELF linkers can do, to get the size of certain
// arrays. According to https://msdn.microsoft.com/en-us/library/7977wcck.aspx
diff --git
a/compiler-rt/lib/sanitizer_common/sanitizer_coverage_win_weak_interception.cpp
b/compiler-rt/lib/sanitizer_common/coverage_sanitizer_win_weak_interception.cpp
similarity index 85%
rename from
compiler-rt/lib/sanitizer_common/sanitizer_coverage_win_weak_interception.cpp
rename to
compiler-rt/lib/sanitizer_common/coverage_sanitizer_win_weak_interception.cpp
index 55263981705fa6..c30a310e91eb97 100644
---
a/compiler-rt/lib/sanitizer_common/sanitizer_coverage_win_weak_interception.cpp
+++
b/compiler-rt/lib/sanitizer_common/coverage_sanitizer_win_weak_interception.cpp
@@ -1,11 +1,11 @@
-//===-- sanitizer_coverage_win_weak_interception.cpp
----------------------===//
+//===-- coverage_sanitizer_win_weak_interception.cpp
----------------------===//
//
// 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 module should be included in Sanitizer Coverage when it implemented as
a
+// This module should be included in Coverage Sanitizer when it implemented as
a
// shared library on Windows (dll), in order to delegate the calls of weak
// functions to the implementation in the main executable when a strong
// definition is provided.
@@ -19,5 +19,5 @@
// implementations.
#define INTERFACE_FUNCTION(Name)
#define INTERFACE_WEAK_FUNCTION(Name) INTERCEPT_SANITIZER_WEAK_FUNCTION(Name)
-#include "sanitizer_coverage_interface.inc"
+#include "coverage_sanitizer_interface.inc"
#endif // SANITIZER_DYNAMIC
diff --git a/compiler-rt/lib/sanitizer_common/sancov_flags.cpp
b/compiler-rt/lib/sanitizer_common/sancov_flags.cpp
index 43b4bcc76729a3..bb844b10c567cf 100644
--- a/compiler-rt/lib/sanitizer_common/sancov_flags.cpp
+++ b/compiler-rt/lib/sanitizer_common/sancov_flags.cpp
@@ -6,7 +6,7 @@
//
//===----------------------------------------------------------------------===//
//
-// Sanitizer Coverage runtime flags.
+// Coverage Sanitizer runtime flags.
//
//===----------------------------------------------------------------------===//
diff --git a/compiler-rt/lib/sanitizer_common/sancov_flags.h
b/compiler-rt/lib/sanitizer_common/sancov_flags.h
index 95d4ee5ca43d72..a0158dada17ee8 100644
--- a/compiler-rt/lib/sanitizer_common/sancov_flags.h
+++ b/compiler-rt/lib/sanitizer_common/sancov_flags.h
@@ -6,7 +6,7 @@
//
//===----------------------------------------------------------------------===//
//
-// Sanitizer Coverage runtime flags.
+// Coverage Sanitizer runtime flags.
//
//===----------------------------------------------------------------------===//
#ifndef SANCOV_FLAGS_H
diff --git a/compiler-rt/lib/sanitizer_common/sancov_flags.inc
b/compiler-rt/lib/sanitizer_common/sancov_flags.inc
index de9ede217fc34b..53c9d40dc3ad4b 100644
--- a/compiler-rt/lib/sanitizer_common/sancov_flags.inc
+++ b/compiler-rt/lib/sanitizer_common/sancov_flags.inc
@@ -6,7 +6,7 @@
//
//===----------------------------------------------------------------------===//
//
-// Sanitizer Coverage runtime flags.
+// Coverage Sanitizer runtime flags.
//
//===----------------------------------------------------------------------===//
#ifndef SANCOV_FLAG
diff --git
a/compiler-rt/test/asan/TestCases/Darwin/interface_symbols_darwin.cpp
b/compiler-rt/test/asan/TestCases/Darwin/interface_symbols_darwin.cpp
index 2cedbc722c4635..eaf48355bfed13 100644
--- a/compiler-rt/test/asan/TestCases/Darwin/interface_symbols_darwin.cpp
+++ b/compiler-rt/test/asan/TestCases/Darwin/interface_symbols_darwin.cpp
@@ -32,7 +32,7 @@
// RUN: %p/../../../../lib/ubsan/ubsan_interface.inc
\
// RUN: %p/../../../../lib/sanitizer_common/sanitizer_common_interface.inc
\
// RUN:
%p/../../../../lib/sanitizer_common/sanitizer_common_interface_posix.inc \
-// RUN: %p/../../../../lib/sanitizer_common/sanitizer_coverage_interface.inc
\
+// RUN: %p/../../../../lib/sanitizer_common/coverage_sanitizer_interface.inc
\
// RUN: | grep -e "INTERFACE_\(WEAK_\)\?FUNCTION"
\
// RUN: | grep -v "__sanitizer_weak_hook"
\
// RUN: | sed -e "s/.*(//" -e "s/).*//" > %t.imports
diff --git a/compiler-rt/test/asan/TestCases/Linux/interface_symbols_linux.cpp
b/compiler-rt/test/asan/TestCases/Linux/interface_symbols_linux.cpp
index ce1255c9578317..97ded7e79c0d58 100644
--- a/compiler-rt/test/asan/TestCases/Linux/interface_symbols_linux.cpp
+++ b/compiler-rt/test/asan/TestCases/Linux/interface_symbols_linux.cpp
@@ -18,7 +18,7 @@
// RUN: %p/../../../../lib/ubsan/ubsan_interface.inc
\
// RUN: %p/../../../../lib/sanitizer_common/sanitizer_common_interface.inc
\
// RUN:
%p/../../../../lib/sanitizer_common/sanitizer_common_interface_posix.inc \
-// RUN: %p/../../../../lib/sanitizer_common/sanitizer_coverage_interface.inc
\
+// RUN: %p/../../../../lib/sanitizer_common/coverage_sanitizer_interface.inc
\
// RUN: | grep -e "INTERFACE_\(WEAK_\)\?FUNCTION"
\
// RUN: | grep -v "__sanitizer_weak_hook"
\
// RUN: | sed -e "s/.*(//" -e "s/).*//" > %t.imports
diff --git a/compiler-rt/test/asan/TestCases/Posix/coverage-reset.cpp
b/compiler-rt/test/asan/TestCases/Posix/coverage-reset.cpp
index e89181cc6c376c..8c3fd73e56fab1 100644
--- a/compiler-rt/test/asan/TestCases/Posix/coverage-reset.cpp
+++ b/compiler-rt/test/asan/TestCases/Posix/coverage-reset.cpp
@@ -27,8 +27,8 @@ int main(int argc, char **argv) {
bar2();
__sanitizer_cov_dump();
// CHECK: RESET
-// CHECK-DAG: SanitizerCoverage: ./coverage-reset.cpp{{.*}}.sancov: 2 PCs
written
-// CHECK-DAG: SanitizerCoverage: ./libcoverage-reset.cpp{{.*}}.sancov: 2 PCs
written
+// CHECK-DAG: CoverageSanitizer: ./coverage-reset.cpp{{.*}}.sancov: 2 PCs
written
+// CHECK-DAG: CoverageSanitizer: ./libcoverage-reset.cpp{{.*}}.sancov: 2 PCs
written
fprintf(stderr, "RESET\n");
__sanitizer_cov_reset();
@@ -36,8 +36,8 @@ int main(int argc, char **argv) {
bar1();
__sanitizer_cov_dump();
// CHECK: RESET
-// CHECK-DAG: SanitizerCoverage: ./coverage-reset.cpp{{.*}}.sancov: 1 PCs
written
-// CHECK-DAG: SanitizerCoverage: ./libcoverage-reset.cpp{{.*}}.sancov: 1 PCs
written
+// CHECK-DAG: CoverageSanitizer: ./coverage-reset.cpp{{.*}}.sancov: 1 PCs
written
+// CHECK-DAG: CoverageSanitizer: ./libcoverage-reset.cpp{{.*}}.sancov: 1 PCs
written
fprintf(stderr, "RESET\n");
__sanitizer_cov_reset();
@@ -45,7 +45,7 @@ int main(int argc, char **argv) {
foo2();
__sanitizer_cov_dump();
// CHECK: RESET
-// CHECK: SanitizerCoverage: ./coverage-reset.cpp{{.*}}.sancov: 2 PCs written
+// CHECK: CoverageSanitizer: ./coverage-reset.cpp{{.*}}.sancov: 2 PCs written
fprintf(stderr, "RESET\n");
__sanitizer_cov_reset();
@@ -53,13 +53,13 @@ int main(int argc, char **argv) {
bar2();
__sanitizer_cov_dump();
// CHECK: RESET
-// CHECK: SanitizerCoverage: ./libcoverage-reset.cpp{{.*}}.sancov: 2 PCs
written
+// CHECK: CoverageSanitizer: ./libcoverage-reset.cpp{{.*}}.sancov: 2 PCs
written
fprintf(stderr, "RESET\n");
__sanitizer_cov_reset();
// CHECK: RESET
bar2();
-// CHECK: SanitizerCoverage: ./libcoverage-reset.cpp{{.*}}.sancov: 1 PCs
written
+// CHECK: CoverageSanitizer: ./libcoverage-reset.cpp{{.*}}.sancov: 1 PCs
written
}
#endif
diff --git a/compiler-rt/test/asan/TestCases/coverage-and-lsan.cpp
b/compiler-rt/test/asan/TestCases/coverage-and-lsan.cpp
index 294de13ce19725..0c173d1a561643 100644
--- a/compiler-rt/test/asan/TestCases/coverage-and-lsan.cpp
+++ b/compiler-rt/test/asan/TestCases/coverage-and-lsan.cpp
@@ -19,4 +19,4 @@ int main(int argc, char **argv) {
}
// CHECK: LeakSanitizer: detected memory leaks
-// CHECK: SanitizerCoverage: {{.*}}PCs written
+// CHECK: CoverageSanitizer: {{.*}}PCs written
diff --git
a/compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_allowlist_ignorelist.cpp
b/compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_allowlist_ignorelist.cpp
similarity index 100%
rename from
compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_allowlist_ignorelist.cpp
rename to
compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_allowlist_ignorelist.cpp
diff --git
a/compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_control_flow.cpp
b/compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_control_flow.cpp
similarity index 100%
rename from
compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_control_flow.cpp
rename to
compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_control_flow.cpp
diff --git
a/compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_inline8bit_counter.cpp
b/compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_inline8bit_counter.cpp
similarity index 100%
rename from
compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_inline8bit_counter.cpp
rename to
compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_inline8bit_counter.cpp
diff --git
a/compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_inline8bit_counter_default_impl.cpp
b/compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_inline8bit_counter_default_impl.cpp
similarity index 100%
rename from
compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_inline8bit_counter_default_impl.cpp
rename to
compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_inline8bit_counter_default_impl.cpp
diff --git
a/compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_inline_bool_flag.cpp
b/compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_inline_bool_flag.cpp
similarity index 100%
rename from
compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_inline_bool_flag.cpp
rename to
compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_inline_bool_flag.cpp
diff --git
a/compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_no_prune.cpp
b/compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_no_prune.cpp
similarity index 100%
rename from
compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_no_prune.cpp
rename to
compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_no_prune.cpp
diff --git
a/compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_stack_depth.cpp
b/compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_stack_depth.cpp
similarity index 100%
rename from
compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_stack_depth.cpp
rename to
compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_stack_depth.cpp
diff --git
a/compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_symbolize.cpp
b/compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_symbolize.cpp
similarity index 91%
rename from
compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_symbolize.cpp
rename to
compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_symbolize.cpp
index ba59e28f688a71..6e46d4b80a595e 100644
---
a/compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_symbolize.cpp
+++
b/compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_symbolize.cpp
@@ -26,4 +26,4 @@ int main() {
}
// CHECK: main
-// CHECK: SanitizerCoverage: ./sanitizer_coverage_symbolize.{{.*}}.sancov: 2
PCs written
+// CHECK: CoverageSanitizer: ./coverage_sanitizer_symbolize.{{.*}}.sancov: 2
PCs written
diff --git
a/compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_trace_loads_stores.cpp
b/compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_trace_loads_stores.cpp
similarity index 100%
rename from
compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_trace_loads_stores.cpp
rename to
compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_trace_loads_stores.cpp
diff --git
a/compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_trace_pc_guard-dso.cpp
b/compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_trace_pc_guard-dso.cpp
similarity index 83%
rename from
compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_trace_pc_guard-dso.cpp
rename to
compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_trace_pc_guard-dso.cpp
index 9a27bc89a5fae1..a3911c099cf195 100644
---
a/compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_trace_pc_guard-dso.cpp
+++
b/compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_trace_pc_guard-dso.cpp
@@ -62,11 +62,11 @@ int baz() {
// CHECK-NEXT: foo
// CHECK-NEXT: bar
// CHECK-NEXT: baz
-// CHECK-DAG: SanitizerCoverage:
./sanitizer_coverage_trace_pc_guard-dso.{{.*}}.sancov: 2 PCs written
-// CHECK-DAG: SanitizerCoverage:
./sanitizer_coverage_trace_pc_guard-dso.{{.*}}_2.so.{{.*}}.sancov: 1 PCs written
-// CHECK-DAG: SanitizerCoverage:
./sanitizer_coverage_trace_pc_guard-dso.{{.*}}_1.so.{{.*}}.sancov: 1 PCs written
+// CHECK-DAG: CoverageSanitizer:
./coverage_sanitizer_trace_pc_guard-dso.{{.*}}.sancov: 2 PCs written
+// CHECK-DAG: CoverageSanitizer:
./coverage_sanitizer_trace_pc_guard-dso.{{.*}}_2.so.{{.*}}.sancov: 1 PCs written
+// CHECK-DAG: CoverageSanitizer:
./coverage_sanitizer_trace_pc_guard-dso.{{.*}}_1.so.{{.*}}.sancov: 1 PCs written
//
// CHECK-SANCOV: Ignoring {{.*}}_1.so and its coverage because
__sanitizer_cov* functions were not found.
// CHECK-SANCOV: Ignoring {{.*}}_2.so and its coverage because
__sanitizer_cov* functions were not found.
-// CHECK-SANCOV-NEXT: sanitizer_coverage_trace_pc_guard-dso.cpp:[[@LINE-42]]
foo
-// CHECK-SANCOV-NEXT: sanitizer_coverage_trace_pc_guard-dso.cpp:[[@LINE-38]]
main
+// CHECK-SANCOV-NEXT: coverage_sanitizer_trace_pc_guard-dso.cpp:[[@LINE-42]]
foo
+// CHECK-SANCOV-NEXT: coverage_sanitizer_trace_pc_guard-dso.cpp:[[@LINE-38]]
main
diff --git
a/compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_trace_pc_guard-init.cpp
b/compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_trace_pc_guard-init.cpp
similarity index 100%
rename from
compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_trace_pc_guard-init.cpp
rename to
compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_trace_pc_guard-init.cpp
diff --git
a/compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_trace_pc_guard.cpp
b/compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_trace_pc_guard.cpp
similarity index 81%
rename from
compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_trace_pc_guard.cpp
rename to
compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_trace_pc_guard.cpp
index b4b491455c390a..6e35d337c18985 100644
---
a/compiler-rt/test/sanitizer_common/TestCases/sanitizer_coverage_trace_pc_guard.cpp
+++
b/compiler-rt/test/sanitizer_common/TestCases/coverage_sanitizer_trace_pc_guard.cpp
@@ -34,9 +34,9 @@ int main() {
// CHECK: main
// CHECK-NEXT: foo
// CHECK-NEXT: foo
-// CHECK-NEXT: SanitizerCoverage:
./sanitizer_coverage_trace_pc_guard.{{.*}}.sancov: 2 PCs written
+// CHECK-NEXT: CoverageSanitizer:
./coverage_sanitizer_trace_pc_guard.{{.*}}.sancov: 2 PCs written
//
-// CHECK-SANCOV: sanitizer_coverage_trace_pc_guard.cpp:[[@LINE-16]] foo
-// CHECK-SANCOV-NEXT: sanitizer_coverage_trace_pc_guard.cpp:[[@LINE-12]] main
+// CHECK-SANCOV: coverage_sanitizer_trace_pc_guard.cpp:[[@LINE-16]] foo
+// CHECK-SANCOV-NEXT: coverage_sanitizer_trace_pc_guard.cpp:[[@LINE-12]] main
//
-// CHECK-NOCOV-NOT: SanitizerCoverage
+// CHECK-NOCOV-NOT: CoverageSanitizer
diff --git a/libcxx/docs/VendorDocumentation.rst
b/libcxx/docs/VendorDocumentation.rst
index 3a3d1cdb1ea7ff..9d12e17eeda443 100644
--- a/libcxx/docs/VendorDocumentation.rst
+++ b/libcxx/docs/VendorDocumentation.rst
@@ -257,7 +257,7 @@ General purpose options
A semicolon list of arguments to pass when running the libc++ benchmarks
using the
``check-cxx-benchmarks`` rule. By default we run the benchmarks for a very
short amount of time,
- since the primary use of ``check-cxx-benchmarks`` is to get test and
sanitizer coverage, not to
+ since the primary use of ``check-cxx-benchmarks`` is to get test and
coverage sanitizer, not to
get accurate measurements.
.. option:: LIBCXX_ASSERTION_HANDLER_FILE:PATH
diff --git a/lldb/docs/resources/fuzzing.rst b/lldb/docs/resources/fuzzing.rst
index b236f08ae1c8e8..a54ae506e172fa 100644
--- a/lldb/docs/resources/fuzzing.rst
+++ b/lldb/docs/resources/fuzzing.rst
@@ -9,7 +9,7 @@ LLDB has fuzzers that provide automated `fuzz testing
<https://en.wikipedia.org/
Building the fuzzers
--------------------
-Building the LLDB fuzzers requires a build configuration that has the address
sanitizer and sanitizer coverage enabled. In addition to your regular CMake
arguments, you will need these arguments to build the fuzzers:
+Building the LLDB fuzzers requires a build configuration that has the address
sanitizer and coverage sanitizer enabled. In addition to your regular CMake
arguments, you will need these arguments to build the fuzzers:
::
@@ -17,7 +17,7 @@ Building the LLDB fuzzers requires a build configuration that
has the address sa
-DLLVM_USE_SANITIZE_COVERAGE=On \
-DCLANG_ENABLE_PROTO_FUZZER=ON
-More information on libFuzzer's sanitizer coverage is available here:
`<https://llvm.org/docs/LibFuzzer.html#fuzzer-usage>`_
+More information on libFuzzer's coverage sanitizer is available here:
`<https://llvm.org/docs/LibFuzzer.html#fuzzer-usage>`_
If you want to debug LLDB itself when you find a bug using the fuzzers, use
the CMake option ``-DCMAKE_BUILD_TYPE='RelWithDebInfo'``
diff --git a/llvm/docs/FuzzingLLVM.rst b/llvm/docs/FuzzingLLVM.rst
index 6b32eeab1241d8..ab1cbb6273262a 100644
--- a/llvm/docs/FuzzingLLVM.rst
+++ b/llvm/docs/FuzzingLLVM.rst
@@ -234,7 +234,7 @@ Configuring LLVM to Build Fuzzers
---------------------------------
Fuzzers will be built and linked to libFuzzer by default as long as you build
-LLVM with sanitizer coverage enabled. You would typically also enable at least
+LLVM with coverage sanitizer enabled. You would typically also enable at least
one sanitizer to find bugs faster. The most common way to build the fuzzers is
by adding the following two flags to your CMake invocation:
``-DLLVM_USE_SANITIZER=Address -DLLVM_USE_SANITIZE_COVERAGE=On``.
diff --git a/llvm/docs/LangRef.rst b/llvm/docs/LangRef.rst
index 8c696cb16e77f8..1fd591463a1f15 100644
--- a/llvm/docs/LangRef.rst
+++ b/llvm/docs/LangRef.rst
@@ -2187,7 +2187,7 @@ example:
This attribute indicates that bounds checking sanitizer instrumentation
is disabled for this function.
``nosanitize_coverage``
- This attribute indicates that SanitizerCoverage instrumentation is disabled
+ This attribute indicates that CoverageSanitizer instrumentation is disabled
for this function.
``nosanitize_realtime``
This attribute indicates that the Realtime Sanitizer instrumentation is
diff --git a/llvm/docs/LibFuzzer.rst b/llvm/docs/LibFuzzer.rst
index 9e34530e7e3e78..0834093866be50 100644
--- a/llvm/docs/LibFuzzer.rst
+++ b/llvm/docs/LibFuzzer.rst
@@ -15,7 +15,7 @@ library via a specific fuzzing entrypoint (aka "target
function"); the fuzzer
then tracks which areas of the code are reached, and generates mutations on the
corpus of input data in order to maximize the code coverage.
The code coverage
-information for libFuzzer is provided by LLVM's SanitizerCoverage_
+information for libFuzzer is provided by LLVM's CoverageSanitizer_
instrumentation.
Contact: libfuzzer(#)googlegroups.com
@@ -507,7 +507,7 @@ Tracing CMP instructions
------------------------
With an additional compiler flag ``-fsanitize-coverage=trace-cmp``
-(on by default as part of ``-fsanitize=fuzzer``, see
SanitizerCoverageTraceDataFlow_)
+(on by default as part of ``-fsanitize=fuzzer``, see
CoverageSanitizerTraceDataFlow_)
libFuzzer will intercept CMP instructions and guide mutations based
on the arguments of intercepted CMP instructions. This may slow down
the fuzzing but is very likely to improve the results.
@@ -837,8 +837,8 @@ Trophies
.. _pcre2: http://www.pcre.org/
.. _AFL: http://lcamtuf.coredump.cx/afl/
.. _Radamsa: https://github.com/aoh/radamsa
-.. _SanitizerCoverage: https://clang.llvm.org/docs/SanitizerCoverage.html
-.. _SanitizerCoverageTraceDataFlow:
https://clang.llvm.org/docs/SanitizerCoverage.html#tracing-data-flow
+.. _CoverageSanitizer: https://clang.llvm.org/docs/CoverageSanitizer.html
+.. _CoverageSanitizerTraceDataFlow:
https://clang.llvm.org/docs/CoverageSanitizer.html#tracing-data-flow
.. _AddressSanitizer: https://clang.llvm.org/docs/AddressSanitizer.html
.. _LeakSanitizer: https://clang.llvm.org/docs/LeakSanitizer.html
.. _Heartbleed: http://en.wikipedia.org/wiki/Heartbleed
@@ -847,9 +847,9 @@ Trophies
.. _building Clang from trunk: https://clang.llvm.org/get_started.html
.. _MemorySanitizer: https://clang.llvm.org/docs/MemorySanitizer.html
.. _UndefinedBehaviorSanitizer:
https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html
-.. _`coverage counters`:
https://clang.llvm.org/docs/SanitizerCoverage.html#coverage-counters
+.. _`coverage counters`:
https://clang.llvm.org/docs/CoverageSanitizer.html#coverage-counters
.. _`value profile`: #value-profile
-.. _`caller-callee pairs`:
https://clang.llvm.org/docs/SanitizerCoverage.html#caller-callee-coverage
+.. _`caller-callee pairs`:
https://clang.llvm.org/docs/CoverageSanitizer.html#caller-callee-coverage
.. _BoringSSL: https://boringssl.googlesource.com/boringssl/
.. _Centipede: https://github.com/google/centipede
diff --git a/llvm/docs/SymbolizerMarkupFormat.rst
b/llvm/docs/SymbolizerMarkupFormat.rst
index d5b17d7e2d1d4b..6710cd1d2ae977 100644
--- a/llvm/docs/SymbolizerMarkupFormat.rst
+++ b/llvm/docs/SymbolizerMarkupFormat.rst
@@ -339,7 +339,7 @@ the external action can then be presented to the user.
processes.
An example of a type identifier is ``sancov``, for dumps from LLVM
- `SanitizerCoverage <https://clang.llvm.org/docs/SanitizerCoverage.html>`_.
+ `CoverageSanitizer <https://clang.llvm.org/docs/CoverageSanitizer.html>`_.
Example::
diff --git a/llvm/include/llvm/Transforms/Instrumentation.h
b/llvm/include/llvm/Transforms/Instrumentation.h
index 1a4824a806dc6e..f37bdcb3aef49b 100644
--- a/llvm/include/llvm/Transforms/Instrumentation.h
+++ b/llvm/include/llvm/Transforms/Instrumentation.h
@@ -137,8 +137,8 @@ struct InstrProfOptions {
// Create the variable for profile sampling.
void createProfileSamplingVar(Module &M);
-// Options for sanitizer coverage instrumentation.
-struct SanitizerCoverageOptions {
+// Options for coverage sanitizer instrumentation.
+struct CoverageSanitizerOptions {
enum Type {
SCK_None = 0,
SCK_Function,
@@ -162,7 +162,7 @@ struct SanitizerCoverageOptions {
bool TraceStores = false;
bool CollectControlFlow = false;
- SanitizerCoverageOptions() = default;
+ CoverageSanitizerOptions() = default;
};
/// Calculate what to divide by to scale counts.
diff --git a/llvm/include/llvm/Transforms/Instrumentation/SanitizerCoverage.h
b/llvm/include/llvm/Transforms/Instrumentation/CoverageSanitizer.h
similarity index 81%
rename from llvm/include/llvm/Transforms/Instrumentation/SanitizerCoverage.h
rename to llvm/include/llvm/Transforms/Instrumentation/CoverageSanitizer.h
index 89ab4fd114fccf..12eae18f748027 100644
--- a/llvm/include/llvm/Transforms/Instrumentation/SanitizerCoverage.h
+++ b/llvm/include/llvm/Transforms/Instrumentation/CoverageSanitizer.h
@@ -1,4 +1,4 @@
-//===--------- Definition of the SanitizerCoverage class --------*- C++
-*-===//
+//===--------- Definition of the CoverageSanitizer class --------*- C++
-*-===//
//
// The LLVM Compiler Infrastructure
//
@@ -8,7 +8,7 @@
//
//===----------------------------------------------------------------------===//
//
-// SanitizerCoverage is a simple code coverage implementation.
+// CoverageSanitizer is a simple code coverage implementation.
//
//===----------------------------------------------------------------------===//
@@ -23,14 +23,14 @@
namespace llvm {
class Module;
-/// This is the ModuleSanitizerCoverage pass used in the new pass manager. The
+/// This is the ModuleCoverageSanitizer pass used in the new pass manager. The
/// pass instruments functions for coverage, adds initialization calls to the
/// module for trace PC guards and 8bit counters if they are requested, and
/// appends globals to llvm.compiler.used.
-class SanitizerCoveragePass : public PassInfoMixin<SanitizerCoveragePass> {
+class CoverageSanitizerPass : public PassInfoMixin<CoverageSanitizerPass> {
public:
- explicit SanitizerCoveragePass(
- SanitizerCoverageOptions Options = SanitizerCoverageOptions(),
+ explicit CoverageSanitizerPass(
+ CoverageSanitizerOptions Options = CoverageSanitizerOptions(),
const std::vector<std::string> &AllowlistFiles =
std::vector<std::string>(),
const std::vector<std::string> &BlocklistFiles =
@@ -47,7 +47,7 @@ class SanitizerCoveragePass : public
PassInfoMixin<SanitizerCoveragePass> {
static bool isRequired() { return true; }
private:
- SanitizerCoverageOptions Options;
+ CoverageSanitizerOptions Options;
std::unique_ptr<SpecialCaseList> Allowlist;
std::unique_ptr<SpecialCaseList> Blocklist;
diff --git a/llvm/lib/Passes/PassBuilder.cpp b/llvm/lib/Passes/PassBuilder.cpp
index 17eed97fd950c9..46afb5c72b42c8 100644
--- a/llvm/lib/Passes/PassBuilder.cpp
+++ b/llvm/lib/Passes/PassBuilder.cpp
@@ -203,7 +203,7 @@
#include "llvm/Transforms/Instrumentation/PoisonChecking.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/ADCE.h"
diff --git a/llvm/lib/Passes/PassRegistry.def b/llvm/lib/Passes/PassRegistry.def
index d6067089c6b5c1..962caa10b0117f 100644
--- a/llvm/lib/Passes/PassRegistry.def
+++ b/llvm/lib/Passes/PassRegistry.def
@@ -134,7 +134,7 @@ MODULE_PASS("rewrite-statepoints-for-gc",
RewriteStatepointsForGC())
MODULE_PASS("rewrite-symbols", RewriteSymbolPass())
MODULE_PASS("rpo-function-attrs", ReversePostOrderFunctionAttrsPass())
MODULE_PASS("sample-profile", SampleProfileLoaderPass())
-MODULE_PASS("sancov-module", SanitizerCoveragePass())
+MODULE_PASS("sancov-module", CoverageSanitizerPass())
MODULE_PASS("sanmd-module", SanitizerBinaryMetadataPass())
MODULE_PASS("scc-oz-module-inliner",
buildInlinerPipeline(OptimizationLevel::Oz,
diff --git a/llvm/lib/Transforms/Instrumentation/CMakeLists.txt
b/llvm/lib/Transforms/Instrumentation/CMakeLists.txt
index deab37801ff1df..de86a8cac63031 100644
--- a/llvm/lib/Transforms/Instrumentation/CMakeLists.txt
+++ b/llvm/lib/Transforms/Instrumentation/CMakeLists.txt
@@ -20,7 +20,7 @@ add_llvm_component_library(LLVMInstrumentation
PGOInstrumentation.cpp
PGOMemOPSizeOpt.cpp
PoisonChecking.cpp
- SanitizerCoverage.cpp
+ CoverageSanitizer.cpp
SanitizerBinaryMetadata.cpp
ValueProfileCollector.cpp
ThreadSanitizer.cpp
diff --git a/llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp
b/llvm/lib/Transforms/Instrumentation/CoverageSanitizer.cpp
similarity index 94%
rename from llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp
rename to llvm/lib/Transforms/Instrumentation/CoverageSanitizer.cpp
index 6a89cee9aaf6cc..ff9157b80677b7 100644
--- a/llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp
+++ b/llvm/lib/Transforms/Instrumentation/CoverageSanitizer.cpp
@@ -1,4 +1,4 @@
-//===-- SanitizerCoverage.cpp - coverage instrumentation for sanitizers
---===//
+//===-- CoverageSanitizer.cpp - coverage instrumentation for sanitizers
---===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM
Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@@ -10,7 +10,7 @@
//
//===----------------------------------------------------------------------===//
-#include "llvm/Transforms/Instrumentation/SanitizerCoverage.h"
+#include "llvm/Transforms/Instrumentation/CoverageSanitizer.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Analysis/GlobalsModRef.h"
@@ -154,32 +154,32 @@ static cl::opt<bool>
namespace {
-SanitizerCoverageOptions getOptions(int LegacyCoverageLevel) {
- SanitizerCoverageOptions Res;
+CoverageSanitizerOptions getOptions(int LegacyCoverageLevel) {
+ CoverageSanitizerOptions Res;
switch (LegacyCoverageLevel) {
case 0:
- Res.CoverageType = SanitizerCoverageOptions::SCK_None;
+ Res.CoverageType = CoverageSanitizerOptions::SCK_None;
break;
case 1:
- Res.CoverageType = SanitizerCoverageOptions::SCK_Function;
+ Res.CoverageType = CoverageSanitizerOptions::SCK_Function;
break;
case 2:
- Res.CoverageType = SanitizerCoverageOptions::SCK_BB;
+ Res.CoverageType = CoverageSanitizerOptions::SCK_BB;
break;
case 3:
- Res.CoverageType = SanitizerCoverageOptions::SCK_Edge;
+ Res.CoverageType = CoverageSanitizerOptions::SCK_Edge;
break;
case 4:
- Res.CoverageType = SanitizerCoverageOptions::SCK_Edge;
+ Res.CoverageType = CoverageSanitizerOptions::SCK_Edge;
Res.IndirectCalls = true;
break;
}
return Res;
}
-SanitizerCoverageOptions OverrideFromCL(SanitizerCoverageOptions Options) {
+CoverageSanitizerOptions OverrideFromCL(CoverageSanitizerOptions Options) {
// Sets CoverageType and IndirectCalls.
- SanitizerCoverageOptions CLOpts = getOptions(ClCoverageLevel);
+ CoverageSanitizerOptions CLOpts = getOptions(ClCoverageLevel);
Options.CoverageType = std::max(Options.CoverageType, CLOpts.CoverageType);
Options.IndirectCalls |= CLOpts.IndirectCalls;
Options.TraceCmp |= ClCMPTracing;
@@ -202,15 +202,15 @@ SanitizerCoverageOptions
OverrideFromCL(SanitizerCoverageOptions Options) {
return Options;
}
-class ModuleSanitizerCoverage {
+class ModuleCoverageSanitizer {
public:
using DomTreeCallback = function_ref<const DominatorTree &(Function &F)>;
using PostDomTreeCallback =
function_ref<const PostDominatorTree &(Function &F)>;
- ModuleSanitizerCoverage(Module &M, DomTreeCallback DTCallback,
+ ModuleCoverageSanitizer(Module &M, DomTreeCallback DTCallback,
PostDomTreeCallback PDTCallback,
- const SanitizerCoverageOptions &Options,
+ const CoverageSanitizerOptions &Options,
const SpecialCaseList *Allowlist,
const SpecialCaseList *Blocklist)
: M(M), DTCallback(DTCallback), PDTCallback(PDTCallback),
@@ -280,14 +280,14 @@ class ModuleSanitizerCoverage {
SmallVector<GlobalValue *, 20> GlobalsToAppendToUsed;
SmallVector<GlobalValue *, 20> GlobalsToAppendToCompilerUsed;
- SanitizerCoverageOptions Options;
+ CoverageSanitizerOptions Options;
const SpecialCaseList *Allowlist;
const SpecialCaseList *Blocklist;
};
} // namespace
-PreservedAnalyses SanitizerCoveragePass::run(Module &M,
+PreservedAnalyses CoverageSanitizerPass::run(Module &M,
ModuleAnalysisManager &MAM) {
auto &FAM =
MAM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
auto DTCallback = [&FAM](Function &F) -> const DominatorTree & {
@@ -296,7 +296,7 @@ PreservedAnalyses SanitizerCoveragePass::run(Module &M,
auto PDTCallback = [&FAM](Function &F) -> const PostDominatorTree & {
return FAM.getResult<PostDominatorTreeAnalysis>(F);
};
- ModuleSanitizerCoverage ModuleSancov(M, DTCallback, PDTCallback,
+ ModuleCoverageSanitizer ModuleSancov(M, DTCallback, PDTCallback,
OverrideFromCL(Options),
Allowlist.get(),
Blocklist.get());
if (!ModuleSancov.instrumentModule())
@@ -311,7 +311,7 @@ PreservedAnalyses SanitizerCoveragePass::run(Module &M,
}
std::pair<Value *, Value *>
-ModuleSanitizerCoverage::CreateSecStartEnd(Module &M, const char *Section,
+ModuleCoverageSanitizer::CreateSecStartEnd(Module &M, const char *Section,
Type *Ty) {
// Use ExternalWeak so that if all sections are discarded due to section
// garbage collection, the linker will not report undefined symbol errors.
@@ -339,7 +339,7 @@ ModuleSanitizerCoverage::CreateSecStartEnd(Module &M, const
char *Section,
return std::make_pair(GEP, SecEnd);
}
-Function *ModuleSanitizerCoverage::CreateInitCallsForSections(
+Function *ModuleCoverageSanitizer::CreateInitCallsForSections(
Module &M, const char *CtorName, const char *InitFunctionName, Type *Ty,
const char *Section) {
auto SecStartEnd = CreateSecStartEnd(M, Section, Ty);
@@ -370,8 +370,8 @@ Function
*ModuleSanitizerCoverage::CreateInitCallsForSections(
return CtorFunc;
}
-bool ModuleSanitizerCoverage::instrumentModule() {
- if (Options.CoverageType == SanitizerCoverageOptions::SCK_None)
+bool ModuleCoverageSanitizer::instrumentModule() {
+ if (Options.CoverageType == CoverageSanitizerOptions::SCK_None)
return false;
if (Allowlist &&
!Allowlist->inSection("coverage", "src", M.getSourceFileName()))
@@ -545,7 +545,7 @@ static bool isFullPostDominator(const BasicBlock *BB,
static bool shouldInstrumentBlock(const Function &F, const BasicBlock *BB,
const DominatorTree &DT,
const PostDominatorTree &PDT,
- const SanitizerCoverageOptions &Options) {
+ const CoverageSanitizerOptions &Options) {
// Don't insert coverage for blocks containing nothing but unreachable: we
// will never call __sanitizer_cov() for them, so counting them in
// NumberOfInstrumentedBlocks() might complicate calculation of code coverage
@@ -562,7 +562,7 @@ static bool shouldInstrumentBlock(const Function &F, const
BasicBlock *BB,
if (Options.NoPrune || &F.getEntryBlock() == BB)
return true;
- if (Options.CoverageType == SanitizerCoverageOptions::SCK_Function &&
+ if (Options.CoverageType == CoverageSanitizerOptions::SCK_Function &&
&F.getEntryBlock() != BB)
return false;
@@ -592,7 +592,7 @@ static bool IsBackEdge(BasicBlock *From, BasicBlock *To,
// Note that Cmp pruning is controlled by the same flag as the
// BB pruning.
static bool IsInterestingCmp(ICmpInst *CMP, const DominatorTree &DT,
- const SanitizerCoverageOptions &Options) {
+ const CoverageSanitizerOptions &Options) {
if (!Options.NoPrune)
if (CMP->hasOneUse())
if (auto BR = dyn_cast<BranchInst>(CMP->user_back()))
@@ -602,7 +602,7 @@ static bool IsInterestingCmp(ICmpInst *CMP, const
DominatorTree &DT,
return true;
}
-void ModuleSanitizerCoverage::instrumentFunction(Function &F) {
+void ModuleCoverageSanitizer::instrumentFunction(Function &F) {
if (F.empty())
return;
if (F.getName().contains(".module_ctor"))
@@ -633,7 +633,7 @@ void ModuleSanitizerCoverage::instrumentFunction(Function
&F) {
return;
if (F.hasFnAttribute(Attribute::DisableSanitizerInstrumentation))
return;
- if (Options.CoverageType >= SanitizerCoverageOptions::SCK_Edge) {
+ if (Options.CoverageType >= CoverageSanitizerOptions::SCK_Edge) {
SplitAllCriticalEdges(
F, CriticalEdgeSplittingOptions().setIgnoreUnreachableDests());
}
@@ -699,7 +699,7 @@ void ModuleSanitizerCoverage::instrumentFunction(Function
&F) {
InjectTraceForLoadsAndStores(F, Loads, Stores);
}
-GlobalVariable *ModuleSanitizerCoverage::CreateFunctionLocalArrayInSection(
+GlobalVariable *ModuleCoverageSanitizer::CreateFunctionLocalArrayInSection(
size_t NumElements, Function &F, Type *Ty, const char *Section) {
ArrayType *ArrayTy = ArrayType::get(Ty, NumElements);
auto Array = new GlobalVariable(
@@ -731,7 +731,7 @@ GlobalVariable
*ModuleSanitizerCoverage::CreateFunctionLocalArrayInSection(
}
GlobalVariable *
-ModuleSanitizerCoverage::CreatePCArray(Function &F,
+ModuleCoverageSanitizer::CreatePCArray(Function &F,
ArrayRef<BasicBlock *> AllBlocks) {
size_t N = AllBlocks.size();
assert(N);
@@ -757,7 +757,7 @@ ModuleSanitizerCoverage::CreatePCArray(Function &F,
return PCArray;
}
-void ModuleSanitizerCoverage::CreateFunctionLocalArrays(
+void ModuleCoverageSanitizer::CreateFunctionLocalArrays(
Function &F, ArrayRef<BasicBlock *> AllBlocks) {
if (Options.TracePCGuard)
FunctionGuardArray = CreateFunctionLocalArrayInSection(
@@ -774,7 +774,7 @@ void ModuleSanitizerCoverage::CreateFunctionLocalArrays(
FunctionPCsArray = CreatePCArray(F, AllBlocks);
}
-bool ModuleSanitizerCoverage::InjectCoverage(Function &F,
+bool ModuleCoverageSanitizer::InjectCoverage(Function &F,
ArrayRef<BasicBlock *> AllBlocks,
bool IsLeafFunc) {
if (AllBlocks.empty()) return false;
@@ -791,7 +791,7 @@ bool ModuleSanitizerCoverage::InjectCoverage(Function &F,
// The cache is used to speed up recording the caller-callee pairs.
// The address of the caller is passed implicitly via caller PC.
// CacheSize is encoded in the name of the run-time function.
-void ModuleSanitizerCoverage::InjectCoverageForIndirectCalls(
+void ModuleCoverageSanitizer::InjectCoverageForIndirectCalls(
Function &F, ArrayRef<Instruction *> IndirCalls) {
if (IndirCalls.empty())
return;
@@ -811,7 +811,7 @@ void
ModuleSanitizerCoverage::InjectCoverageForIndirectCalls(
// __sanitizer_cov_trace_switch(CondValue,
// {NumCases, ValueSizeInBits, Case0Value, Case1Value, Case2Value, ... })
-void ModuleSanitizerCoverage::InjectTraceForSwitch(
+void ModuleCoverageSanitizer::InjectTraceForSwitch(
Function &, ArrayRef<Instruction *> SwitchTraceTargets) {
for (auto *I : SwitchTraceTargets) {
if (SwitchInst *SI = dyn_cast<SwitchInst>(I)) {
@@ -848,7 +848,7 @@ void ModuleSanitizerCoverage::InjectTraceForSwitch(
}
}
-void ModuleSanitizerCoverage::InjectTraceForDiv(
+void ModuleCoverageSanitizer::InjectTraceForDiv(
Function &, ArrayRef<BinaryOperator *> DivTraceTargets) {
for (auto *BO : DivTraceTargets) {
InstrumentationIRBuilder IRB(BO);
@@ -866,7 +866,7 @@ void ModuleSanitizerCoverage::InjectTraceForDiv(
}
}
-void ModuleSanitizerCoverage::InjectTraceForGep(
+void ModuleCoverageSanitizer::InjectTraceForGep(
Function &, ArrayRef<GetElementPtrInst *> GepTraceTargets) {
for (auto *GEP : GepTraceTargets) {
InstrumentationIRBuilder IRB(GEP);
@@ -877,7 +877,7 @@ void ModuleSanitizerCoverage::InjectTraceForGep(
}
}
-void ModuleSanitizerCoverage::InjectTraceForLoadsAndStores(
+void ModuleCoverageSanitizer::InjectTraceForLoadsAndStores(
Function &, ArrayRef<LoadInst *> Loads, ArrayRef<StoreInst *> Stores) {
auto CallbackIdx = [&](Type *ElementTy) -> int {
uint64_t TypeSize = DL->getTypeStoreSizeInBits(ElementTy);
@@ -906,7 +906,7 @@ void ModuleSanitizerCoverage::InjectTraceForLoadsAndStores(
}
}
-void ModuleSanitizerCoverage::InjectTraceForCmp(
+void ModuleCoverageSanitizer::InjectTraceForCmp(
Function &, ArrayRef<Instruction *> CmpTraceTargets) {
for (auto *I : CmpTraceTargets) {
if (ICmpInst *ICMP = dyn_cast<ICmpInst>(I)) {
@@ -941,7 +941,7 @@ void ModuleSanitizerCoverage::InjectTraceForCmp(
}
}
-void ModuleSanitizerCoverage::InjectCoverageAtBlock(Function &F, BasicBlock
&BB,
+void ModuleCoverageSanitizer::InjectCoverageAtBlock(Function &F, BasicBlock
&BB,
size_t Idx,
bool IsLeafFunc) {
BasicBlock::iterator IP = BB.getFirstInsertionPt();
@@ -1015,7 +1015,7 @@ void
ModuleSanitizerCoverage::InjectCoverageAtBlock(Function &F, BasicBlock &BB,
}
std::string
-ModuleSanitizerCoverage::getSectionName(const std::string &Section) const {
+ModuleCoverageSanitizer::getSectionName(const std::string &Section) const {
if (TargetTriple.isOSBinFormatCOFF()) {
if (Section == SanCovCountersSectionName)
return ".SCOV$CM";
@@ -1031,20 +1031,20 @@ ModuleSanitizerCoverage::getSectionName(const
std::string &Section) const {
}
std::string
-ModuleSanitizerCoverage::getSectionStart(const std::string &Section) const {
+ModuleCoverageSanitizer::getSectionStart(const std::string &Section) const {
if (TargetTriple.isOSBinFormatMachO())
return "\1section$start$__DATA$__" + Section;
return "__start___" + Section;
}
std::string
-ModuleSanitizerCoverage::getSectionEnd(const std::string &Section) const {
+ModuleCoverageSanitizer::getSectionEnd(const std::string &Section) const {
if (TargetTriple.isOSBinFormatMachO())
return "\1section$end$__DATA$__" + Section;
return "__stop___" + Section;
}
-void ModuleSanitizerCoverage::createFunctionControlFlow(Function &F) {
+void ModuleCoverageSanitizer::createFunctionControlFlow(Function &F) {
SmallVector<Constant *, 32> CFs;
IRBuilder<> IRB(&*F.getEntryBlock().getFirstInsertionPt());
diff --git a/llvm/test/Instrumentation/SanitizerCoverage/crit-edge-sancov.ll
b/llvm/test/Instrumentation/SanitizerCoverage/crit-edge-sancov.ll
index f42fa7139fd585..de4c4c15048fe0 100644
--- a/llvm/test/Instrumentation/SanitizerCoverage/crit-edge-sancov.ll
+++ b/llvm/test/Instrumentation/SanitizerCoverage/crit-edge-sancov.ll
@@ -2,8 +2,8 @@
; RUN: -sanitizer-coverage-level=3 %s -S -o - | FileCheck %s
; The edge between %entry and %for.inc.i is a critical edge.
-; SanitizerCoveragePass must split this critical edge in order to track
-; coverage of this edge. SanitizerCoveragePass will also insert calls to
+; CoverageSanitizerPass must split this critical edge in order to track
+; coverage of this edge. CoverageSanitizerPass will also insert calls to
; @__sanitizer_cov_trace_pc using the debug location from the predecessor's
; branch. but, if the branch itself is missing debug info (say, by accident
; due to a bug in an earlier transform), we would fail a verifier check that
diff --git a/llvm/test/Transforms/PGOProfile/Inputs/memprof.exe
b/llvm/test/Transforms/PGOProfile/Inputs/memprof.exe
index
710e49ce7ec895fcbb4c27fd465189faeb2b12a7..888ab6362fa2f6babfc1bb06edcc6980f73bb42f
100755
GIT binary patch
delta 329
zcmZo@OKJe37RD`1|9%NN=a;1xC8nnaC+20AWLBjXZRh{ZG%r9X87dxM442sN&HRT2
zQ$zci0A?U&0b*7lW&>h&Am#vKP9Ww2Vs0Sj0b<_mX9D=-8?YGO{`UeO5c31E01yiT
zvC#Iv7lZ|vu_)dye?_=ZOb*kD@j01E$tkG?@p-A`(+_SEHkd9D%gi-B=7F$IyU1(d
q?IN#5+<$Sx^-b@;DJq7|{GO+xs!UiU+7CY$1!A%7ho6hv&ISN0zl=Tr
delta 300
zcmZo@OKJe37RD`1|9%MuC+20AWLBjXIp>$97A2;qZs-5aG%sNK1AAs3HmJycZ{|NN
zm@3=P1TX_J3lOscF&hxG12G2>a{@6J5OV`D4-oTiKNG+w-+*jt``-(EK+F%s0zfPX
z#6sKuUJw>wMpm_5{)%v+7+6FI;+puJ%%tR$)PnfD)bi;EHwha|7l>u%njZ5&Sf^d&
zweWV4*COt}go<I_icg06Yx==AqT(Dd-u9lSqN+?-l(ipzE(*kA+Ydh%x19|DH`adO
diff --git a/llvm/test/Transforms/PGOProfile/Inputs/memprof.nocolinfo.exe
b/llvm/test/Transforms/PGOProfile/Inputs/memprof.nocolinfo.exe
index
c24a0fdbb0e958510775e00236f9b3c7890115a3..87527b1554f896ad78b8a9260178f2461c87bc98
100755
GIT binary patch
delta 318
zcmbQyk~E_wsiB2&3)8<}g3kG6sYQwDslkbPnI)N3sYToQe>2Ss5K4xM#}~sT_Ioq`
zVZqeUekOn!h*^M`6^Pk@m>q~YfS41Axqz4(h<SjRcl((DKKTYLhPVH{zz4+qKr8^n
zf<P>^{qF@~Jti!Qx7%J8E)>He(SG2i@b&{QMK=F3#B_grT4{1dab}`kazOzDru6nD
XPefI*+17shnJ5s8ZNL3Y+;%nqhgyo^
delta 273
zcmbQyk~E_wsiB2&3)8<}g29P-nI)N3sYTBDWvNAp>8acKe>2SsnEt??nTHK3vfrEe
z4-2Ns_A>#@K+FQftU$~L#Oy%K0mPg@%mu{UK+FTgyxY$N@X0qIo7(>O0v{0b1F--Q
z3j(pw_P-Z|^_Y-VZMVHFTquSt(thBj@b&{QMK=EuDu%f|J{jux=^Ji{igUnt+m}2M
WRb|4Wto`;gQ6LuEe*2lY?Q8&-$#&)d
diff --git
a/llvm/test/Transforms/PGOProfile/Inputs/memprof_internal_linkage.exe
b/llvm/test/Transforms/PGOProfile/Inputs/memprof_internal_linkage.exe
index
4d7c54b14ed42ffb180eb60bd798acb54a99643c..91a879ef265ba0d05380ad025bfbe8741871b5ed
100755
GIT binary patch
delta 367
zcmZ4SCvnA}#D*5eEllTr2|DMOr4}Worv@kHWtL=Cr50_!|BGo}fKW12JiZt%(eKUt
zhXqqZ`<wt~AZ7t#Rv=~rVs;?r0Afxc<^p1FAm#yL-tBV&_~L7^7~al%jt_|Wfmi^D
z1%X&-JMTH+&5UxGE{V^{OiE5kEr`!cEuYSKQP_I=gBWJ6>C;~dOH7Zy#HX@7{(|sf
zQ9>FG*9jZ67d#W*UhqtW`IjLUYtl-SGm0}4^^yw;7%-)`FL@xU%7o1?w;zeN-+m;v
K{q`eq-`N0&nwO^l
delta 322
zcmZ4SCvnA}#D*5eEllTr2?i(TWtL=Cr4~8om!%dZrl)Sd|BGo}!1N9F%sgyRk$!LH
zKP;Fk+vfx@12GE_vjQ<25VHd@2M}`tF&7YX12GQ}^KPFLz!zVOY-&62IX)of2Vwyr
z76f9U?Y!rNH#34&2|?_R&&f<mPDw3@&r2<z&UjJSdisMHX0GYeUkXc1kH5sHvOWHS
z@L^G$It<qd8?+ZZ6W(6%OoaKDP%+H2@ySr%PTz1vRGb6G+rH$1s45c{W$m{gi2||M
L_S=udeP;sz{3L?t
diff --git a/llvm/test/Transforms/PGOProfile/Inputs/memprof_loop_unroll.exe
b/llvm/test/Transforms/PGOProfile/Inputs/memprof_loop_unroll.exe
index
4de044a97a21cf5bbb887c434ab0615e0f5a9501..b94f1c41e67f25f482b55925e0f6d1233ce58a54
100755
GIT binary patch
delta 343
zcmX@nlyssgsiB2&3)8t@g3kG6sYQwDslkbPnI)N3sYToG|6-aKAe0Ohk1vKx^m{Y^
zVZqeUJ|}<~h*^M`6^Pk@m>q~YfS41Axqz4(h<SjRcl(?GzQc7`3~w(y&j-Z(Kr8^n
zf<P>^z3{wnDiapP)6cvRR-7L2jmcoT{u^P5>4z`#sZ6(dDy+SI!6jiSF)TXTfjYLI
xc_DKAmm#Ld;?qi#Gm0}4^^yw;7%-)`A9*aQip?4Azn_W%vDo(CPsM#_0|4all6U|B
delta 298
zcmX@nlyssgsiB2&3)8t@g29P-nI)N3sYTBDWvNAp>8acA|6-aKFnxnPGY=b7q~DwQ
z4-2Ns_BjE}K+FQftU$~L#Oy%K0mPg@%mu{UK+FTgyxZpl@Exv0HnqL*JRcDA1F--Q
z3j(pw_QLbRsZ7YKrk{BstT;X38<W9w{WroA(+^+fQ<-k_R9Jiaf=j|uV#rF{fl9ZZ
wc_DKAmryaxQ}M}AUroPoT~wR{#@l}6v8XB&7G>?fpNayp*!JH~#eHW30Qm5I+yDRo
diff --git a/llvm/test/Transforms/PGOProfile/Inputs/memprof_missing_leaf.exe
b/llvm/test/Transforms/PGOProfile/Inputs/memprof_missing_leaf.exe
index
39bc43023559e9cad546eb4a3afd44a1da121e0c..face22863b8f66d7329889bec8bf774bc54c1395
100755
GIT binary patch
delta 312
zcmcccJMqHr#D*5eEllTr2|DMOr4}Worv@kHWtL=Cr50_!|BGo}fKW12JiZt%(eKUt
zhXqqZ`<wt~AZ7t#Rv=~rVs;?r0Afxc<^p1FAm#yL-tBV&_^fNO7~cN!EFTc_1F--Q
z3j(pw_Lpac|1e@vJpJNRVa4eI-<S-xdt4AM7saBa9jIjc#it@wzc}GOnO=WIR1AyS
a?KKZXRhh6zv~PYS3dCaDH$M`WoecoyQHSXO
delta 283
zcmcccJMqHr#D*5eEllTr2?i(TWtL=Cr4~8om!%dZrl)Sd|BGo}!1N9F%sgyRk$!LH
zKP;Fk+vfx@12GE_vjQ<25VHd@2M}`tF&7YX12GQ}^KPFLz-L{HY-;<<vwT3z55xjM
zEC|Fx+h3j){=<l@YWl^e!iv)azA+hW_qZTjE{ZJI4wTz|@u^7FFQH<XFXEG--k84e
gxu`e?jJLh!fv74I7G>?5ABh67*!Inj#ARm#095>W%K!iX
diff --git a/llvm/test/tools/llvm-profdata/Inputs/basic-histogram.memprofexe
b/llvm/test/tools/llvm-profdata/Inputs/basic-histogram.memprofexe
index
f69c0b12a89eb738941dfb2417213658f9965ef8..7b579c843d9b46f28cd8c62adad6511661e3882e
100755
GIT binary patch
delta 332
zcmeydI_byiq=pv8ElhsD1)cNDQi~GPQ-c%pGD|Y6Qj507|7MyOAe0Ohk1vKx@cS_T
zVZqeUE)&QM#4JF}3dC$c%nrmHK+FlmTtLhX#5_REyIm%bFQONV;q7hr_<)!nhy{RH
z5Qv4gx7`!|$Bsqu^yPnq6{lbLD{MHGTSR>O|7XI}M6oDq2P)gX{ErCVZ$nJq#HW=e
mXB1~9>LnKxFknh=fA(Eel?j`nvcE*zWq*lnm;EJvdo}<^u!eB}
delta 287
zcmeydI_byiq=pv8ElhsD1%ngwGD|Y6Qj47P%TkLH(^I#{|7MyOFx|j`nTHK3!tcZU
zhXqq*yG$T65VHU=D-g2*F*^`*05K;Ja{)0o5c2>r?{=9$zKC9AQ`_6_@c}VE5DNgY
zAP@^}Z@VY_j~!Xn^yPnq6{lbLD{MHGTSR>O|7XI}M3Lp&f%4mz{}JK)EmREiNqjQY
jE7Kpm7ZvA#@wPwvE~?6eMOnM-FHs;C+b;V{{Pt`B?x=79
diff --git a/llvm/test/tools/llvm-profdata/Inputs/basic.memprofexe
b/llvm/test/tools/llvm-profdata/Inputs/basic.memprofexe
index
14cbfeb88eaf8f09aabbfafc57cf8b8d3f4852b5..8054bf3f29e91b64eaf5f08297864faa6d1fb48e
100755
GIT binary patch
delta 333
zcmZ4RD{;ZE#D*5eEllTr2|DMOr4}Worv@kHWtL=Cr50_!|BGo}fKW12JiZt%(eKUt
zhXqqZ`<wt~AZ7t#Rv=~rVs;?r0Afxc<^p1FAm#yL-tBV&_-@r;F}%IwEFTc_1F--Q
z3j(pw_Kvf{5=>YWPw#mutT;X38<WBG_b-Gcwo6|Sju*wEt{tdud(Tr5^<RdV-ic2u
lP0lFJOw>y*C}6;p-u~pis46zg+od0g0<qY3=||$MvjOH0i$VYZ
delta 288
zcmZ4RD{;ZE#D*5eEllTr2?i(TWtL=Cr4~8om!%dZrl)Sd|BGo}!1N9F%sgyRk$!LH
zKP;Fk+vfx@12GE_vjQ<25VHd@2M}`tF&7YX12GQ}^KPFLz;~+#+0^!qvwT3z55xjM
zEC|Fx+dIw*OE4j;n%?tNSaEv5HztGW?_UT@Y?r<u950HjpdF}Sd(Tr5^<P58Ft5ZX
lL;W)S!(~x%4j6Cyll!8oOjwk)OFt3?VzKSgkHlGL0|2^;cESJv
diff --git a/llvm/test/tools/llvm-profdata/Inputs/basic_v3.memprofexe
b/llvm/test/tools/llvm-profdata/Inputs/basic_v3.memprofexe
index
d03894b6d8e40c8ca8e1f94d5e328f936a052fde..25dcf25c47d6db29d4b3ebcb8c1d0df9f94842fe
100755
GIT binary patch
delta 315
zcmbO*CuG8$kcKUc^DYWH=a;1xC8nnaC+20AWLBjXZC`(pv6~l*xc7a=b*@6mQ1$V}
zFb(b8s!Tx448$xz%nHP8K+F!r96-zo#9Tnky`5W?=XfhN1D>qnX@9bc7l`?Qn1B0|
zRRZo4u_&AtDX2KTfrm+9d!3D7feaQEZIOc8B8BeHF~oFcd|GL8Msa4MUUESJ1E%zL
Zfp0>pOjwL;cmE*-#KPO%e~6qE1prNFc>DkW
delta 270
zcmbO*CuG8$kcKUc^DYVoC+20AWLBjXIp>$97A2;qZeM?qv6~l*xc7a=b*|GFXfg4y
zK~%PLt1<yGGZ3=?F)I+W0Wmuea{w_X5OV=B_jYbop5v`3I-jiKX@9bc7l`?Qn1B0|
zRRZo4kyT8K6jYqvz{8}lz0O9kKn7W=EmCk>q|p62Ld7tr$0tMGK7GSGA#n~EZ@a)Z
WAyp<U%G%w32m!J1cK075Cq)6mqhq`P
diff --git a/llvm/test/tools/llvm-profdata/Inputs/buildid.memprofexe
b/llvm/test/tools/llvm-profdata/Inputs/buildid.memprofexe
index
1b4db88d8186dd020090058e04bf1621a086fa2e..9d5080e4146fe760751ee89c7ed22b04361fb52a
100755
GIT binary patch
delta 317
zcmZ4SD{;lI#D*5eEllTr2|DMOr4}Worv@kHWtL=Cr50_!|BGo}fKW12JiZt%(eKUt
zhXqqZ`<wt~AZ7t#Rv=~rVs;?r0Afxc<^p1FAm#yL-tBV&`0mtTF}%I&EFTc_1F--Q
z3j(pw_O7$SZyB*D-rjj$_`4_;iRnNI#pxf;F{w`Xxh<^I&hkunJIgbX?LRr;-kJXX
fvZxpqt=r$+7gc4#BGIn=NEC?0wktmpXPpfIDi4Nq
delta 288
zcmZ4SD{;lI#D*5eEllTr2?i(TWtL=Cr4~8om!%dZrl)Sd|BGo}!1N9F%sgyRk$!LH
zKP;Fk+vfx@12GE_vjQ<25VHd@2M}`tF&7YX12GQ}^KPFLz;~wx+0^!~vwT3z55xjM
zEC|Fx+q=#Rzhy*LwY~Ga@OM#Uk?BAY#pxf;F{w`Xxh<^I&hkunJIgbX?LUQzVP1((
lhWcf?;&V}P4j6CyoBN`wOjwk)D?btiVzKSYkHlGL0{||2cUJ%a
diff --git a/llvm/test/tools/llvm-profdata/Inputs/inline.memprofexe
b/llvm/test/tools/llvm-profdata/Inputs/inline.memprofexe
index
2822f2fa204345ec2c496d8bca9d231b947c9831..9c2823016a34525ee34dafc714007f4cb75eb92a
100755
GIT binary patch
delta 333
zcmaFyFY(2{#D*5eEllTr2|DMOr4}Worv@kHWtL=Cr50_!|BGo}fKW12JiZt%(eKUt
zhXqqZ`<wt~AZ7t#Rv=~rVs;?r0Afxc<^p1FAm#yL-tBV&_~PoY7~alvo)3umfmi^D
z1%X&-JI{GxUnVSyw`X4zJ|T)lVmeSlar%dIOsdoW-x1bn-~L>9`}XG|I=>7ty%V2S
lnw(LbnW&dsP{4pGy<Oyys46zg+r6KN0<qY3?<eB2vjOj8iUR-u
delta 288
zcmaFyFY(2{#D*5eEllTr2?i(TWtL=Cr4~8om!%dZrl)Sd|BGo}!1N9F%sgyRk$!LH
zKP;Fk+vfx@12GE_vjQ<25VHd@2M}`tF&7YX12GQ}^KPFLz!z7CY-&5tc|IWK2Vwyr
z76f9U?L6m&eVLF|ZO^_ad_ojiWI9kpar%dIOsdoW-x1bn-~L>9`}XG|I=_U9VP1((
khWcf?!ZlHG4j6B{$RklzCM?R@y`P8zvDkL+C*rcR0m5>0wg3PC
diff --git a/llvm/test/tools/llvm-profdata/Inputs/multi.memprofexe
b/llvm/test/tools/llvm-profdata/Inputs/multi.memprofexe
index
22c6136f3dda805f9ce3bf60ca5d5901cac0b8d5..64c931a598cc4f278fcd43f459b989c9e404bb18
100755
GIT binary patch
delta 332
zcmdn+D{;fG#D*5eEllTr2|DMOr4}Worv@kHWtL=Cr50_!|BGo}fKW12JiZt%(eKUt
zhXqqZ`<wt~AZ7t#Rv=~rVs;?r0Afxc<^p1FAm#yL-tBV&_+HguF}!`oSw0}<2Vwyr
z76f9U?K92_OEO_mJbms{Va4eI-<S-hy%d(%u5&>+UKES6cA&EDbDxT+{W8S#O?+Bu
laz=4xqF!=A0RyJ=_AmEERk7LKuKh?9h{d*RKN4r14FIt-i)R1;
delta 286
zcmdn+D{;fG#D*5eEllTr2?i(TWtL=Cr4~8om!%dZrl)Sd|BGo}!1N9F%sgyRk$!LH
zKP;Fk+vfx@12GE_vjQ<25VHd@2M}`tF&7YX12GQ}^KPFL!1t;K+0^zKXZe7bABY8j
zSP+PXw$C^#EXjndYWm!#!iv)azA+h0dnqijUFU*uyeP7KJ5YZ6+@~UHzl4fmK8a6;
jdS%)bQE?6!XZx4?qN+?-RJChA5(Q$h?b?sTS!V+P`!99(
diff --git a/llvm/test/tools/llvm-profdata/Inputs/padding-histogram.memprofexe
b/llvm/test/tools/llvm-profdata/Inputs/padding-histogram.memprofexe
index
34db7e784208ccb9315aeacf985db18ef3b7c481..44f1d7c8a842f79e76385ce8436a06930e44115f
100755
GIT binary patch
delta 328
zcmdncp0uGosiB2&3zOe(LFfFk)S|@n)ZoOt%#zHi)S~V2znSI*2qi<s<BQ=E{65To
zSTHrT%LFn5F$)m00x=s9vjZ^)5OV@C7Z7s;F%J;)ZkGw<^K8IkczgLpJ|N}?VgVo)
z1Y)7><rjrrnXxF|e(s9!2~jK((}5C-(+kcsskXm+CA|IJE0O8H3^9EYpH`ZjQJk5m
hmt0W5fGNFw+fz|hCM?FczkMzW#A4guJ{Lbc8vvXSg<k*w
delta 283
zcmdncp0uGosiB2&3zOe(!QjNa%#zHi)FS8nvecr)^wjO~znSI*OgC^~=3#@1@cS_T
zVZl_{E)&QM#4JF}3dC$c%nrmHK+FlmTtLhX#5_REyIm%b&$9v9)b{d=d_c?(!~#Gp
z2*g6$%P$JMG9#<ne(s9!2~lK`=|B<1=>_MRRNLRZ65jsqmB{p8Ld7sw_&F@3{b
fQE?6!Z~L~VqN+?-l(oNoE(*kA+uuGHKRg=%#;<Oz
diff --git a/llvm/test/tools/llvm-profdata/Inputs/pic.memprofexe
b/llvm/test/tools/llvm-profdata/Inputs/pic.memprofexe
index
f7d172314de6d50519e3133d2135b97b00885724..6bf1e46076b12384b5286adb5a5a3123b81383ac
100755
GIT binary patch
delta 319
zcmdlmF=@lZq=pv87N#xCc5H&q`DLj^iRr1qiFuhNnN_Jp+x^*?=LHBQL&f8Z;S&GD
znE$X~YG~()VFqFrAZ7((HXvpPVh$kY1Y#~A<_2OOAm-i96T`<*i^cGEwVQlE%n!r@
zKr9HvLfh4D3NK;AqImnATf!D%SR|$cB^0M8++tFl{@|IgPWz0H!rNzj6xsZf6Yibq
g_4h@wY29A)T2z$@i<#}4---gU*!InD#sAI%0RPQ>rT_o{
delta 290
zcmdlmF=@lZq=pv87N#xCc5H&diFuhNnN_Jp&iQ4jMTzOD+x^*?=LJkx@Mh*=gNpnQ
zWB$W}sj{6Xh8c)ifS47C*?^cGh&h0m6NtHhm>Y<BfS7kXPYfSNEwZWYYB%|Sm>-A*
zfLIWSg|@5R6kfuJtZMt6Tf!D%$Rg8$B8t-!ZZWA&fACCLr+vmp;q5a%ifsNVR1EV<
md@|H8(>Hz+73YBQw%5ECRb|4WtbOxaQ6LuEzWJ^A-&p_vA#Hd7
diff --git a/llvm/test/tools/llvm-xray/X86/Inputs/elf64-badentrysizes.bin
b/llvm/test/tools/llvm-xray/X86/Inputs/elf64-badentrysizes.bin
index
702ea1484df1dc64f75660db4b87e265c6f2cdf2..580118079d69c6e001c7ca2fdc9d2566a3cc48aa
100755
GIT binary patch
delta 297
zcmZ2*Rc66enT8g|Elhs|g_85jQi~GPQ{#&h^D;{^t5S=$^9eB>Vik0TN(95jABr>a
zGh)%u&LqhM#LU~7Bw5S@u_&0Hn93qK-C;G0*z^aJS;V$a$YMF9A%$skd~RYvL1tb$
zNWIte|IR@5=k!^)rt5A6vK+ivxVC?r%o0|H#fI&1T&(+9ut>D)^RsT(=V$A+#3H%<
RoCli^HXm)*@nS1^003J2ZtwsA
delta 245
zcmZ2*Rc66enT8g|Elhs|r(bx;!oyaUT9lZcx}8sm=@6@6aAIC&NoG}Qk#jy&{Gm7#
zKO?frb|y(CAZFgqB*|hPI9=csGZ#lPRQ2@4R2IqU4y#$jrazd>BDQ@(7Rw<Guo3~7
zlK9-jf`ZJvbdXZ7>HnR9O3&%Da81|U3S>EWv2bnwHkl=?4B5u*aa^qXS&&8A_4!%1
Z>+`eqS|W>XKj*>bgW}fhI$mrg4*=5_Su_9u
diff --git a/llvm/test/tools/llvm-xray/X86/Inputs/elf64-example.bin
b/llvm/test/tools/llvm-xray/X86/Inputs/elf64-example.bin
index
a6e6d3d64681f34a72bf59ad0eef70be46b01f20..69c34751aed05599b8e480b9da198dbae687b8df
100755
GIT binary patch
delta 297
zcmZ2*Rc66enT8g|Elhs|g_85jQi~GPQ{#&h^D;{^t5S=$^9eB>Vik0TN(95jABr>a
zGh)%u&LqhM#LU~7Bw5S@u_&0Hn93qK-C;G0*z^aJS;V$a$YMF9A%$skd~RYvL1tb$
zNWIte|IR@5=k!^)rt5A6vK+ivxVC?r%o0|H#fI&1T&(+9ut>D)^RsT(=V$A+#3H%<
RoCli^HXm)*@nS1^003J2ZtwsA
delta 245
zcmZ2*Rc66enT8g|Elhs|r(bx;!oyaUT9lZcx}8sm=@6@6aAIC&NoG}Qk#jy&{Gm7#
zKO?frb|y(CAZFgqB*|hPI9=csGZ#lPRQ2@4R2IqU4y#$jrazd>BDQ@(7Rw<Guo3~7
zlK9-jf`ZJvbdXZ7>HnR9O3&%Da81|U3S>EWv2bnwHkl=?4B5u*aa^qXS&&8A_4!%1
Z>+`eqS|W>XKj*>bgW}fhI$mrg4*=5_Su_9u
diff --git a/llvm/test/tools/llvm-xray/X86/Inputs/elf64-sample-o2.bin
b/llvm/test/tools/llvm-xray/X86/Inputs/elf64-sample-o2.bin
index
fe31f9514d37e66e313bd837ff1e30df0c258cd8..f5ccba5b8a3772c6f91e736b9caa6694f8424323
100755
GIT binary patch
delta 269
zcmZ2JQ+D}G*@hOzElfJXLdp4MsYQwDsqw{$d6^}dRjEbW?Sz>Qu?jjvC4%ANf|5-9
zj94_Z8%Z$%G4pmKDVCrtEDENtsb`U#ejtlQY<hhPivoyX+y1(RWs?RL#oO1fWqDA6
oO=6)M>wXq2675CWtlNvU*_7<DNN!)2#pZ*})!SKe*cLwk0DUE8&;S4c
delta 229
zcmZ2JQ+D}G*@hOzElfJX(;c{3xj2&Z%TkLH(^I$G2{RpH6%0<y%Ph&PN-c7Ri3>_H
z@iU^TZ8wr)0%GRvMp7(6S<@3FSP<q+UsKN_IsHHui`ew~6cz;#!M6Q%3(F=ARCU|e
uuVr~qfoksdg=(z(Sy08=i?ms{7iqI8*`tbYUzWw@gXXU7EIDk89{>QSXiJ~~
diff --git a/llvm/test/tools/sancov/Inputs/test-linux_x86_64
b/llvm/test/tools/sancov/Inputs/test-linux_x86_64
index
9ffac6f81b9d935988b2462b1edc86a94b5cbfc0..870eba74b819c0c597a13cc33c4427453e3241ba
100755
GIT binary patch
delta 372
zcmdmUbt>Z?AZ}=3Y+-6)ZeeL*ZDDI+Z{cX+Y~gC*ZsBR+ZQ<L(pQ0+1oL`n&l$f3x
zU!0hiS&~_mTC}}PmHz-Mhci@S`oUm6(e1(7{LGA46t`#S@B^^`5DNma5D*Iku?P^0
z0<jnnivzI)5K98F6c9@Tu?!H)ZqLw>W0%8X==Mf0IRkYmOsB=?CKeQA=A};uDv+FR
zUnIxV{-IEA`-ejLNlMtvnKDH_nFWhPJLgP!AXWfk#qFFkmBKG!QMA1%Te*)BpDXU>
RE6cZA<|=Qu%vEXr3jnf)h=KqB
delta 332
zcmdmUbt>Z?AZ}=3Y+-6)ZeeL*ZDDI+Z{cX+Y~gC*ZsBR+ZQ<L(pQ1WFL6o11BRRh;
zwJ0$?b$gjA{{dFc;KaPllFX{qqUp1B_|>PUY4d+TRo9-O!w<v)Kr9HvLO?7G#3Dc}
z3dCYSEDppHKr9KwQa~&X#4<oEyFEikj$LlL!$nyndmFvv4AjA50x-A4=Oz{uWagz$
z2g*rKw=a_8Y5!0txBWw*{3In**KD6MMLwAYRji$JraTZU0I}kB&Y4Q#mr&)m7iBB=
YF@nV~ZM>VWEZ=UKtGwMZSEczc0CiPzApigX
diff --git a/llvm/test/tools/sancov/Inputs/test-windows_x86_64
b/llvm/test/tools/sancov/Inputs/test-windows_x86_64
index
3eaab93b4cfd7f52ed76c2a4f3585884be9031d8..5e04a3e7f5cdac0473a73a07f29d9d7fe523e659
100644
GIT binary patch
delta 103
zcmZoTpxppOEsQNpEzB(}EvzkUE$mx3e#;6a=a;1xC8npw7boUrmSk3?7H#L1<Cx0I
i;S80Su0MxEbo+i~j&M0FirY1uIDnXQyM`0jjky4cW+d+b
delta 94
zcmZoTpxppOEsQNpEzB(}EvzkUE$mx3e#=gm+seVkk(^(aT9lZcx}8^!V=60WaAIC&
jNoG}Q(R3Rp4)yJqlsR1FP!+aoIB@_m=XMPzt{Za!`8Xf8
diff --git a/llvm/tools/sancov/sancov.cpp b/llvm/tools/sancov/sancov.cpp
index dd51226e21311f..72e0ca0d46c8bd 100644
--- a/llvm/tools/sancov/sancov.cpp
+++ b/llvm/tools/sancov/sancov.cpp
@@ -766,7 +766,7 @@ static void getObjectCoveragePoints(const
object::ObjectFile &O,
continue;
}
uint64_t Addr = Index + SectionAddr;
- // Sanitizer coverage uses the address of the next instruction - 1.
+ // Coverage sanitizer uses the address of the next instruction - 1.
uint64_t CovPoint = getPreviousInstructionPc(Addr + Size, TheTriple);
uint64_t Target;
if (MIA->isCall(Inst) &&
@@ -1147,7 +1147,7 @@ static void parseArgs(int Argc, char **Argv) {
llvm::outs(),
"sancov [options] <action> <binary files...> <.sancov files...> "
"<.symcov files...>",
- "Sanitizer Coverage Processing Tool (sancov)\n\n"
+ "Coverage Sanitizer Processing Tool (sancov)\n\n"
" This tool can extract various coverage-related information from: \n"
" coverage-instrumented binary files, raw .sancov files and their "
"symbolized .symcov version.\n"
diff --git a/llvm/utils/gn/secondary/compiler-rt/lib/sanitizer_common/BUILD.gn
b/llvm/utils/gn/secondary/compiler-rt/lib/sanitizer_common/BUILD.gn
index f7f1fce10bf5f5..3908483ed9e4e3 100644
--- a/llvm/utils/gn/secondary/compiler-rt/lib/sanitizer_common/BUILD.gn
+++ b/llvm/utils/gn/secondary/compiler-rt/lib/sanitizer_common/BUILD.gn
@@ -41,9 +41,9 @@ source_set("sources") {
"sanitizer_common.cpp",
"sanitizer_common.h",
"sanitizer_common_libcdep.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",
"sanitizer_dbghelp.h",
"sanitizer_deadlock_detector.h",
"sanitizer_deadlock_detector1.cpp",
@@ -177,7 +177,7 @@ source_set("weak_interception") {
configs -= [ "//llvm/utils/gn/build:llvm_code" ]
configs += [ "//llvm/utils/gn/build:crt_code" ]
sources = [
- "sanitizer_coverage_win_weak_interception.cpp",
+ "coverage_sanitizer_win_weak_interception.cpp",
"sanitizer_win_weak_interception.cpp",
]
defines = [ "SANITIZER_DYNAMIC" ]
@@ -187,8 +187,8 @@ source_set("dll_thunk") {
configs -= [ "//llvm/utils/gn/build:llvm_code" ]
configs += [ "//llvm/utils/gn/build:crt_code" ]
sources = [
- "sanitizer_coverage_win_dll_thunk.cpp",
- "sanitizer_coverage_win_sections.cpp",
+ "coverage_sanitizer_win_dll_thunk.cpp",
+ "coverage_sanitizer_win_sections.cpp",
"sanitizer_win_dll_thunk.cpp",
]
defines = [ "SANITIZER_DLL_THUNK" ]
@@ -198,8 +198,8 @@ source_set("dynamic_runtime_thunk") {
configs -= [ "//llvm/utils/gn/build:llvm_code" ]
configs += [ "//llvm/utils/gn/build:crt_code" ]
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",
"sanitizer_win_dynamic_runtime_thunk.cpp",
]
defines = [ "SANITIZER_DYNAMIC_RUNTIME_THUNK" ]
diff --git
a/llvm/utils/gn/secondary/llvm/lib/Transforms/Instrumentation/BUILD.gn
b/llvm/utils/gn/secondary/llvm/lib/Transforms/Instrumentation/BUILD.gn
index aeaeb576513576..0cd397f871fa8c 100644
--- a/llvm/utils/gn/secondary/llvm/lib/Transforms/Instrumentation/BUILD.gn
+++ b/llvm/utils/gn/secondary/llvm/lib/Transforms/Instrumentation/BUILD.gn
@@ -34,7 +34,7 @@ static_library("Instrumentation") {
"PoisonChecking.cpp",
"RealtimeSanitizer.cpp",
"SanitizerBinaryMetadata.cpp",
- "SanitizerCoverage.cpp",
+ "CoverageSanitizer.cpp",
"ThreadSanitizer.cpp",
"ValueProfileCollector.cpp",
]
>From f430da54abb6309756179585ad7cb7064596b86f Mon Sep 17 00:00:00 2001
From: Corentin Jabot <corentinja...@gmail.com>
Date: Mon, 2 Sep 2024 13:35:39 +0200
Subject: [PATCH 2/2] Address Louis comment
---
libcxx/docs/VendorDocumentation.rst | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/libcxx/docs/VendorDocumentation.rst
b/libcxx/docs/VendorDocumentation.rst
index 9d12e17eeda443..3a3d1cdb1ea7ff 100644
--- a/libcxx/docs/VendorDocumentation.rst
+++ b/libcxx/docs/VendorDocumentation.rst
@@ -257,7 +257,7 @@ General purpose options
A semicolon list of arguments to pass when running the libc++ benchmarks
using the
``check-cxx-benchmarks`` rule. By default we run the benchmarks for a very
short amount of time,
- since the primary use of ``check-cxx-benchmarks`` is to get test and
coverage sanitizer, not to
+ since the primary use of ``check-cxx-benchmarks`` is to get test and
sanitizer coverage, not to
get accurate measurements.
.. option:: LIBCXX_ASSERTION_HANDLER_FILE:PATH
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
