MC/DC in LLVM Source-Based Code Coverage: llvm-cov visualization

[alanphipps]

Summary

MC/DC in LLVM Source-based Code Coverage: Review 2/3

Background
I previously upstreamed work to enable Branch Coverage (https://reviews.llvm.org/D84467), which was pushed in early 2021. MC/DC (Modified Condition/Decision Coverage) is a planned enhancement to Source-based Code Coverage. Implementation was completed in May for our downstream Arm compiler, and in general use it has not yielded any issues.

Patches have been tested on windows (stage1) and linux/mac (stage1 and stage2). Fuchsia is not yet supported.

See attached file for Background, Motivation, Design, and Implementation Concepts:

mcdc-design-doc.pdf317 KBDownload

See attached PDF for Technical Talk slides from 2022 LLVM Developers' Meeting:

PhippsAlan_MCDC_LLVM_Conf_Talk_final.pdf614 KBDownload

I am also available at Discord @alanphipps

Review
This review is for the Visualization and Evaluation components

• Bitmask evaluation and MC/DC Region Analysis:
  • CoverageMapping.h, CoverageMapping.cpp
• Creation of MC/DC Views with Records:
  • CodeCoverage.cpp
  • CoverageViewOptions.h
• Text, HTML Visualization:
  • SourceCoverageView.h, SourceCoverageView.cpp
  • SourceCoverageViewHTML.h, SourceCoverageViewHTML.cpp
  • SourceCoverageViewText.h, SourceCoverageViewText.cpp
• Summary Report Generation:
  • CoverageSummaryInfo.h, CoverageSummaryInfo.cpp
  • CoverageReport.cpp
• JSON exporting:
  • CoverageExporterJson.cpp

[gulfem]

Overall, it looks good to me. I added a few minor things.
Please add --show-mcdc to the llvm-cov command guide.
https://github.com/llvm/llvm-project/blob/main/llvm/docs/CommandGuide/llvm-cov.rst

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

249

What is the purpose of MCDCBranchRegion? We already have branch regions, and why adding MCDCDecisionRegion is not enough?

llvm/tools/llvm-cov/CoverageSummaryInfo.h

147

This comment misses a dot at the end.

158

"Covered pairs over-counted"

179

"Covered pairs over-counted"

[Ibnmardanis24]

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

249

My understanding is that MCDCDecisionRegion is used for storing the set of minimum condition permutations required for complete MC/DC coverage. This is fundamentally different from BranchRegion's purpose. BranchRegion records the path taken, rather than the condition set that produced it. There is an interesting interaction between the 2, which I believe to be the reason for MCDCBranchRegion: when on a given path, subsequent branching could be conditioned by the particular permutation that allowed it, meaning the path taken downstream could be guessed from MC/DC information. This condition projection can only be done when on MC/DC mode and it also requires more space to exercise. Therefore, this should justify having BranchRegion and MCDCBranchRegion separated.

[alanphipps]

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

249

Yes there are three region types that apply:

1.) "BranchRegion" applies to BranchCoverage when MC/DC is not enabled or to single conditions (where MC/DC doesn't make sense) and simply represents the True/False Counters for a condition. This is also maintained for backward compatibility in the format. It requires less data than MCDCBranchRegion.

2.) "MCDCBranchRegion" extends "BranchRegion" to also apply condition IDs to the condition and is only used when MC/DC is enabled and used.

3.) "MCDCDecisionRegion" is intended to apply to the entire set of conditions in the boolean expression, supplying the source begin/end for the whole region, and supply bitmap index used to track the test vectors for the region.

llvm-cov associates MCDCDecisionRegion with a set of MCDCBranchRegions based on its tie to the source code.

[alanphipps]

In D138847#4186309, @gulfem wrote:

Overall, it looks good to me. I added a few minor things.
Please add --show-mcdc to the llvm-cov command guide.
https://github.com/llvm/llvm-project/blob/main/llvm/docs/CommandGuide/llvm-cov.rst

Thanks! -- yes I need to add the documentation. I'll make the adjustments with a rebase soon.

[gulfem]

Your commit message mentioned: "Fuchsia is not yet supported."
Is there anything that stops us generating MC/DC coverage in Fuchsia or is it just not tested yet?

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

249

Thanks for the explanation!

[alanphipps]

In D138847#4190503, @gulfem wrote:

Your commit message mentioned: "Fuchsia is not yet supported."
Is there anything that stops us generating MC/DC coverage in Fuchsia or is it just not tested yet?

Right, there's nothing that would stop us from enabling MC/DC for Fuchsia; it's not tested. I was planning to leave it separate, so if you or someone wants to enable it and test it, I would be happy to help!

[alanphipps]

Rebase and update based on review comments.

[alanphipps]

Updated diff based on some of the review comments in the clang review (https://reviews.llvm.org/D138849)

[chapuni]

@alanphipps Could you apply clang-format please?

https://github.com/chapuni/llvm-project/commit/8143d4031a52586f71a15f5ea41b3cf3d82c3531

[alanphipps]

Reapply clang-format and minor cleanup

[chapuni]

@alanphipps Thanks for the update.

Can I regenerate test imputs in tests? (eg. *.o32l)
I suggest adding command lines as comments in each source file.

I don't know how to obtain blobs from phab.

[paquette]

This is cool!

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

271–275

On AArch64 Darwin (with clang-1403), FileID is set to 1 when used uninitialised. Somewhere in this patch set we create a default CounterMappingRegion struct.

This causes ParameterizedCovMapTest/CoverageMappingTest.non_code_region_bitmask/0 to assert.

Can we explicitly initialise these values to 0?

[paquette]

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

266

Style nit: I don't think I've ever seen an underscore at the beginning of a struct name? Maybe I'm wrong.

388

Why not SmallVector?

389

Why not SmallVector?

390

Why not SmallVector?

446

Variables in this function should start with a capital letter.

https://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly

Variable names should be nouns (as they represent state). The name should be camel case, and start with an upper case letter (e.g. Leader or Boats).

458

Nit: prefer static cast for greppability

461

Nit: Prefer whole words? (Ditto for the other Hdr function)

484

Nit: prefer whole words?

Also when I read "TestVector" I assume the type is going to be some sort of vector. Could you give this a different name?

485

In asserts, a string describing why the assert is there can be very helpful.

487

Maybe there should be a function called printConditions?

509

Maybe there should be a function called printResult?

520

521

llvm/lib/ProfileData/Coverage/CoverageMapping.cpp

243

Can you add Doxygen comments to the member variables in this class?

244

Looking at the later code, it looks like this indicates whether or not something was run. How about renaming it so that's clear?

E.g. VectorAtIdxWasExecuted or something?

269

LLVM style guide for variables

287

How about some helper functions for this instead of a comment?

shouldCopyOffTestVectorForTruePath(Branch);
shouldCopyOffTestVectorForFalsePath(Branch);

312

How about let's get rid of the braces here to make this a little easier to read.

for (unsigned Idx = 0; Idx < Bitmap.size(); ++Idx) {
   if (!Bitmap[Idx])
     continue;
   assert(!TestVectors[i].empty() && "Test vector doesn't exist.");
   ExecVectors.push_back(TestVectors[i]);
}

318

Can you add a comment explaining what this function is supposed to do?

Also can you give a more descriptive name to C? Maybe ConditionIdx?

334

How about

// Look for other conditions that don't match.
// Skip over C and don't care values (because we don't care about them).
const auto ARecordTyForCond = A[i];
const auto BRecordTyForCond = B[i];
if (i == C ||
    ARecordTyForCond == MCDCRecord::MCDC_DontCare ||
    BRecordTyForCond == MCDCRecord::MCDC_DontCare)
  continue;

// Condition mismatch, so we don't have a match.
if (ARecordTyForCond != BRecordTyForCond)
  return false;

The checks for don't-cares are technically "skip this" statements, so it feels clearer to include them in the continue branch.

343

Can you add a comment to this function?

[paquette]

llvm/lib/ProfileData/Coverage/CoverageMapping.cpp

367

Doxygen comment?

372

this comment probably could be adapted into a doxygen comment

621

LLVM coding standards say to avoid else after return.

https://llvm.org/docs/CodingStandards.html#don-t-use-else-after-a-return

670

Can you explain why you are decrementing this?

677

Why not rewrite evaluateBitmap so that it passes the whole MCDCDecision struct?

[alanphipps]

Thank you for the comments! I appreciate the attention on this review. I hope to address them within the next few days.

[paquette]

No problem, thanks for doing this work, it's very exciting!

[paquette]

ping :)

[alanphipps]

Update forthcoming for this review this weekend... Sorry for the delay!

[alanphipps]

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

487

The function is really constructing a string. I'm going to leave the function intact but it makes sense that the comments shouldn't say "print" when that's not really what it's doing.

[alanphipps]

Update diff...

[paquette]

LGTM

[chapuni]

Thank you for the working and excuse my nitpicks.

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

284–285

Could this be reformatted?

585–586

Could this be reformatted?

llvm/lib/ProfileData/Coverage/CoverageMapping.cpp

690–692

Could this be reformatted?

llvm/test/tools/llvm-cov/mcdc-const.test

5

I am afraid this would fail if LLVM is not configured for the arch of mcdc-*.o.

[phosek]

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

266

No need for typedef in C++.

278–287

I'd consider omitting these constructors altogether and just use aggregate initialization with default values.

[phosek]

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

386

No need for typedef in C++.

427

I'd consider spelling it out in full, it took me a second to realize that Indep means "Independent", or at least I assume it does?

462

470

487

524

llvm/lib/ProfileData/Coverage/CoverageMapping.cpp

237

238

394

395

398

401

llvm/tools/llvm-cov/CoverageSummaryInfo.cpp

50

[phosek]

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

265

I think that MCDCConditionID would be a more idiomatic LLVM type name.

[alanphipps]

Update diff based clang-format and review comments...

llvm/test/tools/llvm-cov/mcdc-const.test

5

Support for different binary formats is tested by binary-formats.c, but I'm not sure this matters for the documented coverage format anyway because it isn't architecture specific, unless I'm overlooking something. I've not seen any issues with others tests in the same directory that follow the same pattern (e.g. branch-c-general.test et al.) that are also built for a single arch and binary format.

[chapuni]

I confirmed all tests passing (with applying three diffs and generated blobs). Thanks.

llvm/test/tools/llvm-cov/mcdc-const.test

5

I generated wrong object mcdc-const*.o. (I didn't copy mcdc-const*.cpp to /tmp)
It caused test failures when directory layout differs.
Sorry for bothering you.

I have reconfirmed mcdc-const*.o generated on aarch64 working on amd64 as well.

[alanphipps]

In D138847#4541837, @chapuni wrote:

I confirmed all tests passing (with applying three diffs and generated blobs). Thanks.

@chapuni Thank you so much for confirming this on your end!

Thank you @phosek for your comments. Do you see anything else on your end?

[chapuni]

A merge conflict to D151283. Could you catch up?

[futogergely]

HI, I just started to look into MC/DC, and if I understand correctly, with the current implementation, you can have 100% MC/DC coverage in the following case:

void test(bool a, bool b, bool c) {

  if (a && b)
    std::cout << "test_1 decision true\n";

  if (c)
    std::cout << "test_2 decision true\n";

}

int main() {
    test(true, false, false);
    test(true, true, false);
    test(false, true, false);
}

This gives you 100% MC/DC coverage (with 2 MC/DC conditions considered). However, with the tests executed, 'c' did not meet the requirements imposed by MC/DC (for example the condition did not take every possible value)

If you change 'if (c)' to 'if (c && 1)' the MC/DC coverage changes to 66.67% (with 3 MC/DC conditions considered), which should be the result for the original use case I think.
Also if you consider branch coverage as well, it will show that the tests missed some spots.

As far as I understood, MC/DC coverage should be more strict than branch coverage, so 100% MC/CD coverage should imply 100% branch coverage. Or do I miss something here?

[alanphipps]

Hello! Thanks for your question.

In D138847#4636826, @futogergely wrote:

Also if you consider branch coverage as well, it will show that the tests missed some spots.

As far as I understood, MC/DC coverage should be more strict than branch coverage, so 100% MC/CD coverage should imply 100% branch coverage. Or do I miss something here?

This implementation of MC/DC is similar to that of other vendors (e.g. LDRA) in that MC/DC coverage for single condition expressions is trivially derivable via branch coverage, which ought to be considered together with the MC/DC metric. A “test vector” for a single condition (boolean expression without operators) is simply true or false. Strictly speaking, branch coverage also gives you a metrics for other things that don’t involve an explicit Boolean expression, such as switch statements and loop ranges. The metric itself need not imply 100% branch coverage.

As this is a good observation, I can make sure the documentation is clear on this point.

[phosek]

LGTM

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

432

Nit: This name doesn't follow LLVM naming conventions.

[MaskRay]

Please, when landing a large patch, check whether clang can build the project. The original commit caused -Wswitch failure which I fixed in ca22d6e40508f6d24a9352835bda9c152e3eee1b.

When reverting a patch, run the test as well. ninja clang did not build due to ca22d6e40508f6d24a9352835bda9c152e3eee1b not being part of the revert.

[alanphipps]

In D138847#4649079, @MaskRay wrote:

Please, when landing a large patch, check whether clang can build the project. The original commit caused -Wswitch failure which I fixed in ca22d6e40508f6d24a9352835bda9c152e3eee1b.

When reverting a patch, run the test as well. ninja clang did not build due to ca22d6e40508f6d24a9352835bda9c152e3eee1b not being part of the revert.

Yes, thanks -- I did build my changes prior to landing them, but I did not see the -Wswitch failure until it landed, not sure why. These changes are actually addressed in the successive commit, which I will now apply here. I reverted due to test failures on windows and did not see your commit to address the -Wswitch failure.

[alanphipps]

Eliminated -Wswitch build issues in CoverageMappingGen.cpp. The actual code for this originally ended up in D138849 after I split up the patches, but it should've been included in this one.

Fixed windows test failures, which were due to relative coverage compilation path inconsistencies in the generated object files used in the test cases. I addressed this by using -fcoverage-compilation-dir and verified the tests now pass on windows, linux, and mac.

Also rebased.

[alanphipps]

@phosek @paquette buildbot issues have been addressed -- could you reapprove? Thanks!

[alanphipps]

Thanks @MaskRay I've addressed the build issues and buildbot failures encountered with the previous attempt to land this. Can you re-approve?

[MaskRay]

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

37

This is an uncommon include in LLVM. We usually use format, formatv, etc.

llvm/tools/llvm-cov/CoverageSummaryInfo.cpp

47

prefer std::pair return value
https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-out

50

https://llvm.org/docs/CodingStandards.html#don-t-evaluate-end-every-time-through-a-loop

[MaskRay]

llvm/test/tools/llvm-cov/mcdc-const.test

73

Prefer -NEXT for adjacent lines

llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp

973

Use Twine https://llvm.org/docs/ProgrammersManual.html#the-twine-class

[paquette]

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

255

Would it make sense to drop "(MC/DC only)" on this and other member vars in this class?

386

Can you put a doxygen comment on this explaining what each of the members are?

417

I think this comment should be changed into a Doxygen comment that explains what this function is doing to TestVectorIndex and Condition.

422

Could use a doxygen comment here

428

doxygen

438

doxygen

449

Would it be valid for getNumConditions to ever be 0? Would it make sense to add an assert somewhere if it doesn't make sense?

507

might as well pull this into a variable instead of calling it here and in the loop

const auto NumConditions = getNumConditions();

llvm/lib/ProfileData/Coverage/CoverageMapping.cpp

330

simple explanation in doxygen comment?

339

this should be a doxygen comment imo

349

doxygenify

llvm/tools/llvm-cov/CodeCoverage.cpp

382

can reduce indentation here

if (ViewMCDCRecords.empty())
  return;
auto ...

llvm/tools/llvm-cov/CoverageSummaryInfo.h

145

might as well say this is MC/DC here

148

init to 0?

151

init to 0?

[MaskRay]

llvm/test/tools/llvm-cov/mcdc-const.test

39

I am also concerned of prebuilt relocatable object files checked into the repository.
They are target-specific, opaque, and difficult to update.

I am well aware of https://maskray.me/blog/2021-08-08-toolchain-testing#the-test-checks-at-the-wrong-layer
but in this case perhaps we should use compiler-rt/test/profile

[alanphipps]

Rebase and update based on recent review comments.

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

37

I get that it's uncommon, though there appears to be some precedent, plus it's very useful. The Coding Standards seem to suggest <sstream> is OK (just not <iostream>).

449

Yep, added an assertion inside getNumConditions() itself.

llvm/test/tools/llvm-cov/mcdc-const.test

39

Ah I see -- you're suggesting using compiler-rt/test/profile so that object files can be generated directly as input to these tools. I think that's a good idea. I'd like to address that in a subsequent PR since this particular patch doesn't include the changes that enable MC/DC in clang.

I understand the concern about adding prebuilt object files to the repo. However, I really like the testing granularity it provides. I've added the steps to reproduce them. But if there is a strong desire, perhaps I can remove them in the subsequent PR and keep them in our downstream repo only (where it's easier to test our baremetal toolchain).

llvm/tools/llvm-cov/CoverageSummaryInfo.h

148

The pattern across all of the *Info classes in this file appears to be to set the member vars on construction. I'm OK with changing it if it's important.

[alanphipps]

Ping @MaskRay @paquette -- thanks for your help! As this review is now over a year old, I'd like to get it merged soon.

[MaskRay]

LGTM.

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

488

const { ?

llvm/lib/ProfileData/Coverage/CoverageMapping.cpp

365

For booleans, if (!((a ^ b) == 1) looks strange. Just use if (a != b)

372

llvm style prefers pre-increment

404

delete blank line immediately after openning a scope.

[paquette]

LGTM after you address @MaskRay's comments.

clang/lib/CodeGen/CoverageMappingGen.cpp

case CounterMappingRegion::ExpansionRegion:
       break;
     case CounterMappingRegion::SkippedRegion:
       OS << "Skipped,";
       break;
     case CounterMappingRegion::GapRegion:
       OS << "Gap,";
       break;
     case CounterMappingRegion::BranchRegion:
+    case CounterMappingRegion::MCDCBranchRegion:
       OS << "Branch,";
       break;
+    case CounterMappingRegion::MCDCDecisionRegion:
+      OS << "Decision,";
+      break;
     }
 
     OS << "File " << R.FileID << ", " << R.LineStart << ":" << R.ColumnStart
        << " -> " << R.LineEnd << ":" << R.ColumnEnd << " = ";
     Ctx.dump(R.Count, OS);
 
     if (R.Kind == CounterMappingRegion::BranchRegion) {
       OS << ", ";

llvm/docs/CommandGuide/llvm-cov.rst

 OPTIONS
 ^^^^^^^
 
 .. option:: -show-branches=<VIEW>
 
  Show coverage for branch conditions in terms of either count or percentage.
  The supported views are: "count", "percent".
 
+.. option:: -show-mcdc
+
+ Show modified condition/decision coverage (MC/DC) for each applicable boolean
+ expression.
+
 .. option:: -show-line-counts
 
  Show the execution counts for each line. Defaults to true, unless another
  ``-show`` option is used.
 
 .. option:: -show-expansions
 
  Expand inclusions, such as preprocessor macros or textual inclusions, inline

 .. option:: -show-region-summary
 
  Show statistics for all regions. Defaults to true.
 
 .. option:: -show-branch-summary
 
  Show statistics for all branch conditions. Defaults to true.
 
+.. option:: -show-mcdc-summary
+
+ Show MC/DC statistics. Defaults to false.
+
 .. option:: -show-functions
 
  Show coverage summaries for each function. Defaults to false.
 
 .. option:: -show-instantiation-summary
 
  Show statistics for all function instantiations. Defaults to false.
 

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

 // llvm-cov to show code coverage statistics for a file.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_PROFILEDATA_COVERAGE_COVERAGEMAPPING_H
 #define LLVM_PROFILEDATA_COVERAGE_COVERAGEMAPPING_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Object/BuildID.h"
 #include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Support/Alignment.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdint>
 #include <iterator>
 #include <memory>
+#include <sstream>
 #include <string>
 #include <system_error>
 #include <tuple>
 #include <utility>
 #include <vector>
 
 namespace llvm {
 
enum RegionKind {
 
     /// A GapRegion is like a CodeRegion, but its count is only set as the
     /// line execution count when its the only region in the line.
     GapRegion,
 
     /// A BranchRegion represents leaf-level boolean expressions and is
     /// associated with two counters, each representing the number of times the
     /// expression evaluates to true or false.
-    BranchRegion
+    BranchRegion,
+
+    /// A DecisionRegion represents a top-level boolean expression and is
+    /// associated with a variable length bitmap index and condition number.
+    MCDCDecisionRegion,
+
+    /// A Branch Region can be extended to include IDs to facilitate MC/DC.
+    MCDCBranchRegion
+  };
+
+  using MCDCConditionID = unsigned int;
+  struct MCDCParameters {
+    /// Byte Index of Bitmap Coverage Object for a Decision Region.
+    unsigned BitmapIdx = 0;
+
+    /// Number of Conditions used for a Decision Region.
+    unsigned NumConditions = 0;
+
+    /// IDs used to represent a branch region and other branch regions
+    /// evaluated based on True and False branches.
+    MCDCConditionID ID = 0, TrueID = 0, FalseID = 0;
   };
 
   /// Primary Counter that is also used for Branch Regions (TrueCount).
   Counter Count;
 
   /// Secondary Counter used for Branch Regions (FalseCount).
   Counter FalseCount;
 
-  unsigned FileID, ExpandedFileID;
+  /// Parameters used for Modified Condition/Decision Coverage
+  MCDCParameters MCDCParams;
+
+  unsigned FileID = 0;
+  unsigned ExpandedFileID = 0;
   unsigned LineStart, ColumnStart, LineEnd, ColumnEnd;
+
   RegionKind Kind;
 
   CounterMappingRegion(Counter Count, unsigned FileID, unsigned ExpandedFileID,
                        unsigned LineStart, unsigned ColumnStart,
                        unsigned LineEnd, unsigned ColumnEnd, RegionKind Kind)
       : Count(Count), FileID(FileID), ExpandedFileID(ExpandedFileID),
         LineStart(LineStart), ColumnStart(ColumnStart), LineEnd(LineEnd),
         ColumnEnd(ColumnEnd), Kind(Kind) {}
 
-  CounterMappingRegion(Counter Count, Counter FalseCount, unsigned FileID,
+  CounterMappingRegion(Counter Count, Counter FalseCount,
+                       MCDCParameters MCDCParams, unsigned FileID,
                        unsigned ExpandedFileID, unsigned LineStart,
                        unsigned ColumnStart, unsigned LineEnd,
                        unsigned ColumnEnd, RegionKind Kind)
-      : Count(Count), FalseCount(FalseCount), FileID(FileID),
-        ExpandedFileID(ExpandedFileID), LineStart(LineStart),
+      : Count(Count), FalseCount(FalseCount), MCDCParams(MCDCParams),
+        FileID(FileID), ExpandedFileID(ExpandedFileID), LineStart(LineStart),
         ColumnStart(ColumnStart), LineEnd(LineEnd), ColumnEnd(ColumnEnd),
         Kind(Kind) {}
 
+  CounterMappingRegion(MCDCParameters MCDCParams, unsigned FileID,
+                       unsigned ExpandedFileID, unsigned LineStart,
+                       unsigned ColumnStart, unsigned LineEnd,
+                       unsigned ColumnEnd, RegionKind Kind)
+      : MCDCParams(MCDCParams), ExpandedFileID(ExpandedFileID),
+        LineStart(LineStart), ColumnStart(ColumnStart), LineEnd(LineEnd),
+        ColumnEnd(ColumnEnd), Kind(Kind) {}
+
   static CounterMappingRegion
   makeRegion(Counter Count, unsigned FileID, unsigned LineStart,
              unsigned ColumnStart, unsigned LineEnd, unsigned ColumnEnd) {
     return CounterMappingRegion(Count, FileID, 0, LineStart, ColumnStart,
                                 LineEnd, ColumnEnd, CodeRegion);
   }
 
   static CounterMappingRegion
makeGapRegion(Counter Count, unsigned FileID, unsigned LineStart,
     return CounterMappingRegion(Count, FileID, 0, LineStart, ColumnStart,
                                 LineEnd, (1U << 31) | ColumnEnd, GapRegion);
   }
 
   static CounterMappingRegion
   makeBranchRegion(Counter Count, Counter FalseCount, unsigned FileID,
                    unsigned LineStart, unsigned ColumnStart, unsigned LineEnd,
                    unsigned ColumnEnd) {
-    return CounterMappingRegion(Count, FalseCount, FileID, 0, LineStart,
-                                ColumnStart, LineEnd, ColumnEnd, BranchRegion);
+    return CounterMappingRegion(Count, FalseCount, MCDCParameters(), FileID, 0,
+                                LineStart, ColumnStart, LineEnd, ColumnEnd,
+                                BranchRegion);
+  }
+
+  static CounterMappingRegion
+  makeBranchRegion(Counter Count, Counter FalseCount, MCDCParameters MCDCParams,
+                   unsigned FileID, unsigned LineStart, unsigned ColumnStart,
+                   unsigned LineEnd, unsigned ColumnEnd) {
+    return CounterMappingRegion(Count, FalseCount, MCDCParams, FileID, 0,
+                                LineStart, ColumnStart, LineEnd, ColumnEnd,
+                                MCDCParams.ID == 0 ? BranchRegion
+                                                   : MCDCBranchRegion);
+  }
+
+  static CounterMappingRegion
+  makeDecisionRegion(MCDCParameters MCDCParams, unsigned FileID,
+                     unsigned LineStart, unsigned ColumnStart, unsigned LineEnd,
+                     unsigned ColumnEnd) {
+    return CounterMappingRegion(MCDCParams, FileID, 0, LineStart, ColumnStart,
+                                LineEnd, ColumnEnd, MCDCDecisionRegion);
   }
 
   inline LineColPair startLoc() const {
     return LineColPair(LineStart, ColumnStart);
   }
 
   inline LineColPair endLoc() const { return LineColPair(LineEnd, ColumnEnd); }
 };
CountedRegion(const CounterMappingRegion &R, uint64_t ExecutionCount)
         FalseExecutionCount(0), Folded(false) {}
 
   CountedRegion(const CounterMappingRegion &R, uint64_t ExecutionCount,
                 uint64_t FalseExecutionCount)
       : CounterMappingRegion(R), ExecutionCount(ExecutionCount),
         FalseExecutionCount(FalseExecutionCount), Folded(false) {}
 };
 
+/// MCDC Record grouping all information together.
+struct MCDCRecord {
+  /// CondState represents the evaluation of a condition in an executed test
+  /// vector, which can be True or False. A DontCare is used to mask an
+  /// unevaluatable condition resulting from short-circuit behavior of logical
+  /// operators in languages like C/C++. When comparing the evaluation of a
+  /// condition across executed test vectors, comparisons against a DontCare
+  /// are effectively ignored.
+  enum CondState { MCDC_DontCare = -1, MCDC_False = 0, MCDC_True = 1 };
+
+  using TestVector = llvm::SmallVector<CondState>;
+  using TestVectors = llvm::SmallVector<TestVector>;
+  using BoolVector = llvm::SmallVector<bool>;
+  using TVRowPair = std::pair<unsigned, unsigned>;
+  using TVPairMap = llvm::DenseMap<unsigned, TVRowPair>;
+  using CondIDMap = llvm::DenseMap<unsigned, unsigned>;
+  using LineColPairMap = llvm::DenseMap<unsigned, LineColPair>;
+
+private:
+  CounterMappingRegion Region;
+  TestVectors TV;
+  TVPairMap IndependencePairs;
+  BoolVector Folded;
+  CondIDMap PosToID;
+  LineColPairMap CondLoc;
+
+public:
+  MCDCRecord(CounterMappingRegion Region, TestVectors TV,
+             TVPairMap IndependencePairs, BoolVector Folded, CondIDMap PosToID,
+             LineColPairMap CondLoc)
+      : Region(Region), TV(TV), IndependencePairs(IndependencePairs),
+        Folded(Folded), PosToID(PosToID), CondLoc(CondLoc){};
+
+  CounterMappingRegion getDecisionRegion() const { return Region; }
+  unsigned getNumConditions() const {
+    assert(Region.MCDCParams.NumConditions != 0 &&
+           "In MC/DC, NumConditions should never be zero!");
+    return Region.MCDCParams.NumConditions;
+  }
+  unsigned getNumTestVectors() const { return TV.size(); }
+  bool isCondFolded(unsigned Condition) const { return Folded[Condition]; }
+
+  /// Return the evaluation of a condition (indicated by Condition) in an
+  /// executed test vector (indicated by TestVectorIndex), which will be True,
+  /// False, or DontCare if the condition is unevaluatable. Because condition
+  /// IDs are not associated based on their position in the expression,
+  /// accessing conditions in the TestVectors requires a translation from a
+  /// ordinal position to actual condition ID. This is done via PosToID[].
+  CondState getTVCondition(unsigned TestVectorIndex, unsigned Condition) {
+    return TV[TestVectorIndex][PosToID[Condition]];
+  }
+
+  /// Return the Result evaluation for an executed test vector.
+  /// See MCDCRecordProcessor::RecordTestVector().
+  CondState getTVResult(unsigned TestVectorIndex) {
+    return TV[TestVectorIndex][getNumConditions()];
+  }
+
+  /// Determine whether a given condition (indicated by Condition) is covered
+  /// by an Independence Pair. Because condition IDs are not associated based
+  /// on their position in the expression, accessing conditions in the
+  /// TestVectors requires a translation from a ordinal position to actual
+  /// condition ID. This is done via PosToID[].
+  bool isConditionIndependencePairCovered(unsigned Condition) const {
+    auto It = PosToID.find(Condition);
+    if (It != PosToID.end())
+      return (IndependencePairs.find(It->second) != IndependencePairs.end());
+    llvm_unreachable("Condition ID without an Ordinal mapping");
+  }
+
+  /// Return the Independence Pair that covers the given condition. Because
+  /// condition IDs are not associated based on their position in the
+  /// expression, accessing conditions in the TestVectors requires a
+  /// translation from a ordinal position to actual condition ID. This is done
+  /// via PosToID[].
+  TVRowPair getConditionIndependencePair(unsigned Condition) {
+    assert(isConditionIndependencePairCovered(Condition));
+    return IndependencePairs[PosToID[Condition]];
+  }
+
+  float getPercentCovered() const {
+    unsigned Folded = 0;
+    unsigned Covered = 0;
+    for (unsigned C = 0; C < getNumConditions(); C++) {
+      if (isCondFolded(C))
+        Folded++;
+      else if (isConditionIndependencePairCovered(C))
+        Covered++;
+    }
+
+    unsigned Total = getNumConditions() - Folded;
+    if (Total == 0)
+      return 0.0;
+    return (static_cast<double>(Covered) / static_cast<double>(Total)) * 100.0;
+  }
+
+  std::string getConditionHeaderString(unsigned Condition) {
+    std::ostringstream OS;
+    OS << "Condition C" << Condition + 1 << " --> (";
+    OS << CondLoc[Condition].first << ":" << CondLoc[Condition].second;
+    OS << ")\n";
+    return OS.str();
+  }
+
+  std::string getTestVectorHeaderString() const {
+    std::ostringstream OS;
+    if (getNumTestVectors() == 0) {
+      OS << "None.\n";
+      return OS.str();
+    }
+    const auto NumConditions = getNumConditions();
+    for (unsigned I = 0; I < NumConditions; I++) {
+      OS << "C" << I + 1;
+      if (I != NumConditions - 1)
+        OS << ", ";
+    }
+    OS << "    Result\n";
+    return OS.str();
+  }
+
+  std::string getTestVectorString(unsigned TestVectorIndex) {
+    assert(TestVectorIndex < getNumTestVectors() &&
+           "TestVector index out of bounds!");
+    std::ostringstream OS;
+    const auto NumConditions = getNumConditions();
+    // Add individual condition values to the string.
+    OS << "  " << TestVectorIndex + 1 << " { ";
+    for (unsigned Condition = 0; Condition < NumConditions; Condition++) {
+      if (isCondFolded(Condition))
+        OS << "C";
+      else {
+        switch (getTVCondition(TestVectorIndex, Condition)) {
+        case MCDCRecord::MCDC_DontCare:
+          OS << "-";
+          break;
+        case MCDCRecord::MCDC_True:
+          OS << "T";
+          break;
+        case MCDCRecord::MCDC_False:
+          OS << "F";
+          break;
+        }
+      }
+      if (Condition != NumConditions - 1)
+        OS << ",  ";
+    }
+
+    // Add result value to the string.
+    OS << "  = ";
+    if (getTVResult(TestVectorIndex) == MCDC_True)
+      OS << "T";
+    else
+      OS << "F";
+    OS << "      }\n";
+
+    return OS.str();
+  }
+
+  std::string getConditionCoverageString(unsigned Condition) {
+    assert(Condition < getNumConditions() &&
+           "Condition index is out of bounds!");
+    std::ostringstream OS;
+
+    OS << "  C" << Condition + 1 << "-Pair: ";
+    if (isCondFolded(Condition)) {
+      OS << "constant folded\n";
+    } else if (isConditionIndependencePairCovered(Condition)) {
+      TVRowPair rows = getConditionIndependencePair(Condition);
+      OS << "covered: (" << rows.first << ",";
+      OS << rows.second << ")\n";
+    } else
+      OS << "not covered\n";
+
+    return OS.str();
+  }
+};
+
 /// A Counter mapping context is used to connect the counters, expressions
 /// and the obtained counter values.
 class CounterMappingContext {
   ArrayRef<CounterExpression> Expressions;
   ArrayRef<uint64_t> CounterValues;
+  ArrayRef<uint8_t> BitmapBytes;
 
 public:
   CounterMappingContext(ArrayRef<CounterExpression> Expressions,
                         ArrayRef<uint64_t> CounterValues = std::nullopt)
       : Expressions(Expressions), CounterValues(CounterValues) {}
 
   void setCounts(ArrayRef<uint64_t> Counts) { CounterValues = Counts; }
+  void setBitmapBytes(ArrayRef<uint8_t> Bytes) { BitmapBytes = Bytes; }
 
   void dump(const Counter &C, raw_ostream &OS) const;
   void dump(const Counter &C) const { dump(C, dbgs()); }
 
   /// Return the number of times that a region of code associated with this
   /// counter was executed.
   Expected<int64_t> evaluate(const Counter &C) const;
 
+  /// Return the number of times that a region of code associated with this
+  /// counter was executed.
+  Expected<BitVector>
+  evaluateBitmap(const CounterMappingRegion *MCDCDecision) const;
+
+  /// Return an MCDC record that indicates executed test vectors and condition
+  /// pairs.
+  Expected<MCDCRecord>
+  evaluateMCDCRegion(CounterMappingRegion Region, BitVector Bitmap,
+                     ArrayRef<CounterMappingRegion> Branches);
+
   unsigned getMaxCounterID(const Counter &C) const;
 };
 
 /// Code coverage information for a single function.
 struct FunctionRecord {
   /// Raw function name.
   std::string Name;
   /// Mapping from FileID (i.e. vector index) to filename. Used to support
   /// macro expansions within a function in which the macro and function are
   /// defined in separate files.
   ///
   /// TODO: Uniquing filenames across all function records may be a performance
   /// optimization.
   std::vector<std::string> Filenames;
   /// Regions in the function along with their counts.
   std::vector<CountedRegion> CountedRegions;
   /// Branch Regions in the function along with their counts.
   std::vector<CountedRegion> CountedBranchRegions;
+  /// MCDC Records record a DecisionRegion and associated BranchRegions.
+  std::vector<MCDCRecord> MCDCRecords;
   /// The number of times this function was executed.
   uint64_t ExecutionCount = 0;
 
   FunctionRecord(StringRef Name, ArrayRef<StringRef> Filenames)
       : Name(Name), Filenames(Filenames.begin(), Filenames.end()) {}
 
   FunctionRecord(FunctionRecord &&FR) = default;
   FunctionRecord &operator=(FunctionRecord &&) = default;
 
+  void pushMCDCRecord(MCDCRecord Record) { MCDCRecords.push_back(Record); }
+
   void pushRegion(CounterMappingRegion Region, uint64_t Count,
                   uint64_t FalseCount) {
-    if (Region.Kind == CounterMappingRegion::BranchRegion) {
+    if (Region.Kind == CounterMappingRegion::BranchRegion ||
+        Region.Kind == CounterMappingRegion::MCDCBranchRegion) {
       CountedBranchRegions.emplace_back(Region, Count, FalseCount);
       // If both counters are hard-coded to zero, then this region represents a
       // constant-folded branch.
       if (Region.Count.isZero() && Region.FalseCount.isZero())
         CountedBranchRegions.back().Folded = true;
       return;
     }
     if (CountedRegions.empty())

 /// list of expansions that can be further processed.
 class CoverageData {
   friend class CoverageMapping;
 
   std::string Filename;
   std::vector<CoverageSegment> Segments;
   std::vector<ExpansionRecord> Expansions;
   std::vector<CountedRegion> BranchRegions;
+  std::vector<MCDCRecord> MCDCRecords;
 
 public:
   CoverageData() = default;
 
   CoverageData(StringRef Filename) : Filename(Filename) {}
 
   /// Get the name of the file this data covers.
   StringRef getFilename() const { return Filename; }
public:
 
   bool empty() const { return Segments.empty(); }
 
   /// Expansions that can be further processed.
   ArrayRef<ExpansionRecord> getExpansions() const { return Expansions; }
 
   /// Branches that can be further processed.
   ArrayRef<CountedRegion> getBranches() const { return BranchRegions; }
+
+  /// MCDC Records that can be further processed.
+  ArrayRef<MCDCRecord> getMCDCRecords() const { return MCDCRecords; }
 };
 
 /// The mapping of profile information to coverage data.
 ///
 /// This is the main interface to get coverage information, using a profile to
 /// fill out execution counts.
 class CoverageMapping {
   DenseMap<size_t, DenseSet<size_t>> RecordProvenance;

llvm/lib/ProfileData/Coverage/CoverageMapping.cpp

 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
+#include <cmath>
 #include <cstdint>
 #include <iterator>
 #include <map>
 #include <memory>
 #include <optional>
 #include <string>
 #include <system_error>
 #include <utility>
case Counter::Expression: {
       break;
     }
     }
   }
 
   return LastPoppedValue;
 }
 
+Expected<BitVector> CounterMappingContext::evaluateBitmap(
+    const CounterMappingRegion *MCDCDecision) const {
+  unsigned ID = MCDCDecision->MCDCParams.BitmapIdx;
+  unsigned NC = MCDCDecision->MCDCParams.NumConditions;
+  unsigned SizeInBits = llvm::alignTo(uint64_t(1) << NC, CHAR_BIT);
+  unsigned SizeInBytes = SizeInBits / CHAR_BIT;
+
+  ArrayRef<uint8_t> Bytes(&BitmapBytes[ID], SizeInBytes);
+
+  // Mask each bitmap byte into the BitVector. Go in reverse so that the
+  // bitvector can just be shifted over by one byte on each iteration.
+  BitVector Result(SizeInBits, false);
+  for (auto Byte = std::rbegin(Bytes); Byte != std::rend(Bytes); ++Byte) {
+    uint32_t Data = *Byte;
+    Result <<= CHAR_BIT;
+    Result.setBitsInMask(&Data, 1);
+  }
+  return Result;
+}
+
+class MCDCRecordProcessor {
+  /// A bitmap representing the executed test vectors for a boolean expression.
+  /// Each index of the bitmap corresponds to a possible test vector. An index
+  /// with a bit value of '1' indicates that the corresponding Test Vector
+  /// identified by that index was executed.
+  BitVector &ExecutedTestVectorBitmap;
+
+  /// Decision Region to which the ExecutedTestVectorBitmap applies.
+  CounterMappingRegion &Region;
+
+  /// Array of branch regions corresponding each conditions in the boolean
+  /// expression.
+  ArrayRef<CounterMappingRegion> Branches;
+
+  /// Total number of conditions in the boolean expression.
+  unsigned NumConditions;
+
+  /// Mapping of a condition ID to its corresponding branch region.
+  llvm::DenseMap<unsigned, const CounterMappingRegion *> Map;
+
+  /// Vector used to track whether a condition is constant folded.
+  MCDCRecord::BoolVector Folded;
+
+  /// Mapping of calculated MC/DC Independence Pairs for each condition.
+  MCDCRecord::TVPairMap IndependencePairs;
+
+  /// Total number of possible Test Vectors for the boolean expression.
+  MCDCRecord::TestVectors TestVectors;
+
+  /// Actual executed Test Vectors for the boolean expression, based on
+  /// ExecutedTestVectorBitmap.
+  MCDCRecord::TestVectors ExecVectors;
+
+public:
+  MCDCRecordProcessor(BitVector &Bitmap, CounterMappingRegion &Region,
+                      ArrayRef<CounterMappingRegion> Branches)
+      : ExecutedTestVectorBitmap(Bitmap), Region(Region), Branches(Branches),
+        NumConditions(Region.MCDCParams.NumConditions),
+        Folded(NumConditions, false), IndependencePairs(NumConditions),
+        TestVectors(pow(2, NumConditions)) {}
+
+private:
+  void recordTestVector(MCDCRecord::TestVector &TV,
+                        MCDCRecord::CondState Result) {
+    // Calculate an index that is used to identify the test vector in a vector
+    // of test vectors.  This index also corresponds to the index values of an
+    // MCDC Region's bitmap (see findExecutedTestVectors()).
+    unsigned Index = 0;
+    for (auto Cond = std::rbegin(TV); Cond != std::rend(TV); ++Cond) {
+      Index <<= 1;
+      Index |= (*Cond == MCDCRecord::MCDC_True) ? 0x1 : 0x0;
+    }
+
+    // Copy the completed test vector to the vector of testvectors.
+    TestVectors[Index] = TV;
+
+    // The final value (T,F) is equal to the last non-dontcare state on the
+    // path (in a short-circuiting system).
+    TestVectors[Index].push_back(Result);
+  }
+
+  void shouldCopyOffTestVectorForTruePath(MCDCRecord::TestVector &TV,
+                                          unsigned ID) {
+    // Branch regions are hashed based on an ID.
+    const CounterMappingRegion *Branch = Map[ID];
+
+    TV[ID - 1] = MCDCRecord::MCDC_True;
+    if (Branch->MCDCParams.TrueID > 0)
+      buildTestVector(TV, Branch->MCDCParams.TrueID);
+    else
+      recordTestVector(TV, MCDCRecord::MCDC_True);
+  }
+
+  void shouldCopyOffTestVectorForFalsePath(MCDCRecord::TestVector &TV,
+                                           unsigned ID) {
+    // Branch regions are hashed based on an ID.
+    const CounterMappingRegion *Branch = Map[ID];
+
+    TV[ID - 1] = MCDCRecord::MCDC_False;
+    if (Branch->MCDCParams.FalseID > 0)
+      buildTestVector(TV, Branch->MCDCParams.FalseID);
+    else
+      recordTestVector(TV, MCDCRecord::MCDC_False);
+  }
+
+  /// Starting with the base test vector, build a comprehensive list of
+  /// possible test vectors by recursively walking the branch condition IDs
+  /// provided. Once an end node is reached, record the test vector in a vector
+  /// of test vectors that can be matched against during MC/DC analysis, and
+  /// then reset the positions to 'DontCare'.
+  void buildTestVector(MCDCRecord::TestVector &TV, unsigned ID = 1) {
+    shouldCopyOffTestVectorForTruePath(TV, ID);
+    shouldCopyOffTestVectorForFalsePath(TV, ID);
+
+    // Reset back to DontCare.
+    TV[ID - 1] = MCDCRecord::MCDC_DontCare;
+  }
+
+  /// Walk the bits in the bitmap.  A bit set to '1' indicates that the test
+  /// vector at the corresponding index was executed during a test run.
+  void findExecutedTestVectors(BitVector &ExecutedTestVectorBitmap) {
+    for (unsigned Idx = 0; Idx < ExecutedTestVectorBitmap.size(); ++Idx) {
+      if (ExecutedTestVectorBitmap[Idx] == 0)
+        continue;
+      assert(!TestVectors[Idx].empty() && "Test Vector doesn't exist.");
+      ExecVectors.push_back(TestVectors[Idx]);
+    }
+  }
+
+  /// For a given condition and two executed Test Vectors, A and B, see if the
+  /// two test vectors match forming an Independence Pair for the condition.
+  /// For two test vectors to match, the following must be satisfied:
+  /// - The condition's value in each test vector must be opposite.
+  /// - The result's value in each test vector must be opposite.
+  /// - All other conditions' values must be equal or marked as "don't care".
+  bool matchTestVectors(unsigned Aidx, unsigned Bidx, unsigned ConditionIdx) {
+    const MCDCRecord::TestVector &A = ExecVectors[Aidx];
+    const MCDCRecord::TestVector &B = ExecVectors[Bidx];
+
+    // If condition values in both A and B aren't opposites, no match.
+    // Because a value can be 0 (false), 1 (true), or -1 (DontCare), a check
+    // that "XOR != 1" will ensure that the values are opposites and that
+    // neither of them is a DontCare.
+    //  1 XOR  0 ==  1 | 0 XOR  0 ==  0 | -1 XOR  0 == -1
+    //  1 XOR  1 ==  0 | 0 XOR  1 ==  1 | -1 XOR  1 == -2
+    //  1 XOR -1 == -2 | 0 XOR -1 == -1 | -1 XOR -1 ==  0
+    if ((A[ConditionIdx] ^ B[ConditionIdx]) != 1)
+      return false;
+
+    // If the results of both A and B aren't opposites, no match.
+    if ((A[NumConditions] ^ B[NumConditions]) != 1)
+      return false;
+
+    for (unsigned Idx = 0; Idx < NumConditions; ++Idx) {
+      // Look for other conditions that don't match. Skip over the given
+      // Condition as well as any conditions marked as "don't care".
+      const auto ARecordTyForCond = A[Idx];
+      const auto BRecordTyForCond = B[Idx];
+      if (Idx == ConditionIdx ||
+          ARecordTyForCond == MCDCRecord::MCDC_DontCare ||
+          BRecordTyForCond == MCDCRecord::MCDC_DontCare)
+        continue;
+
+      // If there is a condition mismatch with any of the other conditions,
+      // there is no match for the test vectors.
+      if (ARecordTyForCond != BRecordTyForCond)
+        return false;
+    }
+
+    // Otherwise, match.
+    return true;
+  }
+
+  /// Find all possible Independence Pairs for a boolean expression given its
+  /// executed Test Vectors.  This process involves looking at each condition
+  /// and attempting to find two Test Vectors that "match", giving us a pair.
+  void findIndependencePairs() {
+    unsigned NumTVs = ExecVectors.size();
+
+    // For each condition.
+    for (unsigned C = 0; C < NumConditions; ++C) {
+      bool PairFound = false;
+
+      // For each executed test vector.
+      for (unsigned I = 0; !PairFound && I < NumTVs; ++I) {
+        // Compared to every other executed test vector.
+        for (unsigned J = 0; !PairFound && J < NumTVs; ++J) {
+          if (I == J)
+            continue;
+
+          // If a matching pair of vectors is found, record them.
+          if ((PairFound = matchTestVectors(I, J, C)))
+            IndependencePairs[C] = std::make_pair(I + 1, J + 1);
+        }
+      }
+    }
+  }
+
+public:
+  /// Process the MC/DC Record in order to produce a result for a boolean
+  /// expression. This process includes tracking the conditions that comprise
+  /// the decision region, calculating the list of all possible test vectors,
+  /// marking the executed test vectors, and then finding an Independence Pair
+  /// out of the executed test vectors for each condition in the boolean
+  /// expression. A condition is tracked to ensure that its ID can be mapped to
+  /// its ordinal position in the boolean expression. The condition's source
+  /// location is also tracked, as well as whether it is constant folded (in
+  /// which case it is excuded from the metric).
+  MCDCRecord processMCDCRecord() {
+    unsigned I = 0;
+    MCDCRecord::CondIDMap PosToID;
+    MCDCRecord::LineColPairMap CondLoc;
+
+    // Walk the Record's BranchRegions (representing Conditions) in order to:
+    // - Hash the condition based on its corresponding ID. This will be used to
+    //   calculate the test vectors.
+    // - Keep a map of the condition's ordinal position (1, 2, 3, 4) to its
+    //   actual ID.  This will be used to visualize the conditions in the
+    //   correct order.
+    // - Keep track of the condition source location. This will be used to
+    //   visualize where the condition is.
+    // - Record whether the condition is constant folded so that we exclude it
+    //   from being measured.
+    for (const auto &B : Branches) {
+      Map[B.MCDCParams.ID] = &B;
+      PosToID[I] = B.MCDCParams.ID - 1;
+      CondLoc[I] = B.startLoc();
+      Folded[I++] = (B.Count.isZero() && B.FalseCount.isZero());
+    }
+
+    // Initialize a base test vector as 'DontCare'.
+    MCDCRecord::TestVector TV(NumConditions, MCDCRecord::MCDC_DontCare);
+
+    // Use the base test vector to build the list of all possible test vectors.
+    buildTestVector(TV);
+
+    // Using Profile Bitmap from runtime, mark the executed test vectors.
+    findExecutedTestVectors(ExecutedTestVectorBitmap);
+
+    // Compare executed test vectors against each other to find an independence
+    // pairs for each condition.  This processing takes the most time.
+    findIndependencePairs();
+
+    // Record Test vectors, executed vectors, and independence pairs.
+    MCDCRecord Res(Region, ExecVectors, IndependencePairs, Folded, PosToID,
+                   CondLoc);
+    return Res;
+  }
+};
+
+Expected<MCDCRecord> CounterMappingContext::evaluateMCDCRegion(
+    CounterMappingRegion Region, BitVector ExecutedTestVectorBitmap,
+    ArrayRef<CounterMappingRegion> Branches) {
+
+  MCDCRecordProcessor MCDCProcessor(ExecutedTestVectorBitmap, Region, Branches);
+  return MCDCProcessor.processMCDCRecord();
+}
+
 unsigned CounterMappingContext::getMaxCounterID(const Counter &C) const {
   struct StackElem {
     Counter ICounter;
     int64_t LHS = 0;
     enum {
       KNeverVisited = 0,
       KVisitedOnce = 1,
       KVisitedTwice = 2,
static unsigned getMaxCounterID(const CounterMappingContext &Ctx,
                                 const CoverageMappingRecord &Record) {
   unsigned MaxCounterID = 0;
   for (const auto &Region : Record.MappingRegions) {
     MaxCounterID = std::max(MaxCounterID, Ctx.getMaxCounterID(Region.Count));
   }
   return MaxCounterID;
 }
 
+static unsigned getMaxBitmapSize(const CounterMappingContext &Ctx,
+                                 const CoverageMappingRecord &Record) {
+  unsigned MaxBitmapID = 0;
+  unsigned NumConditions = 0;
+  // The last DecisionRegion has the highest bitmap byte index used in the
+  // function, which when combined with its number of conditions, yields the
+  // full bitmap size.
+  for (const auto &Region : reverse(Record.MappingRegions)) {
+    if (Region.Kind == CounterMappingRegion::MCDCDecisionRegion) {
+      MaxBitmapID = Region.MCDCParams.BitmapIdx;
+      NumConditions = Region.MCDCParams.NumConditions;
+      break;
+    }
+  }
+  unsigned SizeInBits = llvm::alignTo(uint64_t(1) << NumConditions, CHAR_BIT);
+  return MaxBitmapID + (SizeInBits / CHAR_BIT);
+}
+
 Error CoverageMapping::loadFunctionRecord(
     const CoverageMappingRecord &Record,
     IndexedInstrProfReader &ProfileReader) {
   StringRef OrigFuncName = Record.FunctionName;
   if (OrigFuncName.empty())
     return make_error<CoverageMapError>(coveragemap_error::malformed,
                                         "record function name is empty");
 
   if (Record.Filenames.empty())
     OrigFuncName = getFuncNameWithoutPrefix(OrigFuncName);
   else
     OrigFuncName = getFuncNameWithoutPrefix(OrigFuncName, Record.Filenames[0]);
 
   CounterMappingContext Ctx(Record.Expressions);
 
   std::vector<uint64_t> Counts;
   if (Error E = ProfileReader.getFunctionCounts(Record.FunctionName,
                                                 Record.FunctionHash, Counts)) {
     instrprof_error IPE = std::get<0>(InstrProfError::take(std::move(E)));
     if (IPE == instrprof_error::hash_mismatch) {
       FuncHashMismatches.emplace_back(std::string(Record.FunctionName),
                                       Record.FunctionHash);
       return Error::success();
-    } else if (IPE != instrprof_error::unknown_function)
+    }
+    if (IPE != instrprof_error::unknown_function)
       return make_error<InstrProfError>(IPE);
     Counts.assign(getMaxCounterID(Ctx, Record) + 1, 0);
   }
   Ctx.setCounts(Counts);
 
+  std::vector<uint8_t> BitmapBytes;
+  if (Error E = ProfileReader.getFunctionBitmapBytes(
+          Record.FunctionName, Record.FunctionHash, BitmapBytes)) {
+    instrprof_error IPE = std::get<0>(InstrProfError::take(std::move(E)));
+    if (IPE == instrprof_error::hash_mismatch) {
+      FuncHashMismatches.emplace_back(std::string(Record.FunctionName),
+                                      Record.FunctionHash);
+      return Error::success();
+    }
+    if (IPE != instrprof_error::unknown_function)
+      return make_error<InstrProfError>(IPE);
+    BitmapBytes.assign(getMaxBitmapSize(Ctx, Record) + 1, 0);
+  }
+  Ctx.setBitmapBytes(BitmapBytes);
+
   assert(!Record.MappingRegions.empty() && "Function has no regions");
 
   // This coverage record is a zero region for a function that's unused in
   // some TU, but used in a different TU. Ignore it. The coverage maps from the
   // the other TU will either be loaded (providing full region counts) or they
   // won't (in which case we don't unintuitively report functions as uncovered
   // when they have non-zero counts in the profile).
   if (Record.MappingRegions.size() == 1 &&
       Record.MappingRegions[0].Count.isZero() && Counts[0] > 0)
     return Error::success();
 
+  unsigned NumConds = 0;
+  const CounterMappingRegion *MCDCDecision;
+  std::vector<CounterMappingRegion> MCDCBranches;
+
   FunctionRecord Function(OrigFuncName, Record.Filenames);
   for (const auto &Region : Record.MappingRegions) {
+    // If an MCDCDecisionRegion is seen, track the BranchRegions that follow
+    // it according to Region.NumConditions.
+    if (Region.Kind == CounterMappingRegion::MCDCDecisionRegion) {
+      assert(NumConds == 0);
+      MCDCDecision = &Region;
+      NumConds = Region.MCDCParams.NumConditions;
+      continue;
+    }
     Expected<int64_t> ExecutionCount = Ctx.evaluate(Region.Count);
     if (auto E = ExecutionCount.takeError()) {
       consumeError(std::move(E));
       return Error::success();
     }
     Expected<int64_t> AltExecutionCount = Ctx.evaluate(Region.FalseCount);
     if (auto E = AltExecutionCount.takeError()) {
       consumeError(std::move(E));
       return Error::success();
     }
     Function.pushRegion(Region, *ExecutionCount, *AltExecutionCount);
+
+    // If a MCDCDecisionRegion was seen, store the BranchRegions that
+    // correspond to it in a vector, according to the number of conditions
+    // recorded for the region (tracked by NumConds).
+    if (NumConds > 0 && Region.Kind == CounterMappingRegion::MCDCBranchRegion) {
+      MCDCBranches.push_back(Region);
+
+      // As we move through all of the MCDCBranchRegions that follow the
+      // MCDCDecisionRegion, decrement NumConds to make sure we account for
+      // them all before we calculate the bitmap of executed test vectors.
+      if (--NumConds == 0) {
+        // Evaluating the test vector bitmap for the decision region entails
+        // calculating precisely what bits are pertinent to this region alone.
+        // This is calculated based on the recorded offset into the global
+        // profile bitmap; the length is calculated based on the recorded
+        // number of conditions.
+        Expected<BitVector> ExecutedTestVectorBitmap =
+            Ctx.evaluateBitmap(MCDCDecision);
+        if (auto E = ExecutedTestVectorBitmap.takeError()) {
+          consumeError(std::move(E));
+          return Error::success();
+        }
+
+        // Since the bitmap identifies the executed test vectors for an MC/DC
+        // DecisionRegion, all of the information is now available to process.
+        // This is where the bulk of the MC/DC progressing takes place.
+        Expected<MCDCRecord> Record = Ctx.evaluateMCDCRegion(
+            *MCDCDecision, *ExecutedTestVectorBitmap, MCDCBranches);
+        if (auto E = Record.takeError()) {
+          consumeError(std::move(E));
+          return Error::success();
+        }
+
+        // Save the MC/DC Record so that it can be visualized later.
+        Function.pushMCDCRecord(*Record);
+        MCDCBranches.clear();
+      }
+    }
   }
 
   // Don't create records for (filenames, function) pairs we've already seen.
   auto FilenamesHash = hash_combine_range(Record.Filenames.begin(),
                                           Record.Filenames.end());
   if (!RecordProvenance[FilenamesHash].insert(hash_value(OrigFuncName)).second)
     return Error::success();
 
for (const auto &CR : Function.CountedRegions)
         Regions.push_back(CR);
         if (MainFileID && isExpansion(CR, *MainFileID))
           FileCoverage.Expansions.emplace_back(CR, Function);
       }
     // Capture branch regions specific to the function (excluding expansions).
     for (const auto &CR : Function.CountedBranchRegions)
       if (FileIDs.test(CR.FileID) && (CR.FileID == CR.ExpandedFileID))
         FileCoverage.BranchRegions.push_back(CR);
+    // Capture MCDC records specific to the function.
+    for (const auto &MR : Function.MCDCRecords)
+      if (FileIDs.test(MR.getDecisionRegion().FileID))
+        FileCoverage.MCDCRecords.push_back(MR);
   }
 
   LLVM_DEBUG(dbgs() << "Emitting segments for file: " << Filename << "\n");
   FileCoverage.Segments = SegmentBuilder::buildSegments(Regions);
 
   return FileCoverage;
 }
 
if (CR.FileID == *MainFileID) {
       if (isExpansion(CR, *MainFileID))
         FunctionCoverage.Expansions.emplace_back(CR, Function);
     }
   // Capture branch regions specific to the function (excluding expansions).
   for (const auto &CR : Function.CountedBranchRegions)
     if (CR.FileID == *MainFileID)
       FunctionCoverage.BranchRegions.push_back(CR);
 
+  // Capture MCDC records specific to the function.
+  for (const auto &MR : Function.MCDCRecords)
+    if (MR.getDecisionRegion().FileID == *MainFileID)
+      FunctionCoverage.MCDCRecords.push_back(MR);
+
   LLVM_DEBUG(dbgs() << "Emitting segments for function: " << Function.Name
                     << "\n");
   FunctionCoverage.Segments = SegmentBuilder::buildSegments(Regions);
 
   return FunctionCoverage;
 }
 
 CoverageData CoverageMapping::getCoverageForExpansion(

llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp

Error RawCoverageMappingReader::readMappingRegionsSubArray(
     std::vector<CounterMappingRegion> &MappingRegions, unsigned InferredFileID,
     size_t NumFileIDs) {
   uint64_t NumRegions;
   if (auto Err = readSize(NumRegions))
     return Err;
   unsigned LineStart = 0;
   for (size_t I = 0; I < NumRegions; ++I) {
     Counter C, C2;
+    uint64_t BIDX = 0, NC = 0, ID = 0, TID = 0, FID = 0;
     CounterMappingRegion::RegionKind Kind = CounterMappingRegion::CodeRegion;
 
     // Read the combined counter + region kind.
     uint64_t EncodedCounterAndRegion;
     if (auto Err = readIntMax(EncodedCounterAndRegion,
                               std::numeric_limits<unsigned>::max()))
       return Err;
     unsigned Tag = EncodedCounterAndRegion & Counter::EncodingTagMask;
if (Tag != Counter::Zero) {
         case CounterMappingRegion::BranchRegion:
           // For a Branch Region, read two successive counters.
           Kind = CounterMappingRegion::BranchRegion;
           if (auto Err = readCounter(C))
             return Err;
           if (auto Err = readCounter(C2))
             return Err;
           break;
+        case CounterMappingRegion::MCDCBranchRegion:
+          // For a MCDC Branch Region, read two successive counters and 3 IDs.
+          Kind = CounterMappingRegion::MCDCBranchRegion;
+          if (auto Err = readCounter(C))
+            return Err;
+          if (auto Err = readCounter(C2))
+            return Err;
+          if (auto Err = readIntMax(ID, std::numeric_limits<unsigned>::max()))
+            return Err;
+          if (auto Err = readIntMax(TID, std::numeric_limits<unsigned>::max()))
+            return Err;
+          if (auto Err = readIntMax(FID, std::numeric_limits<unsigned>::max()))
+            return Err;
+          break;
+        case CounterMappingRegion::MCDCDecisionRegion:
+          Kind = CounterMappingRegion::MCDCDecisionRegion;
+          if (auto Err = readIntMax(BIDX, std::numeric_limits<unsigned>::max()))
+            return Err;
+          if (auto Err = readIntMax(NC, std::numeric_limits<unsigned>::max()))
+            return Err;
+          break;
         default:
           return make_error<CoverageMapError>(coveragemap_error::malformed,
                                               "region kind is incorrect");
         }
       }
     }
 
     // Read the source range.
LLVM_DEBUG({
              << ColumnEnd << ", ";
       if (Kind == CounterMappingRegion::ExpansionRegion)
         dbgs() << "Expands to file " << ExpandedFileID;
       else
         CounterMappingContext(Expressions).dump(C, dbgs());
       dbgs() << "\n";
     });
 
-    auto CMR = CounterMappingRegion(C, C2, InferredFileID, ExpandedFileID,
-                                    LineStart, ColumnStart,
-                                    LineStart + NumLines, ColumnEnd, Kind);
+    auto CMR = CounterMappingRegion(
+        C, C2,
+        CounterMappingRegion::MCDCParameters{
+            static_cast<unsigned>(BIDX), static_cast<unsigned>(NC),
+            static_cast<unsigned>(ID), static_cast<unsigned>(TID),
+            static_cast<unsigned>(FID)},
+        InferredFileID, ExpandedFileID, LineStart, ColumnStart,
     if (CMR.startLoc() > CMR.endLoc())
       return make_error<CoverageMapError>(
           coveragemap_error::malformed,
           "counter mapping region locations are incorrect");
     MappingRegions.push_back(CMR);
   }
   return Error::success();
 }

llvm/lib/ProfileData/Coverage/CoverageMappingWriter.cpp

case CounterMappingRegion::SkippedRegion:
       break;
     case CounterMappingRegion::BranchRegion:
       encodeULEB128(unsigned(I->Kind)
                         << Counter::EncodingCounterTagAndExpansionRegionTagBits,
                     OS);
       writeCounter(MinExpressions, Count, OS);
       writeCounter(MinExpressions, FalseCount, OS);
       break;
+    case CounterMappingRegion::MCDCBranchRegion:
+      encodeULEB128(unsigned(I->Kind)
+                        << Counter::EncodingCounterTagAndExpansionRegionTagBits,
+                    OS);
+      writeCounter(MinExpressions, Count, OS);
+      writeCounter(MinExpressions, FalseCount, OS);
+      encodeULEB128(unsigned(I->MCDCParams.ID), OS);
+      encodeULEB128(unsigned(I->MCDCParams.TrueID), OS);
+      encodeULEB128(unsigned(I->MCDCParams.FalseID), OS);
+      break;
+    case CounterMappingRegion::MCDCDecisionRegion:
+      encodeULEB128(unsigned(I->Kind)
+                        << Counter::EncodingCounterTagAndExpansionRegionTagBits,
+                    OS);
+      encodeULEB128(unsigned(I->MCDCParams.BitmapIdx), OS);
+      encodeULEB128(unsigned(I->MCDCParams.NumConditions), OS);
+      break;
     }
     assert(I->LineStart >= PrevLineStart);
     encodeULEB128(I->LineStart - PrevLineStart, OS);
     encodeULEB128(I->ColumnStart, OS);
     assert(I->LineEnd >= I->LineStart);
     encodeULEB128(I->LineEnd - I->LineStart, OS);
     encodeULEB128(I->ColumnEnd, OS);
     PrevLineStart = I->LineStart;

llvm/test/tools/llvm-cov/Inputs/binary-formats.canonical.json

-CHECK: {"data":
-CHECK-SAME: [{
+CHECK: {
+  "data": CHECK - SAME: [
+    {
 CHECK-SAME:  "files":[
 CHECK-SAME:    {"branches":[],
 CHECK-SAME:     "expansions":[],
 CHECK-SAME:     "filename":"/tmp/binary-formats.c",
+CHECK-SAME:     "mcdc_records":[],
 CHECK-SAME:     "segments":
 CHECK-SAME:        4,40,100,true,true,false
 CHECK-SAME:        4,42,0,false,false,false
 CHECK-SAME:     "summary":{"branches":{"count":0,"covered":0,"notcovered":0,"percent":0},
 CHECK-SAME:                "functions":{"count":1,"covered":1,"percent":100},
 CHECK-SAME:                "instantiations":{"count":1,"covered":1,"percent":100},
 CHECK-SAME:                "lines":{"count":1,"covered":1,"percent":100},
+CHECK-SAME:                "mcdc":{"count":0,"covered":0,"notcovered":0,"percent":0},
 CHECK-SAME:                "regions":{"count":1,"covered":1,"notcovered":0,"percent":100}}}
 CHECK-SAME:  ],
 CHECK-SAME:  "functions":[
 CHECK-SAME:    {"branches":[],
-CHECK-SAME:     "count":100,"filenames":["/tmp/binary-formats.c"],"name":"main",
+CHECK-SAME:     "count":100,"filenames":["/tmp/binary-formats.c"],
+CHECK-SAME:     "mcdc_records":[],"name":"main",
 CHECK-SAME:     "regions":
 CHECK-SAME:        4,40,4,42,100,0,0,0
 CHECK-SAME:    }
 CHECK-SAME:  ],
 CHECK-SAME:  "totals":
 CHECK-SAME:    {"branches":{"count":0,"covered":0,"notcovered":0,"percent":0},
 CHECK-SAME:     "functions":{"count":1,"covered":1,"percent":100},
 CHECK-SAME:     "instantiations":{"count":1,"covered":1,"percent":100},
 CHECK-SAME:     "lines":{"count":1,"covered":1,"percent":100},
+CHECk-SAME:     "mcdc":{"count":0,"covered":0,"notcovered":0,"percent":0},
 CHECK-SAME:     "regions":{"count":1,"covered":1,"notcovered":0,"percent":100}}}
 CHECK-SAME: ],
 CHECK-SAME: "type":"llvm.coverage.json.export"
 CHECK-SAME: "version":"2.0.1"

llvm/test/tools/llvm-cov/Inputs/mcdc-const-folding.cpp

+#include <stdlib.h>
+
+bool case0(bool a) {
+    return 0 && a;
+}
+bool case1(bool a) {
+    return a && 0;
+}
+bool case2(bool a) {
+    return 1 && a;
+}
+bool case3(bool a) {
+    return a && 1;
+}
+bool case4(bool a) {
+    return 1 || a;
+}
+bool case5(bool a) {
+    return a || 1;
+}
+bool case6(bool a) {
+    return 0 || a;
+}
+bool case7(bool a) {
+    return a || 0;
+}
+
+bool case8(bool a, bool b) {
+    return 0 && a && b;
+}
+bool case9(bool a, bool b) {
+    return a && 0 && b;
+}
+bool casea(bool a, bool b) {
+    return 1 && a && b;
+}
+bool caseb(bool a, bool b) {
+    return a && 1 && b;
+}
+bool casec(bool a, bool b) {
+    return 1 || a || b;
+}
+bool cased(bool a, bool b) {
+    return a || 1 || b;
+}
+bool casee(bool a, bool b) {
+    return 0 || a || b;
+}
+bool casef(bool a, bool b) {
+    return a || 0 || b;
+}
+
+bool caseg(bool a, bool b) {
+    return b && a && 0;
+}
+bool caseh(bool a, bool b) {
+    return b && 0 && a;
+}
+bool casei(bool a, bool b) {
+    return b && a && 1;
+}
+bool casej(bool a, bool b) {
+    return b && 1 && a;
+}
+bool casek(bool a, bool b) {
+    return b || a || 1;
+}
+bool casel(bool a, bool b) {
+    return b || 1 || a;
+}
+bool casem(bool a, bool b) {
+    return b || a || 0;
+}
+bool casen(bool a, bool b) {
+    return b || 0 || a;
+}
+
+extern "C" {
+  extern void __llvm_profile_write_file(void);
+}
+
+int main(int argc, char *argv[])
+{
+    bool a = atoi(argv[1]);
+    bool b = atoi(argv[2]);
+    volatile bool c;
+
+    c = case0(a);
+    c = case1(a);
+    c = case2(a);
+    c = case3(a);
+    c = case4(a);
+    c = case5(a);
+    c = case6(a);
+    c = case7(a);
+
+    c = case8(a, b);
+    c = case9(a, b);
+    c = casea(a, b);
+    c = caseb(a, b);
+    c = casec(a, b);
+    c = cased(a, b);
+    c = casee(a, b);
+    c = casef(a, b);
+
+    c = caseg(a, b);
+    c = caseh(a, b);
+    c = casei(a, b);
+    c = casej(a, b);
+    c = casek(a, b);
+    c = casel(a, b);
+    c = casem(a, b);
+    c = casen(a, b);
+
+    __llvm_profile_write_file();
+    return 0;
+}

llvm/test/tools/llvm-cov/Inputs/mcdc-const-folding.proftext

+_Z5case8bb
+# Func Hash:
+99214
+# Num Counters:
+5
+# Counter Values:
+4
+0
+0
+0
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x1
+
+
+_Z5case5b
+# Func Hash:
+1551
+# Num Counters:
+3
+# Counter Values:
+4
+1
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x6
+
+
+_Z5caseabb
+# Func Hash:
+99214
+# Num Counters:
+5
+# Counter Values:
+4
+3
+2
+4
+3
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0xa2
+
+
+_Z5case6b
+# Func Hash:
+1551
+# Num Counters:
+3
+# Counter Values:
+4
+4
+1
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x5
+
+
+_Z5casegbb
+# Func Hash:
+99214
+# Num Counters:
+5
+# Counter Values:
+4
+2
+0
+3
+2
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x23
+
+
+_Z5case1b
+# Func Hash:
+1550
+# Num Counters:
+3
+# Counter Values:
+4
+3
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x3
+
+
+_Z5case7b
+# Func Hash:
+1551
+# Num Counters:
+3
+# Counter Values:
+4
+1
+1
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x3
+
+
+_Z5casedbb
+# Func Hash:
+99279
+# Num Counters:
+5
+# Counter Values:
+4
+0
+0
+1
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x12
+
+
+_Z5casekbb
+# Func Hash:
+99279
+# Num Counters:
+5
+# Counter Values:
+4
+0
+0
+1
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x12
+
+
+_Z5casehbb
+# Func Hash:
+99214
+# Num Counters:
+5
+# Counter Values:
+4
+0
+0
+3
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x3
+
+
+_Z5case4b
+# Func Hash:
+1551
+# Num Counters:
+3
+# Counter Values:
+4
+0
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x2
+
+
+_Z5caseibb
+# Func Hash:
+99214
+# Num Counters:
+5
+# Counter Values:
+4
+2
+2
+3
+2
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x83
+
+
+_Z5case2b
+# Func Hash:
+1550
+# Num Counters:
+3
+# Counter Values:
+4
+4
+3
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0xa
+
+
+_Z5casefbb
+# Func Hash:
+99279
+# Num Counters:
+5
+# Counter Values:
+4
+1
+0
+1
+1
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x6
+
+
+_Z5caselbb
+# Func Hash:
+99279
+# Num Counters:
+5
+# Counter Values:
+4
+0
+0
+1
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x12
+
+
+_Z5casenbb
+# Func Hash:
+99279
+# Num Counters:
+5
+# Counter Values:
+4
+1
+0
+1
+1
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x6
+
+
+_Z5case9bb
+# Func Hash:
+99214
+# Num Counters:
+5
+# Counter Values:
+4
+0
+0
+3
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x3
+
+
+_Z5casecbb
+# Func Hash:
+99279
+# Num Counters:
+5
+# Counter Values:
+4
+0
+0
+0
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x2
+
+
+_Z5casebbb
+# Func Hash:
+99214
+# Num Counters:
+5
+# Counter Values:
+4
+3
+2
+3
+3
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0xa1
+
+
+_Z5case0b
+# Func Hash:
+1550
+# Num Counters:
+3
+# Counter Values:
+4
+0
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x1
+
+
+_Z5casejbb
+# Func Hash:
+99214
+# Num Counters:
+5
+# Counter Values:
+4
+3
+2
+3
+3
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0xa1
+
+
+_Z5caseebb
+# Func Hash:
+99279
+# Num Counters:
+5
+# Counter Values:
+4
+1
+0
+4
+1
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x14
+
+
+main
+# Func Hash:
+24
+# Num Counters:
+1
+# Counter Values:
+4
+
+_Z5case3b
+# Func Hash:
+1550
+# Num Counters:
+3
+# Counter Values:
+4
+3
+3
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x9
+
+
+_Z5casembb
+# Func Hash:
+99279
+# Num Counters:
+5
+# Counter Values:
+4
+0
+0
+1
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+0x12

llvm/test/tools/llvm-cov/Inputs/mcdc-const.cpp

+
+#include <stdio.h>
+
+extern "C" {
+extern void __llvm_profile_write_file(void);
+}
+
+extern int foo();
+
+void test(bool a, bool b, bool c, bool d) {
+
+  if ((a && 1) || (0 && d) || 0)
+    printf("test1 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);
+
+    __llvm_profile_write_file();
+    return 0;
+}

llvm/test/tools/llvm-cov/Inputs/mcdc-const.proftext

+main
+# Func Hash:
+24
+# Num Counters:
+1
+# Counter Values:
+1
+
+_Z4testbbbb
+# Func Hash:
[phone]
+# Num Counters:
+9
+# Counter Values:
+5
+4
+1
+1
+1
+4
+4
+0
+0
+# Num Bitmask Bytes:
+$4
+# Bitmask Byte Values:
+1
+2
+0
+0

llvm/test/tools/llvm-cov/Inputs/mcdc-general-none.proftext

+main
+# Func Hash:
+24
+# Num Counters:
+1
+# Counter Values:
+1
+
+_Z4testbbbb
+# Func Hash:
+9819241276358969079
+# Num Counters:
+19
+# Counter Values:
+7
+3
+5
+5
+2
+3
+1
+2
+3
+2
+1
+1
+1
+1
+2
+4
+2
+2
+1
+# Num Bitmask Bytes:
+$6
+# Bitmask Byte Values:
+0
+0
+0
+0
+0
+0

llvm/test/tools/llvm-cov/Inputs/mcdc-general.cpp

+
+#include <stdio.h>
+
+extern "C" {
+extern void __llvm_profile_write_file(void);
+}
+
+extern int foo();
+
+void test(bool a, bool b, bool c, bool d) {
+
+  if ((a && b) || (c && d))
+    printf("test1 decision true\n");
+
+  if (b && c) if (a && d)
+    printf("test2 decision true\n");
+
+  if ((c && d) &&
+      (a && b))
+    printf("test3 decision true\n");
+}
+
+int main()
+{
+    test(false,false,false,false);
+    test(true,false,true,false);
+    test(true,false,true,true);
+    test(true,true,false,false);
+
+    test(true,false,false,false);
+    test(true,true,true,true);
+    test(false,true,true,false);
+
+    __llvm_profile_write_file();
+    return 0;
+}

llvm/test/tools/llvm-cov/Inputs/mcdc-general.proftext

+main
+# Func Hash:
+24
+# Num Counters:
+1
+# Counter Values:
+1
+
+_Z4testbbbb
+# Func Hash:
+9819241276358969079
+# Num Counters:
+19
+# Counter Values:
+7
+3
+5
+5
+2
+3
+1
+2
+3
+2
+1
+1
+1
+1
+2
+4
+2
+2
+1
+# Num Bitmask Bytes:
+$6
+# Bitmask Byte Values:
+0x2f
+0x8
+0xb
+0x9
+0x83
+0x80

llvm/test/tools/llvm-cov/mcdc-const.test

+// Test visualization of MC/DC constructs for constant-folded condition masking.
+
+// RUN: llvm-profdata merge %S/Inputs/mcdc-const.proftext -o %t.profdata
+// RUN: llvm-cov show --show-branches=count --show-mcdc %S/Inputs/mcdc-const.o -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-const.cpp | FileCheck %s -check-prefix=CHECKGENERALCASE
+
+// CHECKGENERALCASE:  ------------------
+// CHECKGENERALCASE-NEXT:  |  Branch (12:8): [True: 4, False: 1]
+// CHECKGENERALCASE-NEXT:  |  Branch (12:13): [Folded - Ignored]
+// CHECKGENERALCASE-NEXT:  |  Branch (12:20): [Folded - Ignored]
+// CHECKGENERALCASE-NEXT:  |  Branch (12:25): [True: 0, False: 0]
+// CHECKGENERALCASE-NEXT:  |  Branch (12:31): [Folded - Ignored]
+// CHECKGENERALCASE-NEXT:  ------------------
+// CHECKGENERALCASE-NEXT:  |---> MC/DC Decision Region (12:7) to (12:32)
+// CHECKGENERALCASE-NEXT:  |
+// CHECKGENERALCASE-NEXT:  |  Number of Conditions: 5
+// CHECKGENERALCASE-NEXT:  |     Condition C1 --> (12:8)
+// CHECKGENERALCASE-NEXT:  |     Condition C2 --> (12:13)
+// CHECKGENERALCASE-NEXT:  |     Condition C3 --> (12:20)
+// CHECKGENERALCASE-NEXT:  |     Condition C4 --> (12:25)
+// CHECKGENERALCASE-NEXT:  |     Condition C5 --> (12:31)
+// CHECKGENERALCASE-NEXT:  |
+// CHECKGENERALCASE-NEXT:  |  Executed MC/DC Test Vectors:
+// CHECKGENERALCASE-NEXT:  |
+// CHECKGENERALCASE-NEXT:  |     C1, C2, C3, C4, C5    Result
+// CHECKGENERALCASE-NEXT:  |  1 { F,  C,  C,  -,  C  = F      }
+// CHECKGENERALCASE-NEXT:  |  2 { T,  C,  C,  -,  C  = T      }
+// CHECKGENERALCASE-NEXT:  |
+// CHECKGENERALCASE-NEXT:  |  C1-Pair: covered: (1,2)
+// CHECKGENERALCASE-NEXT:  |  C2-Pair: constant folded
+// CHECKGENERALCASE-NEXT:  |  C3-Pair: constant folded
+// CHECKGENERALCASE-NEXT:  |  C4-Pair: not covered
+// CHECKGENERALCASE-NEXT:  |  C5-Pair: constant folded
+// CHECKGENERALCASE-NEXT:  |  MC/DC Coverage for Decision: 50.00%
+// CHECKGENERALCASE-NEXT:  |
+// CHECKGENERALCASE-NEXT:  ------------------
+
+// RUN: llvm-profdata merge %S/Inputs/mcdc-const-folding.proftext -o %t.profdata
+// RUN: llvm-cov show --show-mcdc %S/Inputs/mcdc-const-folding.o -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-const-folding.cpp | FileCheck %s -check-prefix=CHECKFULLCASE
+// RUN: llvm-cov report --show-mcdc-summary %S/Inputs/mcdc-const-folding.o -instr-profile %t.profdata -show-functions -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-const-folding.cpp | FileCheck %s -check-prefix=REPORT
+
+// CHECKFULLCASE: |  1 { C,  -  = F      }
+// CHECKFULLCASE: |  C1-Pair: constant folded
+// CHECKFULLCASE-NEXT: |  C2-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { F,  C  = F      }
+// CHECKFULLCASE-NEXT: |  2 { T,  C  = F      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE-NEXT: |  C2-Pair: constant folded
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { C,  F  = F      }
+// CHECKFULLCASE-NEXT: |  2 { C,  T  = T      }
+// CHECKFULLCASE: |  C1-Pair: constant folded
+// CHECKFULLCASE-NEXT: |  C2-Pair: covered: (1,2)
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 100.00%
+// CHECKFULLCASE: |  1 { F,  C  = F      }
+// CHECKFULLCASE-NEXT: |  2 { T,  C  = T      }
+// CHECKFULLCASE: |  C1-Pair: covered: (1,2)
+// CHECKFULLCASE-NEXT: |  C2-Pair: constant folded
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 100.00%
+// CHECKFULLCASE: |  1 { C,  -  = T      }
+// CHECKFULLCASE: |  C1-Pair: constant folded
+// CHECKFULLCASE-NEXT: |  C2-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { T,  C  = T      }
+// CHECKFULLCASE-NEXT: |  2 { F,  C  = T      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE-NEXT: |  C2-Pair: constant folded
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { C,  F  = F      }
+// CHECKFULLCASE-NEXT: |  2 { C,  T  = T      }
+// CHECKFULLCASE: |  C1-Pair: constant folded
+// CHECKFULLCASE-NEXT: |  C2-Pair: covered: (1,2)
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 100.00%
+// CHECKFULLCASE: |  1 { F,  C  = F      }
+// CHECKFULLCASE-NEXT: |  2 { T,  C  = T      }
+// CHECKFULLCASE: |  C1-Pair: covered: (1,2)
+// CHECKFULLCASE-NEXT: |  C2-Pair: constant folded
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 100.00%
+// CHECKFULLCASE: |  1 { C,  -,  -  = F      }
+// CHECKFULLCASE: |  C1-Pair: constant folded
+// CHECKFULLCASE-NEXT: |  C2-Pair: not covered
+// CHECKFULLCASE-NEXT: |  C3-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { F,  C,  -  = F      }
+// CHECKFULLCASE-NEXT: |  2 { T,  C,  -  = F      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE-NEXT: |  C2-Pair: constant folded
+// CHECKFULLCASE-NEXT: |  C3-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { C,  F,  -  = F      }
+// CHECKFULLCASE-NEXT: |  2 { C,  T,  F  = F      }
+// CHECKFULLCASE-NEXT: |  3 { C,  T,  T  = T      }
+// CHECKFULLCASE: |  C1-Pair: constant folded
+// CHECKFULLCASE-NEXT: |  C2-Pair: covered: (1,3)
+// CHECKFULLCASE-NEXT: |  C3-Pair: covered: (2,3)
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 100.00%
+// CHECKFULLCASE: |  1 { F,  C,  -  = F      }
+// CHECKFULLCASE-NEXT: |  2 { T,  C,  F  = F      }
+// CHECKFULLCASE-NEXT: |  3 { T,  C,  T  = T      }
+// CHECKFULLCASE: |  C1-Pair: covered: (1,3)
+// CHECKFULLCASE-NEXT: |  C2-Pair: constant folded
+// CHECKFULLCASE-NEXT: |  C3-Pair: covered: (2,3)
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 100.00%
+// CHECKFULLCASE: |  1 { C,  -,  -  = T      }
+// CHECKFULLCASE: |  C1-Pair: constant folded
+// CHECKFULLCASE-NEXT: |  C2-Pair: not covered
+// CHECKFULLCASE-NEXT: |  C3-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { T,  C,  -  = T      }
+// CHECKFULLCASE-NEXT: |  2 { F,  C,  -  = T      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE-NEXT: |  C2-Pair: constant folded
+// CHECKFULLCASE-NEXT: |  C3-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { C,  F,  T  = T      }
+// CHECKFULLCASE-NEXT: |  2 { C,  T,  -  = T      }
+// CHECKFULLCASE: |  C1-Pair: constant folded
+// CHECKFULLCASE-NEXT: |  C2-Pair: not covered
+// CHECKFULLCASE-NEXT: |  C3-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { T,  C,  -  = T      }
+// CHECKFULLCASE-NEXT: |  2 { F,  C,  T  = T      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE-NEXT: |  C2-Pair: constant folded
+// CHECKFULLCASE-NEXT: |  C3-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { F,  -,  C  = F      }
+// CHECKFULLCASE-NEXT: |  2 { T,  F,  C  = F      }
+// CHECKFULLCASE-NEXT: |  3 { T,  T,  C  = F      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE-NEXT: |  C2-Pair: not covered
+// CHECKFULLCASE-NEXT: |  C3-Pair: constant folded
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { F,  C,  -  = F      }
+// CHECKFULLCASE-NEXT: |  2 { T,  C,  -  = F      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE-NEXT: |  C2-Pair: constant folded
+// CHECKFULLCASE-NEXT: |  C3-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { F,  -,  C  = F      }
+// CHECKFULLCASE-NEXT: |  2 { T,  F,  C  = F      }
+// CHECKFULLCASE-NEXT: |  3 { T,  T,  C  = T      }
+// CHECKFULLCASE: |  C1-Pair: covered: (1,3)
+// CHECKFULLCASE-NEXT: |  C2-Pair: covered: (2,3)
+// CHECKFULLCASE-NEXT: |  C3-Pair: constant folded
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 100.00%
+// CHECKFULLCASE: |  1 { F,  C,  -  = F      }
+// CHECKFULLCASE-NEXT: |  2 { T,  C,  F  = F      }
+// CHECKFULLCASE-NEXT: |  3 { T,  C,  T  = T      }
+// CHECKFULLCASE: |  C1-Pair: covered: (1,3)
+// CHECKFULLCASE-NEXT: |  C2-Pair: constant folded
+// CHECKFULLCASE-NEXT: |  C3-Pair: covered: (2,3)
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 100.00%
+// CHECKFULLCASE: |  1 { T,  -,  C  = T      }
+// CHECKFULLCASE-NEXT: |  2 { F,  T,  C  = T      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE-NEXT: |  C2-Pair: not covered
+// CHECKFULLCASE-NEXT: |  C3-Pair: constant folded
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { T,  C,  -  = T      }
+// CHECKFULLCASE-NEXT: |  2 { F,  C,  -  = T      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE-NEXT: |  C2-Pair: constant folded
+// CHECKFULLCASE-NEXT: |  C3-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { T,  -,  C  = T      }
+// CHECKFULLCASE-NEXT: |  2 { F,  T,  C  = T      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE-NEXT: |  C2-Pair: not covered
+// CHECKFULLCASE-NEXT: |  C3-Pair: constant folded
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { T,  C,  -  = T      }
+// CHECKFULLCASE-NEXT: |  2 { F,  C,  T  = T      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE-NEXT: |  C2-Pair: constant folded
+// CHECKFULLCASE-NEXT: |  C3-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+
+// REPORT: _Z5case0b {{.*}} 1       1   0.00%
+// REPORT-NEXT: _Z5case1b {{.*}} 1       1   0.00%
+// REPORT-NEXT: _Z5case2b {{.*}} 1       0 100.00%
+// REPORT-NEXT: _Z5case3b {{.*}} 1       0 100.00%
+// REPORT-NEXT: _Z5case4b {{.*}} 1       1   0.00%
+// REPORT-NEXT: _Z5case5b {{.*}} 1       1   0.00%
+// REPORT-NEXT: _Z5case6b {{.*}} 1       0 100.00%
+// REPORT-NEXT: _Z5case7b {{.*}} 1       0 100.00%
+// REPORT-NEXT: _Z5case8bb {{.*}} 2       2   0.00%
+// REPORT-NEXT: _Z5case9bb {{.*}} 2       2   0.00%
+// REPORT-NEXT: _Z5caseabb {{.*}} 2       0 100.00%
+// REPORT-NEXT: _Z5casebbb {{.*}} 2       0 100.00%
+// REPORT-NEXT: _Z5casecbb {{.*}} 2       2   0.00%
+// REPORT-NEXT: _Z5casedbb {{.*}} 2       2   0.00%
+// REPORT-NEXT: _Z5caseebb {{.*}} 2       2   0.00%
+// REPORT-NEXT: _Z5casefbb {{.*}} 2       2   0.00%
+// REPORT-NEXT: _Z5casegbb {{.*}} 2       2   0.00%
+// REPORT-NEXT: _Z5casehbb {{.*}} 2       2   0.00%
+// REPORT-NEXT: _Z5caseibb {{.*}} 2       0 100.00%
+// REPORT-NEXT: _Z5casejbb {{.*}} 2       0 100.00%
+// REPORT-NEXT: _Z5casekbb {{.*}} 2       2   0.00%
+// REPORT-NEXT: _Z5caselbb {{.*}} 2       2   0.00%
+// REPORT-NEXT: _Z5casembb {{.*}} 2       2   0.00%
+// REPORT-NEXT: _Z5casenbb {{.*}} 2       2   0.00%
+// REPORT: TOTAL {{.*}} 40      28  30.00%
+
+Instructions for regenerating the test:
+
+# cd %S/Inputs
+cp mcdc-const.cpp /tmp
+cp mcdc-const-folding.cpp /tmp
+
+clang -fcoverage-mcdc -fprofile-instr-generate -fcoverage-compilation-dir=. \
+    -fcoverage-mapping /tmp/mcdc-const.cpp -o /tmp/mcdc-const.o
+
+clang -fcoverage-mcdc -fprofile-instr-generate -fcoverage-compilation-dir=. \
+    -fcoverage-mapping /tmp/mcdc-const-folding.cpp -o /tmp/mcdc-const-folding.o
+
+mv /tmp/mcdc-const.o %S/Inputs
+mv /tmp/mcdc-const-folding.o %S/Inputs

llvm/test/tools/llvm-cov/mcdc-export-json.test

+// RUN: llvm-profdata merge %S/Inputs/mcdc-general.proftext -o %t.profdata
+// RUN: llvm-cov export --format=text %S/Inputs/mcdc-general.o -instr-profile %t.profdata | FileCheck %s
+
+// CHECK: 12,7,12,27,0,5,[true,true,true,true]
+// CHECK: 15,7,15,13,0,5,[true,true]
+// CHECK: 15,19,15,25,0,5,[true,false]
+// CHECK: 18,7,19,15,0,5,[true,true,false,true]
+// CHECK: "mcdc":{"count":12,"covered":10,"notcovered":2,"percent":83.333333333333343}
+
+Instructions for regenerating the test:
+
+# cd %S/Inputs
+cp mcdc-general.cpp /tmp
+
+clang -fcoverage-mcdc -fprofile-instr-generate -fcoverage-compilation-dir=. \
+    -fcoverage-mapping /tmp/mcdc-general.cpp -o /tmp/mcdc-const.o
+
+mv /tmp/mcdc-general.o %S/Inputs

llvm/test/tools/llvm-cov/mcdc-general-none.test

+// Test visualization of general MC/DC constructs with 0 executed test vectors.
+
+// RUN: llvm-profdata merge %S/Inputs/mcdc-general-none.proftext -o %t.profdata
+// RUN: llvm-cov show --show-mcdc %S/Inputs/mcdc-general.o -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s
+// RUN: llvm-cov report --show-mcdc-summary %S/Inputs/mcdc-general.o -instr-profile %t.profdata -show-functions -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s -check-prefix=REPORT
+
+// CHECK: test(bool
+
+// CHECK:  ------------------
+// CHECK-NEXT:  |---> MC/DC Decision Region (12:7) to (12:27)
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |  Number of Conditions: 4
+// CHECK-NEXT:  |     Condition C1 --> (12:8)
+// CHECK-NEXT:  |     Condition C2 --> (12:13)
+// CHECK-NEXT:  |     Condition C3 --> (12:20)
+// CHECK-NEXT:  |     Condition C4 --> (12:25)
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |  Executed MC/DC Test Vectors:
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |  None.
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |  C1-Pair: not covered
+// CHECK-NEXT:  |  C2-Pair: not covered
+// CHECK-NEXT:  |  C3-Pair: not covered
+// CHECK-NEXT:  |  C4-Pair: not covered
+// CHECK-NEXT:  |  MC/DC Coverage for Decision: 0.00%
+// CHECK-NEXT:  |
+// CHECK-NEXT:  ------------------
+
+
+// Turn off MC/DC visualization.
+// RUN: llvm-cov show %S/Inputs/mcdc-general.o -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s -check-prefix=NOMCDC
+// NOMCDC-NOT: MC/DC Decision Region
+
+// REPORT: Name                        Regions    Miss   Cover     Lines    Miss   Cover  Branches    Miss   Cover    MC/DC Conditions    Miss   Cover
+// REPORT-NEXT: -------------------------------------------------------------------------------------------------------------------------------------------
+// REPORT-NEXT: _Z4testbbbb                      25       0 100.00%         9       0 100.00%        24       2  91.67%                  12      12   0.00%
+// REPORT-NEXT: main                              1       0 100.00%        11       0 100.00%         0       0   0.00%                   0       0   0.00%
+// REPORT-NEXT: ---
+// REPORT-NEXT: TOTAL                            26       0 100.00%        20       0 100.00%        24       2  91.67%                  12      12   0.00%
+
+// Turn off MC/DC summary.
+// RUN: llvm-cov report %S/Inputs/mcdc-general.o -instr-profile %t.profdata -show-functions -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s -check-prefix=REPORT_NOMCDC
+// REPORT_NOMCDC-NOT: TOTAL{{.*}}12                   12    0.00%
+
+
+// Test file-level report.
+// RUN: llvm-cov report --show-mcdc-summary %S/Inputs/mcdc-general.o -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s -check-prefix=FILEREPORT
+// FILEREPORT: TOTAL{{.*}}12                   12    0.00%
+
+
+// Test html output.
+// RUN: llvm-cov show --show-mcdc-summary --show-mcdc %S/Inputs/mcdc-general.o -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp -format html -o %t.html.dir
+// RUN: FileCheck -check-prefix=HTML -input-file=%t.html.dir/coverage/tmp/mcdc-general.cpp.html %s
+// HTML-COUNT-4: MC/DC Decision Region (<span class='line-number'><a name='L{{[0-9]+}}' href='#L{{[0-9]+}}'><span>
+
+// RUN: FileCheck -check-prefix HTML-INDEX -input-file %t.html.dir/index.html %s
+// HTML-INDEX-LABEL: <table>
+// HTML-INDEX: <td class='column-entry-bold'>Filename</td>
+// HTML-INDEX: <td class='column-entry-bold'>Function Coverage</td>
+// HTML-INDEX: <td class='column-entry-bold'>Line Coverage</td>
+// HTML-INDEX: <td class='column-entry-bold'>Region Coverage</td>
+// HTML-INDEX: <td class='column-entry-bold'>Branch Coverage</td>
+// HTML-INDEX: <td class='column-entry-bold'>MC/DC</td>
+// HTML-INDEX: <a href='coverage{{.*}}mcdc-general.cpp.html'{{.*}}mcdc-general.cpp</a>
+// HTML-INDEX: <td class='column-entry-green'>
+// HTML-INDEX: 100.00% (2/2)
+// HTML-INDEX: 100.00% (20/20)
+// HTML-INDEX: 100.00% (26/26)
+// HTML-INDEX: 91.67% (22/24)
+// HTML-INDEX: 0.00% (0/12)
+// HTML-INDEX: Totals
+
+Instructions for regenerating the test:
+
+# cd %S/Inputs
+cp mcdc-general.cpp /tmp
+
+clang -fcoverage-mcdc -fprofile-instr-generate -fcoverage-compilation-dir=. \
+    -fcoverage-mapping /tmp/mcdc-general.cpp -o /tmp/mcdc-general.o
+
+mv /tmp/mcdc-general.o %S/Inputs

llvm/test/tools/llvm-cov/mcdc-general.test

+// Test visualization of general MC/DC constructs.
+
+// RUN: llvm-profdata merge %S/Inputs/mcdc-general.proftext -o %t.profdata
+// RUN: llvm-cov show --show-mcdc %S/Inputs/mcdc-general.o -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s
+// RUN: llvm-cov report --show-mcdc-summary %S/Inputs/mcdc-general.o -instr-profile %t.profdata -show-functions -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s -check-prefix=REPORT
+
+// CHECK: test(bool
+
+// CHECK:  ------------------
+// CHECK-NEXT:  |---> MC/DC Decision Region (12:7) to (12:27)
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |  Number of Conditions: 4
+// CHECK-NEXT:  |     Condition C1 --> (12:8)
+// CHECK-NEXT:  |     Condition C2 --> (12:13)
+// CHECK-NEXT:  |     Condition C3 --> (12:20)
+// CHECK-NEXT:  |     Condition C4 --> (12:25)
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |  Executed MC/DC Test Vectors:
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |     C1, C2, C3, C4    Result
+// CHECK-NEXT:  |  1 { F,  -,  F,  -  = F      }
+// CHECK-NEXT:  |  2 { T,  F,  F,  -  = F      }
+// CHECK-NEXT:  |  3 { F,  -,  T,  F  = F      }
+// CHECK-NEXT:  |  4 { T,  F,  T,  F  = F      }
+// CHECK-NEXT:  |  5 { T,  T,  -,  -  = T      }
+// CHECK-NEXT:  |  6 { T,  F,  T,  T  = T      }
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |  C1-Pair: covered: (1,5)
+// CHECK-NEXT:  |  C2-Pair: covered: (2,5)
+// CHECK-NEXT:  |  C3-Pair: covered: (2,6)
+// CHECK-NEXT:  |  C4-Pair: covered: (4,6)
+// CHECK-NEXT:  |  MC/DC Coverage for Decision: 100.00%
+// CHECK-NEXT:  |
+// CHECK-NEXT:  ------------------
+
+// CHECK:  ------------------
+// CHECK-NEXT:  |---> MC/DC Decision Region (15:7) to (15:13)
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |  Number of Conditions: 2
+// CHECK-NEXT:  |     Condition C1 --> (15:7)
+// CHECK-NEXT:  |     Condition C2 --> (15:12)
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |  Executed MC/DC Test Vectors:
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |     C1, C2    Result
+// CHECK-NEXT:  |  1 { F,  -  = F      }
+// CHECK-NEXT:  |  2 { T,  F  = F      }
+// CHECK-NEXT:  |  3 { T,  T  = T      }
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |  C1-Pair: covered: (1,3)
+// CHECK-NEXT:  |  C2-Pair: covered: (2,3)
+// CHECK-NEXT:  |  MC/DC Coverage for Decision: 100.00%
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |---> MC/DC Decision Region (15:19) to (15:25)
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |  Number of Conditions: 2
+// CHECK-NEXT:  |     Condition C1 --> (15:19)
+// CHECK-NEXT:  |     Condition C2 --> (15:24)
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |  Executed MC/DC Test Vectors:
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |     C1, C2    Result
+// CHECK-NEXT:  |  1 { F,  -  = F      }
+// CHECK-NEXT:  |  2 { T,  T  = T      }
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |  C1-Pair: covered: (1,2)
+// CHECK-NEXT:  |  C2-Pair: not covered
+// CHECK-NEXT:  |  MC/DC Coverage for Decision: 50.00%
+// CHECK-NEXT:  |
+// CHECK-NEXT:  ------------------
+
+// CHECK:  ------------------
+// CHECK-NEXT:  |---> MC/DC Decision Region (18:7) to (19:15)
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |  Number of Conditions: 4
+// CHECK-NEXT:  |     Condition C1 --> (18:8)
+// CHECK-NEXT:  |     Condition C2 --> (18:13)
+// CHECK-NEXT:  |     Condition C3 --> (19:8)
+// CHECK-NEXT:  |     Condition C4 --> (19:13)
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |  Executed MC/DC Test Vectors:
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |     C1, C2, C3, C4    Result
+// CHECK-NEXT:  |  1 { F,  -,  -,  -  = F      }
+// CHECK-NEXT:  |  2 { T,  F,  -,  -  = F      }
+// CHECK-NEXT:  |  3 { T,  T,  T,  F  = F      }
+// CHECK-NEXT:  |  4 { T,  T,  T,  T  = T      }
+// CHECK-NEXT:  |
+// CHECK-NEXT:  |  C1-Pair: covered: (1,4)
+// CHECK-NEXT:  |  C2-Pair: covered: (2,4)
+// CHECK-NEXT:  |  C3-Pair: not covered
+// CHECK-NEXT:  |  C4-Pair: covered: (3,4)
+// CHECK-NEXT:  |  MC/DC Coverage for Decision: 75.00%
+// CHECK-NEXT:  |
+// CHECK-NEXT:  ------------------
+
+// Turn off MC/DC visualization.
+// RUN: llvm-cov show %S/Inputs/mcdc-general.o -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s -check-prefix=NOMCDC
+// NOMCDC-NOT: MC/DC Decision Region
+
+// REPORT: Name                        Regions    Miss   Cover     Lines    Miss   Cover  Branches    Miss   Cover    MC/DC Conditions    Miss   Cover
+// REPORT-NEXT: -------------------------------------------------------------------------------------------------------------------------------------------
+// REPORT-NEXT: _Z4testbbbb                      25       0 100.00%         9       0 100.00%        24       2  91.67%                  12       2  83.33%
+// REPORT-NEXT: main                              1       0 100.00%        11       0 100.00%         0       0   0.00%                   0       0   0.00%
+// REPORT-NEXT: ---
+// REPORT-NEXT: TOTAL                            26       0 100.00%        20       0 100.00%        24       2  91.67%                  12       2  83.33%
+
+// Turn off MC/DC summary.
+// RUN: llvm-cov report %S/Inputs/mcdc-general.o -instr-profile %t.profdata -show-functions -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s -check-prefix=REPORT_NOMCDC
+// REPORT_NOMCDC-NOT: TOTAL{{.*}}12                    2    83.33%
+
+
+// Test file-level report.
+// RUN: llvm-cov report --show-mcdc-summary %S/Inputs/mcdc-general.o -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp | FileCheck %s -check-prefix=FILEREPORT
+// FILEREPORT: TOTAL{{.*}}12                    2    83.33%
+
+
+// Test html output.
+// RUN: llvm-cov show --show-mcdc-summary --show-mcdc %S/Inputs/mcdc-general.o -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs %S/Inputs/mcdc-general.cpp -format html -o %t.html.dir
+// RUN: FileCheck -check-prefix=HTML -input-file=%t.html.dir/coverage/tmp/mcdc-general.cpp.html %s
+// HTML-COUNT-4: MC/DC Decision Region (<span class='line-number'><a name='L{{[0-9]+}}' href='#L{{[0-9]+}}'><span>
+
+// RUN: FileCheck -check-prefix HTML-INDEX -input-file %t.html.dir/index.html %s
+// HTML-INDEX-LABEL: <table>
+// HTML-INDEX: <td class='column-entry-bold'>Filename</td>
+// HTML-INDEX: <td class='column-entry-bold'>Function Coverage</td>
+// HTML-INDEX: <td class='column-entry-bold'>Line Coverage</td>
+// HTML-INDEX: <td class='column-entry-bold'>Region Coverage</td>
+// HTML-INDEX: <td class='column-entry-bold'>Branch Coverage</td>
+// HTML-INDEX: <td class='column-entry-bold'>MC/DC</td>
+// HTML-INDEX: <a href='coverage{{.*}}mcdc-general.cpp.html'{{.*}}mcdc-general.cpp</a>
+// HTML-INDEX: <td class='column-entry-green'>
+// HTML-INDEX: 100.00% (2/2)
+// HTML-INDEX: 100.00% (20/20)
+// HTML-INDEX: 100.00% (26/26)
+// HTML-INDEX: 91.67% (22/24)
+// HTML-INDEX: 83.33% (10/12)
+// HTML-INDEX: Totals
+
+Instructions for regenerating the test:
+
+# cd %S/Inputs
+cp mcdc-general.cpp /tmp
+
+clang -fcoverage-mcdc -fprofile-instr-generate -fcoverage-compilation-dir=. \
+    -fcoverage-mapping /tmp/mcdc-general.cpp -o /tmp/mcdc-general.o
+
+mv /tmp/mcdc-general.o %S/Inputs

llvm/tools/llvm-cov/CodeCoverage.cpp

void attachExpansionSubViews(SourceCoverageView &View,
                                const CoverageMapping &Coverage);
 
   /// Create source views for the branches of the view.
   void attachBranchSubViews(SourceCoverageView &View, StringRef SourceName,
                             ArrayRef<CountedRegion> Branches,
                             const MemoryBuffer &File,
                             CoverageData &CoverageInfo);
 
+  /// Create source views for the MCDC records.
+  void attachMCDCSubViews(SourceCoverageView &View, StringRef SourceName,
+                          ArrayRef<MCDCRecord> MCDCRecords,
+                          const MemoryBuffer &File, CoverageData &CoverageInfo);
+
   /// Create the source view of a particular function.
   std::unique_ptr<SourceCoverageView>
   createFunctionView(const FunctionRecord &Function,
                      const CoverageMapping &Coverage);
 
   /// Create the main source view of a particular source file.
   std::unique_ptr<SourceCoverageView>
   createSourceFileView(StringRef SourceFile, const CoverageMapping &Coverage);
while (NextBranch != EndBranch) {
     if (!ViewBranches.empty()) {
       auto SubView = SourceCoverageView::create(SourceName, File, ViewOpts,
                                                 std::move(CoverageInfo));
       View.addBranch(CurrentLine, ViewBranches, std::move(SubView));
     }
   }
 }
 
+void CodeCoverageTool::attachMCDCSubViews(SourceCoverageView &View,
+                                          StringRef SourceName,
+                                          ArrayRef<MCDCRecord> MCDCRecords,
+                                          const MemoryBuffer &File,
+                                          CoverageData &CoverageInfo) {
+  if (!ViewOpts.ShowMCDC)
+    return;
+
+  const auto *NextRecord = MCDCRecords.begin();
+  const auto *EndRecord = MCDCRecords.end();
+
+  // Group and process MCDC records that have the same line number into the
+  // same subview.
+  while (NextRecord != EndRecord) {
+    std::vector<MCDCRecord> ViewMCDCRecords;
+    unsigned CurrentLine = NextRecord->getDecisionRegion().LineEnd;
+
+    while (NextRecord != EndRecord &&
+           CurrentLine == NextRecord->getDecisionRegion().LineEnd) {
+      ViewMCDCRecords.push_back(*NextRecord++);
+    }
+
+    if (ViewMCDCRecords.empty())
+      continue;
+
+    auto SubView = SourceCoverageView::create(SourceName, File, ViewOpts,
+                                              std::move(CoverageInfo));
+    View.addMCDCRecord(CurrentLine, ViewMCDCRecords, std::move(SubView));
+  }
+}
+
 std::unique_ptr<SourceCoverageView>
 CodeCoverageTool::createFunctionView(const FunctionRecord &Function,
                                      const CoverageMapping &Coverage) {
   auto FunctionCoverage = Coverage.getCoverageForFunction(Function);
   if (FunctionCoverage.empty())
     return nullptr;
   auto SourceBuffer = getSourceFile(FunctionCoverage.getFilename());
   if (!SourceBuffer)
     return nullptr;
 
   auto Branches = FunctionCoverage.getBranches();
   auto Expansions = FunctionCoverage.getExpansions();
+  auto MCDCRecords = FunctionCoverage.getMCDCRecords();
   auto View = SourceCoverageView::create(DC.demangle(Function.Name),
                                          SourceBuffer.get(), ViewOpts,
                                          std::move(FunctionCoverage));
   attachExpansionSubViews(*View, Expansions, Coverage);
   attachBranchSubViews(*View, DC.demangle(Function.Name), Branches,
                        SourceBuffer.get(), FunctionCoverage);
+  attachMCDCSubViews(*View, DC.demangle(Function.Name), MCDCRecords,
+                     SourceBuffer.get(), FunctionCoverage);
 
   return View;
 }
 
 std::unique_ptr<SourceCoverageView>
 CodeCoverageTool::createSourceFileView(StringRef SourceFile,
                                        const CoverageMapping &Coverage) {
   auto SourceBuffer = getSourceFile(SourceFile);
   if (!SourceBuffer)
     return nullptr;
   auto FileCoverage = Coverage.getCoverageForFile(SourceFile);
   if (FileCoverage.empty())
     return nullptr;
 
   auto Branches = FileCoverage.getBranches();
   auto Expansions = FileCoverage.getExpansions();
+  auto MCDCRecords = FileCoverage.getMCDCRecords();
   auto View = SourceCoverageView::create(SourceFile, SourceBuffer.get(),
                                          ViewOpts, std::move(FileCoverage));
   attachExpansionSubViews(*View, Expansions, Coverage);
   attachBranchSubViews(*View, SourceFile, Branches, SourceBuffer.get(),
                        FileCoverage);
+  attachMCDCSubViews(*View, SourceFile, MCDCRecords, SourceBuffer.get(),
+                     FileCoverage);
   if (!ViewOpts.ShowFunctionInstantiations)
     return View;
 
   for (const auto &Group : Coverage.getInstantiationGroups(SourceFile)) {
     // Skip functions which have a single instantiation.
     if (Group.size() < 2)
       continue;
 
     for (const FunctionRecord *Function : Group.getInstantiations()) {
       std::unique_ptr<SourceCoverageView> SubView{nullptr};
 
       StringRef Funcname = DC.demangle(Function->Name);
 
       if (Function->ExecutionCount > 0) {
         auto SubViewCoverage = Coverage.getCoverageForFunction(*Function);
         auto SubViewExpansions = SubViewCoverage.getExpansions();
         auto SubViewBranches = SubViewCoverage.getBranches();
+        auto SubViewMCDCRecords = SubViewCoverage.getMCDCRecords();
         SubView = SourceCoverageView::create(
             Funcname, SourceBuffer.get(), ViewOpts, std::move(SubViewCoverage));
         attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
         attachBranchSubViews(*SubView, SourceFile, SubViewBranches,
                              SourceBuffer.get(), SubViewCoverage);
+        attachMCDCSubViews(*SubView, SourceFile, SubViewMCDCRecords,
+                           SourceBuffer.get(), SubViewCoverage);
       }
 
       unsigned FileID = Function->CountedRegions.front().FileID;
       unsigned Line = 0;
       for (const auto &CR : Function->CountedRegions)
         if (CR.FileID == FileID)
           Line = std::max(CR.LineEnd, Line);
       View->addInstantiation(Funcname, Line, std::move(SubView));
cl::opt<bool> RegionSummary(
       cl::desc("Show region statistics in summary table"),
       cl::init(true));
 
   cl::opt<bool> BranchSummary(
       "show-branch-summary", cl::Optional,
       cl::desc("Show branch condition statistics in summary table"),
       cl::init(true));
 
+  cl::opt<bool> MCDCSummary("show-mcdc-summary", cl::Optional,
+                            cl::desc("Show MCDC statistics in summary table"),
+                            cl::init(false));
+
   cl::opt<bool> InstantiationSummary(
       "show-instantiation-summary", cl::Optional,
       cl::desc("Show instantiation statistics in summary table"));
 
   cl::opt<bool> SummaryOnly(
       "summary-only", cl::Optional,
       cl::desc("Export only summary information for each source file"));
 
for (const std::string &File : InputSourceFiles)
       collectPaths(File);
 
     if (DebugDumpCollectedPaths) {
       for (const std::string &SF : SourceFiles)
         outs() << SF << '\n';
       ::exit(0);
     }
 
+    ViewOpts.ShowMCDCSummary = MCDCSummary;
     ViewOpts.ShowBranchSummary = BranchSummary;
     ViewOpts.ShowRegionSummary = RegionSummary;
     ViewOpts.ShowInstantiationSummary = InstantiationSummary;
     ViewOpts.ExportSummaryOnly = SummaryOnly;
     ViewOpts.NumThreads = NumThreads;
     ViewOpts.CompilationDirectory = CompilationDirectory;
 
     return 0;
cl::opt<CoverageViewOptions::BranchOutputType> ShowBranches(
       "show-branches", cl::Optional,
       cl::desc("Show coverage for branch conditions"), cl::cat(ViewCategory),
       cl::values(clEnumValN(CoverageViewOptions::BranchOutputType::Count,
                             "count", "Show True/False counts"),
                  clEnumValN(CoverageViewOptions::BranchOutputType::Percent,
                             "percent", "Show True/False percent")),
       cl::init(CoverageViewOptions::BranchOutputType::Off));
 
+  cl::opt<bool> ShowMCDC(
+      "show-mcdc", cl::Optional,
+      cl::desc("Show the MCDC Coverage for each applicable boolean expression"),
+      cl::cat(ViewCategory));
+
   cl::opt<bool> ShowBestLineRegionsCounts(
       "show-line-counts-or-regions", cl::Optional,
       cl::desc("Show the execution counts for each line, or the execution "
                "counts for each region on lines that have multiple regions"),
       cl::cat(ViewCategory));
 
   cl::opt<bool> ShowExpansions("show-expansions", cl::Optional,
                                cl::desc("Show expanded source regions"),
int CodeCoverageTool::doShow(int argc, const char **argv,
 
   ViewOpts.ShowLineNumbers = true;
   ViewOpts.ShowLineStats = ShowLineExecutionCounts.getNumOccurrences() != 0 ||
                            !ShowRegions || ShowBestLineRegionsCounts;
   ViewOpts.ShowRegionMarkers = ShowRegions || ShowBestLineRegionsCounts;
   ViewOpts.ShowExpandedRegions = ShowExpansions;
   ViewOpts.ShowBranchCounts =
       ShowBranches == CoverageViewOptions::BranchOutputType::Count;
+  ViewOpts.ShowMCDC = ShowMCDC;
   ViewOpts.ShowBranchPercents =
       ShowBranches == CoverageViewOptions::BranchOutputType::Percent;
   ViewOpts.ShowFunctionInstantiations = ShowInstantiations;
   ViewOpts.ShowDirectoryCoverage = ShowDirectoryCoverage;
   ViewOpts.ShowOutputDirectory = ShowOutputDirectory;
   ViewOpts.TabSize = TabSize;
   ViewOpts.ProjectTitle = ProjectTitle;
 

llvm/tools/llvm-cov/CoverageExporterJson.cpp

 // The json code coverage export follows the following format
 // Root: dict => Root Element containing metadata
 // -- Data: array => Homogeneous array of one or more export objects
 //   -- Export: dict => Json representation of one CoverageMapping
 //     -- Files: array => List of objects describing coverage for files
 //       -- File: dict => Coverage for a single file
 //         -- Branches: array => List of Branches in the file
 //           -- Branch: dict => Describes a branch of the file with counters
+//         -- MCDC Records: array => List of MCDC records in the file
+//           -- MCDC Values: array => List of T/F covered condition values
 //         -- Segments: array => List of Segments contained in the file
 //           -- Segment: dict => Describes a segment of the file with a counter
 //         -- Expansions: array => List of expansion records
 //           -- Expansion: dict => Object that descibes a single expansion
 //             -- CountedRegion: dict => The region to be expanded
 //             -- TargetRegions: array => List of Regions in the expansion
 //               -- CountedRegion: dict => Single Region in the expansion
 //             -- Branches: array => List of Branches in the expansion
 //               -- Branch: dict => Describes a branch in expansion and counters
 //         -- Summary: dict => Object summarizing the coverage for this file
 //           -- LineCoverage: dict => Object summarizing line coverage
 //           -- FunctionCoverage: dict => Object summarizing function coverage
 //           -- RegionCoverage: dict => Object summarizing region coverage
 //           -- BranchCoverage: dict => Object summarizing branch coverage
+//           -- MCDCCoverage: dict => Object summarizing MC/DC coverage
 //     -- Functions: array => List of objects describing coverage for functions
 //       -- Function: dict => Coverage info for a single function
 //         -- Filenames: array => List of filenames that the function relates to
 //   -- Summary: dict => Object summarizing the coverage for the entire binary
 //     -- LineCoverage: dict => Object summarizing line coverage
 //     -- FunctionCoverage: dict => Object summarizing function coverage
 //     -- InstantiationCoverage: dict => Object summarizing inst. coverage
 //     -- RegionCoverage: dict => Object summarizing region coverage
 //     -- BranchCoverage: dict => Object summarizing branch coverage
+//     -- MCDCCoverage: dict => Object summarizing MC/DC coverage
 //
 //===----------------------------------------------------------------------===//
 
 #include "CoverageExporterJson.h"
 #include "CoverageReport.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/ThreadPool.h"

 json::Array renderBranch(const coverage::CountedRegion &Region) {
   return json::Array(
       {Region.LineStart, Region.ColumnStart, Region.LineEnd, Region.ColumnEnd,
        clamp_uint64_to_int64(Region.ExecutionCount),
        clamp_uint64_to_int64(Region.FalseExecutionCount), Region.FileID,
        Region.ExpandedFileID, int64_t(Region.Kind)});
 }
 
+json::Array gatherConditions(const coverage::MCDCRecord &Record) {
+  json::Array Conditions;
+  for (unsigned c = 0; c < Record.getNumConditions(); c++)
+    Conditions.push_back(Record.isConditionIndependencePairCovered(c));
+  return Conditions;
+}
+
+json::Array renderMCDCRecord(const coverage::MCDCRecord &Record) {
+  const llvm::coverage::CounterMappingRegion &CMR = Record.getDecisionRegion();
+  return json::Array({CMR.LineStart, CMR.ColumnStart, CMR.LineEnd,
+                      CMR.ColumnEnd, CMR.ExpandedFileID, int64_t(CMR.Kind),
+                      gatherConditions(Record)});
+}
+
 json::Array renderRegions(ArrayRef<coverage::CountedRegion> Regions) {
   json::Array RegionArray;
   for (const auto &Region : Regions)
     RegionArray.push_back(renderRegion(Region));
   return RegionArray;
 }
 
 json::Array renderBranchRegions(ArrayRef<coverage::CountedRegion> Regions) {
   json::Array RegionArray;
   for (const auto &Region : Regions)
     if (!Region.Folded)
       RegionArray.push_back(renderBranch(Region));
   return RegionArray;
 }
 
+json::Array renderMCDCRecords(ArrayRef<coverage::MCDCRecord> Records) {
+  json::Array RecordArray;
+  for (auto &Record : Records)
+    RecordArray.push_back(renderMCDCRecord(Record));
+  return RecordArray;
+}
+
 std::vector<llvm::coverage::CountedRegion>
 collectNestedBranches(const coverage::CoverageMapping &Coverage,
                       ArrayRef<llvm::coverage::ExpansionRecord> Expansions) {
   std::vector<llvm::coverage::CountedRegion> Branches;
   for (const auto &Expansion : Expansions) {
     auto ExpansionCoverage = Coverage.getCoverageForExpansion(Expansion);
 
     // Recursively collect branches from nested expansions.
return json::Object(
                                     Summary.RegionCoverage.getCovered())},
              {"percent", Summary.RegionCoverage.getPercentCovered()}})},
        {"branches",
         json::Object(
             {{"count", int64_t(Summary.BranchCoverage.getNumBranches())},
              {"covered", int64_t(Summary.BranchCoverage.getCovered())},
              {"notcovered", int64_t(Summary.BranchCoverage.getNumBranches() -
                                     Summary.BranchCoverage.getCovered())},
-             {"percent", Summary.BranchCoverage.getPercentCovered()}})}});
+             {"percent", Summary.BranchCoverage.getPercentCovered()}})},
+       {"mcdc",
+        json::Object(
+            {{"count", int64_t(Summary.MCDCCoverage.getNumPairs())},
+             {"covered", int64_t(Summary.MCDCCoverage.getCoveredPairs())},
+             {"notcovered", int64_t(Summary.MCDCCoverage.getNumPairs() -
+                                    Summary.MCDCCoverage.getCoveredPairs())},
+             {"percent", Summary.MCDCCoverage.getPercentCovered()}})}});
 }
 
 json::Array renderFileExpansions(const coverage::CoverageMapping &Coverage,
                                  const coverage::CoverageData &FileCoverage,
                                  const FileCoverageSummary &FileReport) {
   json::Array ExpansionArray;
   for (const auto &Expansion : FileCoverage.getExpansions())
     ExpansionArray.push_back(renderExpansion(Coverage, Expansion));

 json::Array renderFileBranches(const coverage::CoverageData &FileCoverage,
                                const FileCoverageSummary &FileReport) {
   json::Array BranchArray;
   for (const auto &Branch : FileCoverage.getBranches())
     BranchArray.push_back(renderBranch(Branch));
   return BranchArray;
 }
 
+json::Array renderFileMCDC(const coverage::CoverageData &FileCoverage,
+                           const FileCoverageSummary &FileReport) {
+  json::Array MCDCRecordArray;
+  for (const auto &Record : FileCoverage.getMCDCRecords())
+    MCDCRecordArray.push_back(renderMCDCRecord(Record));
+  return MCDCRecordArray;
+}
+
 json::Object renderFile(const coverage::CoverageMapping &Coverage,
                         const std::string &Filename,
                         const FileCoverageSummary &FileReport,
                         const CoverageViewOptions &Options) {
   json::Object File({{"filename", Filename}});
   if (!Options.ExportSummaryOnly) {
     // Calculate and render detailed coverage information for given file.
     auto FileCoverage = Coverage.getCoverageForFile(Filename);
     File["segments"] = renderFileSegments(FileCoverage, FileReport);
     File["branches"] = renderFileBranches(FileCoverage, FileReport);
+    File["mcdc_records"] = renderFileMCDC(FileCoverage, FileReport);
     if (!Options.SkipExpansions) {
       File["expansions"] =
           renderFileExpansions(Coverage, FileCoverage, FileReport);
     }
   }
   File["summary"] = renderSummary(FileReport);
   return File;
 }
json::Array renderFunctions(
     const iterator_range<coverage::FunctionRecordIterator> &Functions) {
   json::Array FunctionArray;
   for (const auto &F : Functions)
     FunctionArray.push_back(
         json::Object({{"name", F.Name},
                       {"count", clamp_uint64_to_int64(F.ExecutionCount)},
                       {"regions", renderRegions(F.CountedRegions)},
                       {"branches", renderBranchRegions(F.CountedBranchRegions)},
+                      {"mcdc_records", renderMCDCRecords(F.MCDCRecords)},
                       {"filenames", json::Array(F.Filenames)}}));
   return FunctionArray;
 }
 
 } // end anonymous namespace
 
 void CoverageExporterJson::renderRoot(const CoverageFilters &IgnoreFilters) {
   std::vector<std::string> SourceFiles;

llvm/tools/llvm-cov/CoverageReport.cpp

 Column column(StringRef Str, unsigned Width) { return Column(Str, Width); }
 
 template <typename T>
 Column column(StringRef Str, unsigned Width, const T &Value) {
   return Column(Str, Width).set(Value);
 }
 
 // Specify the default column widths.
-size_t FileReportColumns[] = {25, 12, 18, 10, 12, 18, 10, 16,
-                              16, 10, 12, 18, 10, 12, 18, 10};
-size_t FunctionReportColumns[] = {25, 10, 8, 8, 10, 8, 8, 10, 8, 8};
+size_t FileReportColumns[] = {25, 12, 18, 10, 12, 18, 10, 16, 16, 10,
+                              12, 18, 10, 12, 18, 10, 20, 21, 10};
+size_t FunctionReportColumns[] = {25, 10, 8, 8, 10, 8, 8, 10, 8, 8, 20, 8, 8};
 
 /// Adjust column widths to fit long file paths and function names.
 void adjustColumnWidths(ArrayRef<StringRef> Files,
                         ArrayRef<StringRef> Functions) {
   for (StringRef Filename : Files)
     FileReportColumns[0] = std::max(FileReportColumns[0], Filename.size());
   for (StringRef Funcname : Functions)
     FunctionReportColumns[0] =
if (File.BranchCoverage.getNumBranches())
       Options.colored_ostream(OS, LineCoverageColor)
           << format("%*.2f", FileReportColumns[15] - 1,
                     File.BranchCoverage.getPercentCovered())
           << '%';
     else
       OS << column("-", FileReportColumns[15], Column::RightAlignment);
   }
 
+  if (Options.ShowMCDCSummary) {
+    OS << format("%*u", FileReportColumns[16],
+                 (unsigned)File.MCDCCoverage.getNumPairs());
+    Options.colored_ostream(OS, LineCoverageColor)
+        << format("%*u", FileReportColumns[17],
+                  (unsigned)(File.MCDCCoverage.getNumPairs() -
+                             File.MCDCCoverage.getCoveredPairs()));
+    if (File.MCDCCoverage.getNumPairs())
+      Options.colored_ostream(OS, LineCoverageColor)
+          << format("%*.2f", FileReportColumns[18] - 1,
+                    File.MCDCCoverage.getPercentCovered())
+          << '%';
+    else
+      OS << column("-", FileReportColumns[18], Column::RightAlignment);
+  }
+
   OS << "\n";
 }
 
 void CoverageReport::render(const FunctionCoverageSummary &Function,
                             const DemangleCache &DC,
                             raw_ostream &OS) const {
   auto FuncCoverageColor =
       determineCoveragePercentageColor(Function.RegionCoverage);
Options.colored_ostream(OS, LineCoverageColor)
                   (unsigned)(Function.BranchCoverage.getNumBranches() -
                              Function.BranchCoverage.getCovered()));
     Options.colored_ostream(
         OS, determineCoveragePercentageColor(Function.BranchCoverage))
         << format("%*.2f", FunctionReportColumns[9] - 1,
                   Function.BranchCoverage.getPercentCovered())
         << '%';
   }
+  if (Options.ShowMCDCSummary) {
+    OS << format("%*u", FunctionReportColumns[10],
+                 (unsigned)Function.MCDCCoverage.getNumPairs());
+    Options.colored_ostream(OS, LineCoverageColor)
+        << format("%*u", FunctionReportColumns[11],
+                  (unsigned)(Function.MCDCCoverage.getNumPairs() -
+                             Function.MCDCCoverage.getCoveredPairs()));
+    Options.colored_ostream(
+        OS, determineCoveragePercentageColor(Function.MCDCCoverage))
+        << format("%*.2f", FunctionReportColumns[12] - 1,
+                  Function.MCDCCoverage.getPercentCovered())
+        << '%';
+  }
   OS << "\n";
 }
 
 void CoverageReport::renderFunctionReports(ArrayRef<std::string> Files,
                                            const DemangleCache &DC,
                                            raw_ostream &OS) {
   bool isFirst = true;
   for (StringRef Filename : Files) {
OS << column("Name", FunctionReportColumns[0])
        << column("Cover", FunctionReportColumns[3], Column::RightAlignment)
        << column("Lines", FunctionReportColumns[4], Column::RightAlignment)
        << column("Miss", FunctionReportColumns[5], Column::RightAlignment)
        << column("Cover", FunctionReportColumns[6], Column::RightAlignment);
     if (Options.ShowBranchSummary)
       OS << column("Branches", FunctionReportColumns[7], Column::RightAlignment)
          << column("Miss", FunctionReportColumns[8], Column::RightAlignment)
          << column("Cover", FunctionReportColumns[9], Column::RightAlignment);
+    if (Options.ShowMCDCSummary)
+      OS << column("MC/DC Conditions", FunctionReportColumns[10],
+                   Column::RightAlignment)
+         << column("Miss", FunctionReportColumns[11], Column::RightAlignment)
+         << column("Cover", FunctionReportColumns[12], Column::RightAlignment);
     OS << "\n";
     renderDivider(FunctionReportColumns, OS);
     OS << "\n";
     FunctionCoverageSummary Totals("TOTAL");
     for (const auto &F : Functions) {
       auto Function = FunctionCoverageSummary::get(Coverage, F);
       ++Totals.ExecutionCount;
       Totals.RegionCoverage += Function.RegionCoverage;
       Totals.LineCoverage += Function.LineCoverage;
       Totals.BranchCoverage += Function.BranchCoverage;
+      Totals.MCDCCoverage += Function.MCDCCoverage;
       render(Function, DC, OS);
     }
     if (Totals.ExecutionCount) {
       renderDivider(FunctionReportColumns, OS);
       OS << "\n";
       render(Totals, DC, OS);
     }
   }
void CoverageReport::renderFileReports(
   OS << column("Lines", FileReportColumns[10], Column::RightAlignment)
      << column("Missed Lines", FileReportColumns[11], Column::RightAlignment)
      << column("Cover", FileReportColumns[12], Column::RightAlignment);
   if (Options.ShowBranchSummary)
     OS << column("Branches", FileReportColumns[13], Column::RightAlignment)
        << column("Missed Branches", FileReportColumns[14],
                  Column::RightAlignment)
        << column("Cover", FileReportColumns[15], Column::RightAlignment);
+  if (Options.ShowMCDCSummary)
+    OS << column("MC/DC Conditions", FileReportColumns[16],
+                 Column::RightAlignment)
+       << column("Missed Conditions", FileReportColumns[17],
+                 Column::RightAlignment)
+       << column("Cover", FileReportColumns[18], Column::RightAlignment);
   OS << "\n";
   renderDivider(FileReportColumns, OS);
   OS << "\n";
 
   std::vector<const FileCoverageSummary *> EmptyFiles;
   for (const FileCoverageSummary &FCS : FileReports) {
     if (FCS.FunctionCoverage.getNumFunctions())
       render(FCS, OS);

llvm/tools/llvm-cov/CoverageSummaryInfo.h

public:
   double getPercentCovered() const {
     assert(Covered <= NumBranches && "Covered branches over-counted");
     if (NumBranches == 0)
       return 0.0;
     return double(Covered) / double(NumBranches) * 100.0;
   }
 };
 
+/// Provides information about MC/DC coverage for a function/file.
+class MCDCCoverageInfo {
+  /// The number of Independence Pairs that were covered.
+  size_t CoveredPairs;
+
+  /// The total number of Independence Pairs in a function/file.
+  size_t NumPairs;
+
+public:
+  MCDCCoverageInfo() : CoveredPairs(0), NumPairs(0) {}
+
+  MCDCCoverageInfo(size_t CoveredPairs, size_t NumPairs)
+      : CoveredPairs(CoveredPairs), NumPairs(NumPairs) {
+    assert(CoveredPairs <= NumPairs && "Covered pairs over-counted");
+  }
+
+  MCDCCoverageInfo &operator+=(const MCDCCoverageInfo &RHS) {
+    CoveredPairs += RHS.CoveredPairs;
+    NumPairs += RHS.NumPairs;
+    return *this;
+  }
+
+  void merge(const MCDCCoverageInfo &RHS) {
+    CoveredPairs = std::max(CoveredPairs, RHS.CoveredPairs);
+    NumPairs = std::max(NumPairs, RHS.NumPairs);
+  }
+
+  size_t getCoveredPairs() const { return CoveredPairs; }
+
+  size_t getNumPairs() const { return NumPairs; }
+
+  bool isFullyCovered() const { return CoveredPairs == NumPairs; }
+
+  double getPercentCovered() const {
+    assert(CoveredPairs <= NumPairs && "Covered pairs over-counted");
+    if (NumPairs == 0)
+      return 0.0;
+    return double(CoveredPairs) / double(NumPairs) * 100.0;
+  }
+};
+
 /// Provides information about function coverage for a file.
 class FunctionCoverageInfo {
   /// The number of functions that were executed.
   size_t Executed;
 
   /// The total number of functions in this file.
   size_t NumFunctions;
 

 
 /// A summary of function's code coverage.
 struct FunctionCoverageSummary {
   std::string Name;
   uint64_t ExecutionCount;
   RegionCoverageInfo RegionCoverage;
   LineCoverageInfo LineCoverage;
   BranchCoverageInfo BranchCoverage;
+  MCDCCoverageInfo MCDCCoverage;
 
   FunctionCoverageSummary(const std::string &Name)
       : Name(Name), ExecutionCount(0) {}
 
   FunctionCoverageSummary(const std::string &Name, uint64_t ExecutionCount,
                           const RegionCoverageInfo &RegionCoverage,
                           const LineCoverageInfo &LineCoverage,
-                          const BranchCoverageInfo &BranchCoverage)
+                          const BranchCoverageInfo &BranchCoverage,
+                          const MCDCCoverageInfo &MCDCCoverage)
       : Name(Name), ExecutionCount(ExecutionCount),
         RegionCoverage(RegionCoverage), LineCoverage(LineCoverage),
-        BranchCoverage(BranchCoverage) {}
+        BranchCoverage(BranchCoverage), MCDCCoverage(MCDCCoverage) {}
 
   /// Compute the code coverage summary for the given function coverage
   /// mapping record.
   static FunctionCoverageSummary get(const coverage::CoverageMapping &CM,
                                      const coverage::FunctionRecord &Function);
 
   /// Compute the code coverage summary for an instantiation group \p Group,
   /// given a list of summaries for each instantiation in \p Summaries.
   static FunctionCoverageSummary
   get(const coverage::InstantiationGroup &Group,
       ArrayRef<FunctionCoverageSummary> Summaries);
 };
 
 /// A summary of file's code coverage.
 struct FileCoverageSummary {
   StringRef Name;
   RegionCoverageInfo RegionCoverage;
   LineCoverageInfo LineCoverage;
   BranchCoverageInfo BranchCoverage;
+  MCDCCoverageInfo MCDCCoverage;
   FunctionCoverageInfo FunctionCoverage;
   FunctionCoverageInfo InstantiationCoverage;
 
   FileCoverageSummary() = default;
   FileCoverageSummary(StringRef Name) : Name(Name) {}
 
   FileCoverageSummary &operator+=(const FileCoverageSummary &RHS) {
     RegionCoverage += RHS.RegionCoverage;
     LineCoverage += RHS.LineCoverage;
     FunctionCoverage += RHS.FunctionCoverage;
     BranchCoverage += RHS.BranchCoverage;
+    MCDCCoverage += RHS.MCDCCoverage;
     InstantiationCoverage += RHS.InstantiationCoverage;
     return *this;
   }
 
   void addFunction(const FunctionCoverageSummary &Function) {
     RegionCoverage += Function.RegionCoverage;
     LineCoverage += Function.LineCoverage;
     BranchCoverage += Function.BranchCoverage;
+    MCDCCoverage += Function.MCDCCoverage;
     FunctionCoverage.addFunction(/*Covered=*/Function.ExecutionCount > 0);
   }
 
   void addInstantiation(const FunctionCoverageSummary &Function) {
     InstantiationCoverage.addFunction(/*Covered=*/Function.ExecutionCount > 0);
   }
 };
 

llvm/tools/llvm-cov/CoverageSummaryInfo.cpp

static void sumBranchExpansions(size_t &NumBranches, size_t &CoveredBranches,
                                 ArrayRef<ExpansionRecord> Expansions) {
   for (const auto &Expansion : Expansions) {
     auto CE = CM.getCoverageForExpansion(Expansion);
     sumBranches(NumBranches, CoveredBranches, CE.getBranches());
     sumBranchExpansions(NumBranches, CoveredBranches, CM, CE.getExpansions());
   }
 }
 
+static std::pair<size_t, size_t>
+sumMCDCPairs(const ArrayRef<MCDCRecord> &Records) {
+  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.isCondFolded(C))
+        ++NumPairs;
+      if (Record.isConditionIndependencePairCovered(C))
+        ++CoveredPairs;
+    }
+  }
+  return {NumPairs, CoveredPairs};
+}
+
 FunctionCoverageSummary
 FunctionCoverageSummary::get(const CoverageMapping &CM,
                              const coverage::FunctionRecord &Function) {
   // Compute the region coverage.
   size_t NumCodeRegions = 0, CoveredRegions = 0;
   for (auto &CR : Function.CountedRegions) {
     if (CR.Kind != CounterMappingRegion::CodeRegion)
       continue;
if (LCS.getExecutionCount())
       ++CoveredLines;
   }
 
   // Compute the branch coverage, including branches from expansions.
   size_t NumBranches = 0, CoveredBranches = 0;
   sumBranches(NumBranches, CoveredBranches, CD.getBranches());
   sumBranchExpansions(NumBranches, CoveredBranches, CM, CD.getExpansions());
 
+  size_t NumPairs = 0, CoveredPairs = 0;
+  std::tie(NumPairs, CoveredPairs) = sumMCDCPairs(CD.getMCDCRecords());
+
   return FunctionCoverageSummary(
       Function.Name, Function.ExecutionCount,
       RegionCoverageInfo(CoveredRegions, NumCodeRegions),
       LineCoverageInfo(CoveredLines, NumLines),
-      BranchCoverageInfo(CoveredBranches, NumBranches));
+      BranchCoverageInfo(CoveredBranches, NumBranches),
+      MCDCCoverageInfo(CoveredPairs, NumPairs));
 }
 
 FunctionCoverageSummary
 FunctionCoverageSummary::get(const InstantiationGroup &Group,
                              ArrayRef<FunctionCoverageSummary> Summaries) {
   std::string Name;
   if (Group.hasName()) {
     Name = std::string(Group.getName());
   } else {
     llvm::raw_string_ostream OS(Name);
     OS << "Definition at line " << Group.getLine() << ", column "
        << Group.getColumn();
   }
 
   FunctionCoverageSummary Summary(Name);
   Summary.ExecutionCount = Group.getTotalExecutionCount();
   Summary.RegionCoverage = Summaries[0].RegionCoverage;
   Summary.LineCoverage = Summaries[0].LineCoverage;
   Summary.BranchCoverage = Summaries[0].BranchCoverage;
+  Summary.MCDCCoverage = Summaries[0].MCDCCoverage;
   for (const auto &FCS : Summaries.drop_front()) {
     Summary.RegionCoverage.merge(FCS.RegionCoverage);
     Summary.LineCoverage.merge(FCS.LineCoverage);
     Summary.BranchCoverage.merge(FCS.BranchCoverage);
+    Summary.MCDCCoverage.merge(FCS.MCDCCoverage);
   }
   return Summary;
 }

llvm/tools/llvm-cov/CoverageViewOptions.h

struct CoverageViewOptions {
 
   enum class BranchOutputType { Count, Percent, Off };
 
   bool Debug;
   bool Colors;
   bool ShowLineNumbers;
   bool ShowLineStats;
   bool ShowRegionMarkers;
+  bool ShowMCDC;
   bool ShowBranchCounts;
   bool ShowBranchPercents;
   bool ShowExpandedRegions;
   bool ShowFunctionInstantiations;
   bool ShowFullFilenames;
   bool ShowBranchSummary;
+  bool ShowMCDCSummary;
   bool ShowRegionSummary;
   bool ShowInstantiationSummary;
   bool ShowDirectoryCoverage;
   bool ExportSummaryOnly;
   bool SkipExpansions;
   bool SkipFunctions;
   bool SkipBranches;
   OutputFormat Format;

llvm/tools/llvm-cov/SourceCoverageView.h

struct BranchView {
 
   unsigned getLine() const { return Line; }
 
   friend bool operator<(const BranchView &LHS, const BranchView &RHS) {
     return LHS.Line < RHS.Line;
   }
 };
 
+/// A view that represents one or more MCDC regions on a given source line.
+struct MCDCView {
+  std::vector<MCDCRecord> Records;
+  std::unique_ptr<SourceCoverageView> View;
+  unsigned Line;
+
+  MCDCView(unsigned Line, ArrayRef<MCDCRecord> Records,
+           std::unique_ptr<SourceCoverageView> View)
+      : Records(Records), View(std::move(View)), Line(Line) {}
+
+  unsigned getLine() const { return Line; }
+
+  friend bool operator<(const MCDCView &LHS, const MCDCView &RHS) {
+    return LHS.Line < RHS.Line;
+  }
+};
+
 /// A file manager that handles format-aware file creation.
 class CoveragePrinter {
 public:
   struct StreamDestructor {
     void operator()(raw_ostream *OS) const;
   };
 
   using OwnedStream = std::unique_ptr<raw_ostream, StreamDestructor>;
class SourceCoverageView {
   CoverageData CoverageInfo;
 
   /// A container for all expansions (e.g macros) in the source on display.
   std::vector<ExpansionView> ExpansionSubViews;
 
   /// A container for all branches in the source on display.
   std::vector<BranchView> BranchSubViews;
 
+  /// A container for all MCDC records in the source on display.
+  std::vector<MCDCView> MCDCSubViews;
+
   /// A container for all instantiations (e.g template functions) in the source
   /// on display.
   std::vector<InstantiationView> InstantiationSubViews;
 
   /// Get the first uncovered line number for the source file.
   unsigned getFirstUncoveredLineNo();
 
 protected:
protected:
   /// Render an instantiation view and any nested views.
   virtual void renderInstantiationView(raw_ostream &OS, InstantiationView &ISV,
                                        unsigned ViewDepth) = 0;
 
   /// Render a branch view and any nested views.
   virtual void renderBranchView(raw_ostream &OS, BranchView &BRV,
                                 unsigned ViewDepth) = 0;
 
+  /// Render an MCDC view.
+  virtual void renderMCDCView(raw_ostream &OS, MCDCView &BRV,
+                              unsigned ViewDepth) = 0;
+
   /// Render \p Title, a project title if one is available, and the
   /// created time.
   virtual void renderTitle(raw_ostream &OS, StringRef CellText) = 0;
 
   /// Render the table header for a given source file.
   virtual void renderTableHeader(raw_ostream &OS, unsigned FirstUncoveredLineNo,
                                  unsigned IndentLevel) = 0;
 
public:
   /// Add a function instantiation subview to this view.
   void addInstantiation(StringRef FunctionName, unsigned Line,
                         std::unique_ptr<SourceCoverageView> View);
 
   /// Add a branch subview to this view.
   void addBranch(unsigned Line, ArrayRef<CountedRegion> Regions,
                  std::unique_ptr<SourceCoverageView> View);
 
+  /// Add an MCDC subview to this view.
+  void addMCDCRecord(unsigned Line, ArrayRef<MCDCRecord> Records,
+                     std::unique_ptr<SourceCoverageView> View);
+
   /// Print the code coverage information for a specific portion of a
   /// source file to the output stream.
   void print(raw_ostream &OS, bool WholeFile, bool ShowSourceName,
              bool ShowTitle, unsigned ViewDepth = 0);
 };
 
 } // namespace llvm
 
 #endif // LLVM_COV_SOURCECOVERAGEVIEW_H

llvm/tools/llvm-cov/SourceCoverageView.cpp

 }
 
 void SourceCoverageView::addBranch(unsigned Line,
                                    ArrayRef<CountedRegion> Regions,
                                    std::unique_ptr<SourceCoverageView> View) {
   BranchSubViews.emplace_back(Line, Regions, std::move(View));
 }
 
+void SourceCoverageView::addMCDCRecord(
+    unsigned Line, ArrayRef<MCDCRecord> Records,
+    std::unique_ptr<SourceCoverageView> View) {
+  MCDCSubViews.emplace_back(Line, Records, std::move(View));
+}
+
 void SourceCoverageView::addInstantiation(
     StringRef FunctionName, unsigned Line,
     std::unique_ptr<SourceCoverageView> View) {
   InstantiationSubViews.emplace_back(FunctionName, Line, std::move(View));
 }
 
 void SourceCoverageView::print(raw_ostream &OS, bool WholeFile,
                                bool ShowSourceName, bool ShowTitle,
void SourceCoverageView::print(raw_ostream &OS, bool WholeFile,
   renderTableHeader(OS, (ViewDepth > 0) ? 0 : getFirstUncoveredLineNo(),
                     ViewDepth);
 
   // We need the expansions, instantiations, and branches sorted so we can go
   // through them while we iterate lines.
   llvm::stable_sort(ExpansionSubViews);
   llvm::stable_sort(InstantiationSubViews);
   llvm::stable_sort(BranchSubViews);
+  llvm::stable_sort(MCDCSubViews);
   auto NextESV = ExpansionSubViews.begin();
   auto EndESV = ExpansionSubViews.end();
   auto NextISV = InstantiationSubViews.begin();
   auto EndISV = InstantiationSubViews.end();
   auto NextBRV = BranchSubViews.begin();
   auto EndBRV = BranchSubViews.end();
+  auto NextMSV = MCDCSubViews.begin();
+  auto EndMSV = MCDCSubViews.end();
 
   // Get the coverage information for the file.
   auto StartSegment = CoverageInfo.begin();
   auto EndSegment = CoverageInfo.end();
   LineCoverageIterator LCI{CoverageInfo, 1};
   LineCoverageIterator LCIEnd = LCI.getEnd();
 
   unsigned FirstLine = StartSegment != EndSegment ? StartSegment->Line : 0;
for (; NextISV != EndISV && NextISV->Line == LI.line_number(); ++NextISV) {
       renderInstantiationView(OS, *NextISV, ViewDepth + 1);
       RenderedSubView = true;
     }
     for (; NextBRV != EndBRV && NextBRV->Line == LI.line_number(); ++NextBRV) {
       renderViewDivider(OS, ViewDepth + 1);
       renderBranchView(OS, *NextBRV, ViewDepth + 1);
       RenderedSubView = true;
     }
+    for (; NextMSV != EndMSV && NextMSV->Line == LI.line_number(); ++NextMSV) {
+      renderViewDivider(OS, ViewDepth + 1);
+      renderMCDCView(OS, *NextMSV, ViewDepth + 1);
+      RenderedSubView = true;
+    }
     if (RenderedSubView)
       renderViewDivider(OS, ViewDepth + 1);
     renderLineSuffix(OS, ViewDepth);
   }
 
   renderViewFooter(OS);
 }

llvm/tools/llvm-cov/SourceCoverageViewHTML.h

void renderExpansionSite(raw_ostream &OS, LineRef L,
                            unsigned ViewDepth) override;
 
   void renderExpansionView(raw_ostream &OS, ExpansionView &ESV,
                            unsigned ViewDepth) override;
 
   void renderBranchView(raw_ostream &OS, BranchView &BRV,
                         unsigned ViewDepth) override;
 
+  void renderMCDCView(raw_ostream &OS, MCDCView &BRV,
+                      unsigned ViewDepth) override;
+
   void renderInstantiationView(raw_ostream &OS, InstantiationView &ISV,
                                unsigned ViewDepth) override;
 
   void renderLineCoverageColumn(raw_ostream &OS,
                                 const LineCoverageStats &Line) override;
 
   void renderLineNumberColumn(raw_ostream &OS, unsigned LineNo) override;
 

llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp

void emitTableRow(raw_ostream &OS, const CoverageViewOptions &Opts,
   if (Opts.ShowRegionSummary)
     AddCoverageTripleToColumn(FCS.RegionCoverage.getCovered(),
                               FCS.RegionCoverage.getNumRegions(),
                               FCS.RegionCoverage.getPercentCovered());
   if (Opts.ShowBranchSummary)
     AddCoverageTripleToColumn(FCS.BranchCoverage.getCovered(),
                               FCS.BranchCoverage.getNumBranches(),
                               FCS.BranchCoverage.getPercentCovered());
+  if (Opts.ShowMCDCSummary)
+    AddCoverageTripleToColumn(FCS.MCDCCoverage.getCoveredPairs(),
+                              FCS.MCDCCoverage.getNumPairs(),
+                              FCS.MCDCCoverage.getPercentCovered());
 
   if (IsTotals)
     OS << tag("tr", join(Columns.begin(), Columns.end(), ""), "light-row-bold");
   else
     OS << tag("tr", join(Columns.begin(), Columns.end(), ""), "light-row");
 }
 
 void emitEpilog(raw_ostream &OS) {
static void emitColumnLabelsForIndex(raw_ostream &OS,
   if (Opts.ShowInstantiationSummary)
     Columns.emplace_back(
         tag("td", "Instantiation Coverage", "column-entry-bold"));
   Columns.emplace_back(tag("td", "Line Coverage", "column-entry-bold"));
   if (Opts.ShowRegionSummary)
     Columns.emplace_back(tag("td", "Region Coverage", "column-entry-bold"));
   if (Opts.ShowBranchSummary)
     Columns.emplace_back(tag("td", "Branch Coverage", "column-entry-bold"));
+  if (Opts.ShowMCDCSummary)
+    Columns.emplace_back(tag("td", "MC/DC", "column-entry-bold"));
   OS << tag("tr", join(Columns.begin(), Columns.end(), ""));
 }
 
 std::string
 CoveragePrinterHTML::buildLinkToFile(StringRef SF,
                                      const FileCoverageSummary &FCS) const {
   SmallString<128> LinkTextStr(sys::path::relative_path(FCS.Name));
   sys::path::remove_dots(LinkTextStr, /*remove_dot_dot=*/true);
else
       OS << format("%0.2f", FalsePercent) << "%";
 
     OS << "]\n";
   }
   OS << EndPre;
   OS << EndExpansionDiv;
 }
 
+void SourceCoverageViewHTML::renderMCDCView(raw_ostream &OS, MCDCView &MRV,
+                                            unsigned ViewDepth) {
+  for (auto &Record : MRV.Records) {
+    OS << BeginExpansionDiv;
+    OS << BeginPre;
+    OS << "  MC/DC Decision Region (";
+
+    // Display Line + Column information.
+    const CounterMappingRegion &DecisionRegion = Record.getDecisionRegion();
+    std::string LineNoStr = Twine(DecisionRegion.LineStart).str();
+    std::string ColNoStr = Twine(DecisionRegion.ColumnStart).str();
+    std::string TargetName = "L" + LineNoStr;
+    OS << tag("span",
+              a("#" + TargetName, tag("span", LineNoStr + ":" + ColNoStr),
+                TargetName),
+              "line-number") +
+              ") to (";
+    LineNoStr = utostr(uint64_t(DecisionRegion.LineEnd));
+    ColNoStr = utostr(uint64_t(DecisionRegion.ColumnEnd));
+    OS << tag("span",
+              a("#" + TargetName, tag("span", LineNoStr + ":" + ColNoStr),
+                TargetName),
+              "line-number") +
+              ")\n\n";
+
+    // Display MC/DC Information.
+    OS << "  Number of Conditions: " << Record.getNumConditions() << "\n";
+    for (unsigned i = 0; i < Record.getNumConditions(); i++) {
+      OS << "     " << Record.getConditionHeaderString(i);
+    }
+    OS << "\n";
+    OS << "  Executed MC/DC Test Vectors:\n\n     ";
+    OS << Record.getTestVectorHeaderString();
+    for (unsigned i = 0; i < Record.getNumTestVectors(); i++)
+      OS << Record.getTestVectorString(i);
+    OS << "\n";
+    for (unsigned i = 0; i < Record.getNumConditions(); i++)
+      OS << Record.getConditionCoverageString(i);
+    OS << "  MC/DC Coverage for Expression: ";
+    OS << format("%0.2f", Record.getPercentCovered()) << "%\n";
+    OS << EndPre;
+    OS << EndExpansionDiv;
+  }
+  return;
+}
+
 void SourceCoverageViewHTML::renderInstantiationView(raw_ostream &OS,
                                                      InstantiationView &ISV,
                                                      unsigned ViewDepth) {
   OS << BeginExpansionDiv;
   if (!ISV.View)
     OS << BeginSourceNameDiv
        << tag("pre",
               escape("Unexecuted instantiation: " + ISV.FunctionName.str(),

llvm/tools/llvm-cov/SourceCoverageViewText.h

void renderExpansionSite(raw_ostream &OS, LineRef L,
                            unsigned ViewDepth) override;
 
   void renderExpansionView(raw_ostream &OS, ExpansionView &ESV,
                            unsigned ViewDepth) override;
 
   void renderBranchView(raw_ostream &OS, BranchView &BRV,
                         unsigned ViewDepth) override;
 
+  void renderMCDCView(raw_ostream &OS, MCDCView &BRV,
+                      unsigned ViewDepth) override;
+
   void renderInstantiationView(raw_ostream &OS, InstantiationView &ISV,
                                unsigned ViewDepth) override;
 
   void renderLineCoverageColumn(raw_ostream &OS,
                                 const LineCoverageStats &Line) override;
 
   void renderLineNumberColumn(raw_ostream &OS, unsigned LineNo) override;
 

llvm/tools/llvm-cov/SourceCoverageViewText.cpp

for (const auto &R : BRV.Regions) {
     if (getOptions().ShowBranchCounts)
       OS << ": " << formatCount(R.FalseExecutionCount);
     else
       OS << ": " << format("%0.2f", FalsePercent) << "%";
     OS << "]\n";
   }
 }
 
+void SourceCoverageViewText::renderMCDCView(raw_ostream &OS, MCDCView &MRV,
+                                            unsigned ViewDepth) {
+  for (auto &Record : MRV.Records) {
+    renderLinePrefix(OS, ViewDepth);
+    OS << "---> MC/DC Decision Region (";
+    // Display Line + Column information.
+    const CounterMappingRegion &DecisionRegion = Record.getDecisionRegion();
+    OS << DecisionRegion.LineStart << ":";
+    OS << DecisionRegion.ColumnStart << ") to (";
+    OS << DecisionRegion.LineEnd << ":";
+    OS << DecisionRegion.ColumnEnd << ")\n";
+    renderLinePrefix(OS, ViewDepth);
+    OS << "\n";
+
+    // Display MC/DC Information.
+    renderLinePrefix(OS, ViewDepth);
+    OS << "  Number of Conditions: " << Record.getNumConditions() << "\n";
+    for (unsigned i = 0; i < Record.getNumConditions(); i++) {
+      renderLinePrefix(OS, ViewDepth);
+      OS << "     " << Record.getConditionHeaderString(i);
+    }
+    renderLinePrefix(OS, ViewDepth);
+    OS << "\n";
+    renderLinePrefix(OS, ViewDepth);
+    OS << "  Executed MC/DC Test Vectors:\n";
+    renderLinePrefix(OS, ViewDepth);
+    OS << "\n";
+    renderLinePrefix(OS, ViewDepth);
+    OS << "     ";
+    OS << Record.getTestVectorHeaderString();
+    for (unsigned i = 0; i < Record.getNumTestVectors(); i++) {
+      renderLinePrefix(OS, ViewDepth);
+      OS << Record.getTestVectorString(i);
+    }
+    renderLinePrefix(OS, ViewDepth);
+    OS << "\n";
+    for (unsigned i = 0; i < Record.getNumConditions(); i++) {
+      renderLinePrefix(OS, ViewDepth);
+      OS << Record.getConditionCoverageString(i);
+    }
+    renderLinePrefix(OS, ViewDepth);
+    OS << "  MC/DC Coverage for Decision: ";
+    colored_ostream(OS, raw_ostream::RED,
+                    getOptions().Colors && Record.getPercentCovered() < 100.0,
+                    /*Bold=*/false, /*BG=*/true)
+        << format("%0.2f", Record.getPercentCovered()) << "%\n";
+    renderLinePrefix(OS, ViewDepth);
+    OS << "\n";
+  }
+}
+
 void SourceCoverageViewText::renderInstantiationView(raw_ostream &OS,
                                                      InstantiationView &ISV,
                                                      unsigned ViewDepth) {
   renderLinePrefix(OS, ViewDepth);
   OS << ' ';
   if (!ISV.View)
     getOptions().colored_ostream(OS, raw_ostream::RED)
         << "Unexecuted instantiation: " << ISV.FunctionName << "\n";

llvm/unittests/ProfileData/CoverageMappingTest.cpp

void addCMR(Counter C, StringRef File, unsigned LS, unsigned CS, unsigned LE,
               unsigned CE, bool Skipped = false) {
     auto &Regions = InputFunctions.back().Regions;
     unsigned FileID = getFileIndexForFunction(File);
     Regions.push_back(
         Skipped ? CounterMappingRegion::makeSkipped(FileID, LS, CS, LE, CE)
                 : CounterMappingRegion::makeRegion(C, FileID, LS, CS, LE, CE));
   }
 
+  void addMCDCDecisionCMR(unsigned Mask, unsigned NC, StringRef File,
+                          unsigned LS, unsigned CS, unsigned LE, unsigned CE) {
+    auto &Regions = InputFunctions.back().Regions;
+    unsigned FileID = getFileIndexForFunction(File);
+    Regions.push_back(CounterMappingRegion::makeDecisionRegion(
+        CounterMappingRegion::MCDCParameters{Mask, NC}, FileID, LS, CS, LE,
+        CE));
+  }
+
+  void addMCDCBranchCMR(Counter C1, Counter C2, unsigned ID, unsigned TrueID,
+                        unsigned FalseID, StringRef File, unsigned LS,
+                        unsigned CS, unsigned LE, unsigned CE) {
+    auto &Regions = InputFunctions.back().Regions;
+    unsigned FileID = getFileIndexForFunction(File);
+    Regions.push_back(CounterMappingRegion::makeBranchRegion(
+        C1, C2, CounterMappingRegion::MCDCParameters{0, 0, ID, TrueID, FalseID},
+        FileID, LS, CS, LE, CE));
+  }
+
   void addExpansionCMR(StringRef File, StringRef ExpandedFile, unsigned LS,
                        unsigned CS, unsigned LE, unsigned CE) {
     InputFunctions.back().Regions.push_back(CounterMappingRegion::makeExpansion(
         getFileIndexForFunction(File), getFileIndexForFunction(ExpandedFile),
         LS, CS, LE, CE));
   }
 
   void addExpression(CounterExpression CE) {
TEST_P(CoverageMappingTest, non_code_region_counters) {
   std::vector<std::string> Names;
   for (const auto &Func : LoadedCoverage->getCoveredFunctions()) {
     Names.push_back(Func.Name);
     ASSERT_EQ(2U, Func.CountedRegions.size());
   }
   ASSERT_EQ(1U, Names.size());
 }
 
+// Test that MCDC bitmasks not associated with any code regions are allowed.
+TEST_P(CoverageMappingTest, non_code_region_bitmask) {
+  // No records in profdata
+
+  startFunction("func", 0x1234);
+  addCMR(Counter::getCounter(0), "file", 1, 1, 5, 5);
+  addCMR(Counter::getCounter(1), "file", 1, 1, 5, 5);
+  addCMR(Counter::getCounter(2), "file", 1, 1, 5, 5);
+  addCMR(Counter::getCounter(3), "file", 1, 1, 5, 5);
+
+  addMCDCDecisionCMR(0, 2, "file", 7, 1, 7, 6);
+  addMCDCBranchCMR(Counter::getCounter(0), Counter::getCounter(1), 1, 2, 0,
+                   "file", 7, 2, 7, 3);
+  addMCDCBranchCMR(Counter::getCounter(2), Counter::getCounter(3), 2, 0, 0,
+                   "file", 7, 4, 7, 5);
+
+  EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded());
+
+  std::vector<std::string> Names;
+  for (const auto &Func : LoadedCoverage->getCoveredFunctions()) {
+    Names.push_back(Func.Name);
+    ASSERT_EQ(2U, Func.CountedBranchRegions.size());
+    ASSERT_EQ(1U, Func.MCDCRecords.size());
+  }
+  ASSERT_EQ(1U, Names.size());
+}
+
 TEST_P(CoverageMappingTest, strip_filename_prefix) {
   ProfileWriter.addRecord({"file1:func", 0x1234, {0}}, Err);
 
   startFunction("file1:func", 0x1234);
   addCMR(Counter::getCounter(0), "file1", 1, 1, 9, 9);
   EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded());
 
   std::vector<std::string> Names;