[coverage] add option to exclude special conditions from MC/DC report

Lambdaris · Lambdaris · commit 021b3d487c8a · 2025-02-12T21:41:35.000+08:00
diff --git a/llvm/docs/CommandGuide/llvm-cov.rst b/llvm/docs/CommandGuide/llvm-cov.rst
@@ -227,6 +227,12 @@ OPTIONS
  Show modified condition/decision coverage (MC/DC) for each applicable boolean
  expression.
 
+.. option:: -mcdc-exclude
+
+ Set which special states of conditions should be excluded from coverage (MC/DC). Possible
+ values are: "none", "uncoverable", "constant", "unreachable", separated by comma. Default
+ to "constant".
+
 .. option:: -show-line-counts
 
  Show the execution counts for each line. Defaults to true, unless another
@@ -435,6 +441,12 @@ OPTIONS
 
  Show MC/DC statistics. Defaults to false.
 
+.. option:: -mcdc-exclude-uncoverable
+
+ MC/DC does not count uncoverable conditions. Default to false.
+ Uncoverable conditions are conditions that may be evaluated but can not affect
+ the outcome of decisions due to constants.
+
 .. option:: -show-functions
 
  Show coverage summaries for each function. Defaults to false.
diff --git a/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h b/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h
@@ -397,10 +397,10 @@ struct MCDCRecord {
   enum CondState { MCDC_DontCare = -1, MCDC_False = 0, MCDC_True = 1 };
 
   enum CondResult {
-    MCDC_Normal,
-    MCDC_Constant,
-    MCDC_Uncoverable,
-    MCDC_Unreachable
+    MCDC_Normal = 0x1,
+    MCDC_Constant = 0x2,
+    MCDC_Uncoverable = 0x4,
+    MCDC_Unreachable = 0x8
   };
 
   /// Emulate SmallVector<CondState> with a pair of BitVector.
@@ -540,11 +540,12 @@ struct MCDCRecord {
 
   /// Return if the decision is coverable and percent of covered conditions.
   /// Only coverable conditions are counted as denominator.
-  std::pair<bool, float> getPercentCovered() const {
+  std::pair<bool, float> getPercentCovered(int32_t CountedStates) const {
     unsigned Excluded = 0;
     unsigned Covered = 0;
+    auto ExcludedStates = ~CountedStates;
     for (unsigned C = 0; C < getNumConditions(); C++) {
-      if (isCondConstant(C))
+      if (getCondResult(C) & ExcludedStates)
         Excluded++;
       else if (isConditionIndependencePairCovered(C))
         Covered++;
diff --git a/llvm/test/tools/llvm-cov/Inputs/mcdc-exclude.cpp b/llvm/test/tools/llvm-cov/Inputs/mcdc-exclude.cpp
@@ -0,0 +1,25 @@
+#include <stdio.h>
+
+
+
+
+
+
+
+
+void test(bool a,bool b, bool c, bool d) {
+
+  if (a && (b || true || c) && ( true || d)  && true)
+    printf("test 1 decision true\n");
+
+}
+
+int main()
+{
+    test(true,false,true,false);
+    test(true,false,true,true);
+    test(true,true,false,false);
+    test(false,true,true,false);
+    test(true,false,false,false);
+    return 0;
+}
diff --git a/llvm/test/tools/llvm-cov/Inputs/mcdc-exclude.o b/llvm/test/tools/llvm-cov/Inputs/mcdc-exclude.o
diff --git a/llvm/test/tools/llvm-cov/Inputs/mcdc-exclude.proftext b/llvm/test/tools/llvm-cov/Inputs/mcdc-exclude.proftext
@@ -0,0 +1,34 @@
+_Z4testbbbb
+# Func Hash:
+2877299778974865
+# Num Counters:
+12
+# Counter Values:
+5
+4
+4
+4
+4
+4
+0
+0
+3
+0
+0
+0
+# Num Bitmap Bytes:
+$3
+# Bitmap Byte Values:
+0xc0
+0x80
+0x0
+
+
+main
+# Func Hash:
+24
+# Num Counters:
+1
+# Counter Values:
+1
+
diff --git a/llvm/test/tools/llvm-cov/mcdc-exclude.test b/llvm/test/tools/llvm-cov/mcdc-exclude.test
@@ -0,0 +1,56 @@
+// Test visualization of MC/DC constructs for constant-folded condition masking with different counted states.
+
+// RUN: llvm-profdata merge %S/Inputs/mcdc-exclude.proftext -o %t.profdata
+// RUN: llvm-cov show --show-mcdc %S/Inputs/mcdc-exclude.o -instr-profile %t.profdata -path-equivalence=.,%S/Inputs | FileCheck %s -check-prefix=DEFAULTCASE
+// RUN: llvm-cov report --show-mcdc-summary %S/Inputs/mcdc-exclude.o -instr-profile %t.profdata -show-functions -path-equivalence=.,%S/Inputs %S/Inputs/mcdc-exclude.cpp | FileCheck %s -check-prefix=REPORTDEFAULT
+
+// DEFAULTCASE:  |  MC/DC Coverage for Decision: 25.00%
+
+// REPORTDEFAULT: TOTAL {{.*}} 4       3  25.00%
+
+// RUN: llvm-cov show --show-mcdc --mcdc-exclude=uncoverable %S/Inputs/mcdc-exclude.o -instr-profile %t.profdata -path-equivalence=.,%S/Inputs | FileCheck %s -check-prefix=EXCLUDEUNCOVERABECASE
+// RUN: llvm-cov report --show-mcdc-summary --mcdc-exclude=uncoverable %S/Inputs/mcdc-exclude.o -instr-profile %t.profdata -show-functions -path-equivalence=.,%S/Inputs %S/Inputs/mcdc-exclude.cpp | FileCheck %s -check-prefix=REPORTEXCLUDEUNCOVERABLE
+
+// EXCLUDEUNCOVERABECASE:  |  MC/DC Coverage for Decision: 16.67%
+
+// REPORTEXCLUDEUNCOVERABLE: TOTAL {{.*}} 6       5  16.67%
+
+// RUN: llvm-cov show --show-mcdc --mcdc-exclude=constant %S/Inputs/mcdc-exclude.o -instr-profile %t.profdata -path-equivalence=.,%S/Inputs | FileCheck %s -check-prefix=EXCLUDECONSTANTCASE
+// RUN: llvm-cov report --show-mcdc-summary --mcdc-exclude=constant %S/Inputs/mcdc-exclude.o -instr-profile %t.profdata -show-functions -path-equivalence=.,%S/Inputs %S/Inputs/mcdc-exclude.cpp | FileCheck %s -check-prefix=REPORTEXCLUDECONSTANT
+
+// EXCLUDECONSTANTCASE:  |  MC/DC Coverage for Decision: 25.00%
+
+// REPORTEXCLUDECONSTANT: TOTAL {{.*}} 4       3  25.00%
+
+// RUN: llvm-cov show --show-mcdc --mcdc-exclude=unreachable %S/Inputs/mcdc-exclude.o -instr-profile %t.profdata -path-equivalence=.,%S/Inputs | FileCheck %s -check-prefix=EXCLUDEUNREACHABLECASE
+// RUN: llvm-cov report --show-mcdc-summary --mcdc-exclude=unreachable %S/Inputs/mcdc-exclude.o -instr-profile %t.profdata -show-functions -path-equivalence=.,%S/Inputs %S/Inputs/mcdc-exclude.cpp | FileCheck %s -check-prefix=REPORTEXCLUDEUNREACHABLE
+
+// EXCLUDEUNREACHABLECASE:  |  MC/DC Coverage for Decision: 20.00%
+
+// REPORTEXCLUDEUNREACHABLE: TOTAL {{.*}} 5       4  20.00%
+
+// RUN: llvm-cov show --show-mcdc --mcdc-exclude=none %S/Inputs/mcdc-exclude.o -instr-profile %t.profdata -path-equivalence=.,%S/Inputs | FileCheck %s -check-prefix=INCLUDEALLCASE
+// RUN: llvm-cov report --show-mcdc-summary --mcdc-exclude=none %S/Inputs/mcdc-exclude.o -instr-profile %t.profdata -show-functions -path-equivalence=.,%S/Inputs %S/Inputs/mcdc-exclude.cpp | FileCheck %s -check-prefix=REPORTALL
+
+// INCLUDEALLCASE:  |  MC/DC Coverage for Decision: 14.29%
+
+// REPORTALL: TOTAL {{.*}} 7       6  14.29%
+Instructions for regenerating the test:
+
+cd %S/Inputs # Or copy files into the working directory
+
+clang++ -c -Os \
+    -fcoverage-compilation-dir=. -mllvm -enable-name-compression=false \
+    -fcoverage-mcdc -fprofile-instr-generate -fcoverage-mapping \
+    mcdc-exclude.cpp
+
+# Instructions for regenerating proftext
+
+for x in mcdc-exclude; do (
+  clang++ -fprofile-instr-generate $x.o -o $x
+  find -name '*.profraw' | xargs rm -f
+  export LLVM_PROFILE_FILE=$x-%p.profraw
+  ./$x 0 1
+  llvm-profdata merge --sparse -o $x.profdata $(find -name '*.profraw')
+  llvm-profdata merge --text -o $x.proftext $x.profdata
+); done
diff --git a/llvm/tools/llvm-cov/CodeCoverage.cpp b/llvm/tools/llvm-cov/CodeCoverage.cpp
@@ -773,6 +773,12 @@ int CodeCoverageTool::run(Command Cmd, int argc, const char **argv) {
                             cl::desc("Show MCDC statistics in summary table"),
                             cl::init(false));
 
+  cl::list<std::string> MCDCExcludeStates(
+      "mcdc-exclude", cl::Optional,
+      cl::desc(
+          "Set which abnormal kinds of conditions are excluded from MC/DC"),
+      cl::CommaSeparated, cl::list_init<std::string>({"constant"}));
+
   cl::opt<bool> InstantiationSummary(
       "show-instantiation-summary", cl::Optional,
       cl::desc("Show instantiation statistics in summary table"));
@@ -944,6 +950,24 @@ int CodeCoverageTool::run(Command Cmd, int argc, const char **argv) {
       ::exit(0);
     }
 
+    ViewOpts.MCDCCountedStates =
+        MCDCRecord::MCDC_Normal | MCDCRecord::MCDC_Uncoverable |
+        MCDCRecord::MCDC_Constant | MCDCRecord::MCDC_Unreachable;
+    for (const auto &State : MCDCExcludeStates) {
+      if (State == "uncoverable") {
+        ViewOpts.MCDCCountedStates &= ~MCDCRecord::MCDC_Uncoverable;
+      } else if (State == "constant") {
+        ViewOpts.MCDCCountedStates &= ~MCDCRecord::MCDC_Constant;
+      } else if (State == "unreachable") {
+        ViewOpts.MCDCCountedStates &= ~MCDCRecord::MCDC_Unreachable;
+      } else if (State != "none") {
+        error("invalid argument '" + State +
+                  "', must be in one of 'uncoverable, constant, unreachable'",
+              "--mcdc-exclude");
+        return 1;
+      }
+    }
+
     ViewOpts.ShowMCDCSummary = MCDCSummary;
     ViewOpts.ShowBranchSummary = BranchSummary;
     ViewOpts.ShowRegionSummary = RegionSummary;
diff --git a/llvm/tools/llvm-cov/CoverageReport.cpp b/llvm/tools/llvm-cov/CoverageReport.cpp
@@ -428,7 +428,8 @@ void CoverageReport::renderFunctionReports(ArrayRef<std::string> Files,
     OS << "\n";
     FunctionCoverageSummary Totals("TOTAL");
     for (const auto &F : Functions) {
-      auto Function = FunctionCoverageSummary::get(Coverage, F);
+      auto Function =
+          FunctionCoverageSummary::get(Coverage, F, Options.MCDCCountedStates);
       ++Totals.ExecutionCount;
       Totals.RegionCoverage += Function.RegionCoverage;
       Totals.LineCoverage += Function.LineCoverage;
@@ -453,7 +454,8 @@ void CoverageReport::prepareSingleFileReport(const StringRef Filename,
     for (const coverage::FunctionRecord *F : Group.getInstantiations()) {
       if (!Filters->matches(*Coverage, *F))
         continue;
-      auto InstantiationSummary = FunctionCoverageSummary::get(*Coverage, *F);
+      auto InstantiationSummary = FunctionCoverageSummary::get(
+          *Coverage, *F, Options.MCDCCountedStates);
       FileReport->addInstantiation(InstantiationSummary);
       InstantiationSummaries.push_back(InstantiationSummary);
     }
diff --git a/llvm/tools/llvm-cov/CoverageSummaryInfo.cpp b/llvm/tools/llvm-cov/CoverageSummaryInfo.cpp
@@ -12,6 +12,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "CoverageSummaryInfo.h"
+#include "llvm/ProfileData/Coverage/CoverageMapping.h"
 
 using namespace llvm;
 using namespace coverage;
@@ -48,12 +49,13 @@ sumBranchExpansions(const CoverageMapping &CM,
   return BranchCoverage;
 }
 
-auto sumMCDCPairs(const ArrayRef<MCDCRecord> &Records) {
+auto
+sumMCDCPairs(const ArrayRef<MCDCRecord> &Records, const int32_t CountFlags) {
   size_t NumPairs = 0, CoveredPairs = 0;
   for (const auto &Record : Records) {
     const auto NumConditions = Record.getNumConditions();
     for (unsigned C = 0; C < NumConditions; C++) {
-      if (!Record.isCondConstant(C)) {
+      if(Record.getCondResult(C) & CountFlags){
         ++NumPairs;
         if (Record.isConditionIndependencePairCovered(C))
           ++CoveredPairs;
@@ -86,25 +88,27 @@ sumRegions(ArrayRef<CountedRegion> CodeRegions, const CoverageData &CD) {
   }
 
   return {RegionCoverageInfo(CoveredRegions, NumCodeRegions),
+    
           LineCoverageInfo(CoveredLines, NumLines)};
 }
 
 CoverageDataSummary::CoverageDataSummary(const CoverageData &CD,
-                                         ArrayRef<CountedRegion> CodeRegions) {
+                                         ArrayRef<CountedRegion> CodeRegions,const int32_t MCDCCountedFlags) {
   std::tie(RegionCoverage, LineCoverage) = sumRegions(CodeRegions, CD);
   BranchCoverage = sumBranches(CD.getBranches());
-  MCDCCoverage = sumMCDCPairs(CD.getMCDCRecords());
+  MCDCCoverage = sumMCDCPairs(CD.getMCDCRecords(),
+  MCDCCountedFlags);
 }
 
 FunctionCoverageSummary
 FunctionCoverageSummary::get(const CoverageMapping &CM,
-                             const coverage::FunctionRecord &Function) {
+                             const coverage::FunctionRecord &Function,const int32_t MCDCCountedFlags) {
   CoverageData CD = CM.getCoverageForFunction(Function);
 
   auto Summary =
       FunctionCoverageSummary(Function.Name, Function.ExecutionCount);
 
-  Summary += CoverageDataSummary(CD, Function.CountedRegions);
+  Summary += CoverageDataSummary(CD, Function.CountedRegions, MCDCCountedFlags);
 
   // Compute the branch coverage, including branches from expansions.
   Summary.BranchCoverage += sumBranchExpansions(CM, CD.getExpansions());
diff --git a/llvm/tools/llvm-cov/CoverageSummaryInfo.h b/llvm/tools/llvm-cov/CoverageSummaryInfo.h
@@ -16,6 +16,7 @@
 
 #include "llvm/ProfileData/Coverage/CoverageMapping.h"
 #include "llvm/Support/raw_ostream.h"
+#include <cstdint>
 
 namespace llvm {
 
@@ -231,7 +232,8 @@ struct CoverageDataSummary {
 
   CoverageDataSummary() = default;
   CoverageDataSummary(const coverage::CoverageData &CD,
-                      ArrayRef<coverage::CountedRegion> CodeRegions);
+                      ArrayRef<coverage::CountedRegion> CodeRegions,
+                      const int32_t MCDCCountedFlags);
 
   auto &operator+=(const CoverageDataSummary &RHS) {
     RegionCoverage += RHS.RegionCoverage;
@@ -253,7 +255,8 @@ struct FunctionCoverageSummary : CoverageDataSummary {
   /// Compute the code coverage summary for the given function coverage
   /// mapping record.
   static FunctionCoverageSummary get(const coverage::CoverageMapping &CM,
-                                     const coverage::FunctionRecord &Function);
+                                     const coverage::FunctionRecord &Function,
+                                     int32_t MCDCCountedFlags = 0);
 
   /// Compute the code coverage summary for an instantiation group \p Group,
   /// given a list of summaries for each instantiation in \p Summaries.
diff --git a/llvm/tools/llvm-cov/CoverageViewOptions.h b/llvm/tools/llvm-cov/CoverageViewOptions.h
@@ -46,6 +46,7 @@ struct CoverageViewOptions {
   bool SkipFunctions;
   bool SkipBranches;
   bool BinaryCounters;
+  int32_t MCDCCountedStates;
   OutputFormat Format;
   BranchOutputType ShowBranches;
   std::string ShowOutputDirectory;
diff --git a/llvm/tools/llvm-cov/SourceCoverageView.h b/llvm/tools/llvm-cov/SourceCoverageView.h
@@ -161,9 +161,6 @@ class SourceCoverageView {
   /// A memory buffer backing the source on display.
   const MemoryBuffer &File;
 
-  /// Various options to guide the coverage renderer.
-  const CoverageViewOptions &Options;
-
   /// Complete coverage information about the source on display.
   CoverageData CoverageInfo;
 
@@ -195,6 +192,9 @@ class SourceCoverageView {
 
   using CoverageSegmentArray = ArrayRef<const CoverageSegment *>;
 
+  /// Various options to guide the coverage renderer.
+  const CoverageViewOptions &Options;
+
   /// @name Rendering Interface
   /// @{
 
diff --git a/llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp b/llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp
@@ -1187,7 +1187,8 @@ void SourceCoverageViewHTML::renderMCDCView(raw_ostream &OS, MCDCView &MRV,
     for (unsigned i = 0; i < Record.getNumConditions(); i++)
       OS << Record.getConditionCoverageString(i);
     OS << "  MC/DC Coverage for Expression: ";
-    const auto [Coverable, Percent] = Record.getPercentCovered();
+    const auto [Coverable, Percent] =
+        Record.getPercentCovered(Options.MCDCCountedStates);
     if (Coverable) {
       OS << format("%0.2f", Percent) << "%\n";
     } else {
diff --git a/llvm/tools/llvm-cov/SourceCoverageViewText.cpp b/llvm/tools/llvm-cov/SourceCoverageViewText.cpp
@@ -377,7 +377,8 @@ void SourceCoverageViewText::renderMCDCView(raw_ostream &OS, MCDCView &MRV,
     }
     renderLinePrefix(OS, ViewDepth);
     OS << "  MC/DC Coverage for Decision: ";
-    const auto [Coverable, Percent] = Record.getPercentCovered();
+    const auto [Coverable, Percent] =
+        Record.getPercentCovered(Options.MCDCCountedStates);
     if (Coverable) {
       colored_ostream(OS, raw_ostream::RED,
                       getOptions().Colors && Percent < 100.0,
