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

238

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

238

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

238

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

238

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

257

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

242

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

374

Why not SmallVector?

375

Why not SmallVector?

376

Why not SmallVector?

432

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).

444

Nit: prefer static cast for greppability

447

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

470

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?

471

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

473

Maybe there should be a function called printConditions?

495

Maybe there should be a function called printResult?

506

507

llvm/lib/ProfileData/Coverage/CoverageMapping.cpp

210

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

211

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?

236

LLVM style guide for variables

254

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

shouldCopyOffTestVectorForTruePath(Branch);
shouldCopyOffTestVectorForFalsePath(Branch);

279

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]);
}

285

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?

301

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.

310

Can you add a comment to this function?

[paquette]

llvm/lib/ProfileData/Coverage/CoverageMapping.cpp

334

Doxygen comment?

339

this comment probably could be adapted into a doxygen comment

478

LLVM coding standards say to avoid else after return.

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

526

Can you explain why you are decrementing this?

533

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

473

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

260–261

Could this be reformatted?

545–546

Could this be reformatted?

llvm/lib/ProfileData/Coverage/CoverageMapping.cpp

546–548

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

242

No need for typedef in C++.

254–263

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

[phosek]

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

372

No need for typedef in C++.

413

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?

448

456

473

510

llvm/lib/ProfileData/Coverage/CoverageMapping.cpp

204

205

361

362

365

368

llvm/tools/llvm-cov/CoverageSummaryInfo.cpp

50

[phosek]

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

241

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

418

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

741

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

[paquette]

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

244

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

372

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

403

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

408

Could use a doxygen comment here

414

doxygen

424

doxygen

435

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?

493

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

297

simple explanation in doxygen comment?

306

this should be a doxygen comment imo

316

doxygenify

llvm/tools/llvm-cov/CodeCoverage.cpp

373

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>).

435

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

474

const { ?

llvm/lib/ProfileData/Coverage/CoverageMapping.cpp

332

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

339

llvm style prefers pre-increment

371

delete blank line immediately after openning a scope.

[paquette]

LGTM after you address @MaskRay's comments.

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/None.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.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
   };
 
   /// Primary Counter that is also used for Branch Regions (TrueCount).
   Counter Count;
 
   /// Secondary Counter used for Branch Regions (FalseCount).
   Counter FalseCount;
 
+  /// Byte Index of Bitmap Coverage Object for a Decision Region (MC/DC only).
+  unsigned BitmapIdx;
+
+  /// Number of Conditions used for a Decision Region (MC/DC only).
+  unsigned NumConditions;
+
+  /// IDs used to represent a branch region and other branch regions evaluated
+  /// based on True and False branches (MC/DC only).
+  unsigned ID, TrueID, FalseID;
+
   unsigned FileID, ExpandedFileID;
   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, unsigned BitmapIdx,
+                       unsigned NumConditions, unsigned ID, unsigned TrueID,
+                       unsigned FalseID, unsigned FileID,
                        unsigned ExpandedFileID, unsigned LineStart,
                        unsigned ColumnStart, unsigned LineEnd,
                        unsigned ColumnEnd, RegionKind Kind)
-      : Count(Count), FalseCount(FalseCount), FileID(FileID),
+      : Count(Count), FalseCount(FalseCount), BitmapIdx(BitmapIdx),
+        NumConditions(NumConditions), ID(ID), TrueID(TrueID), FalseID(FalseID),
+        FileID(FileID), ExpandedFileID(ExpandedFileID), LineStart(LineStart),
+        ColumnStart(ColumnStart), LineEnd(LineEnd), ColumnEnd(ColumnEnd),
+        Kind(Kind) {}
+
+  CounterMappingRegion(unsigned BitmapIdx, unsigned NumConditions,
+                       unsigned FileID, unsigned ExpandedFileID,
+                       unsigned LineStart, unsigned ColumnStart,
+                       unsigned LineEnd, unsigned ColumnEnd, RegionKind Kind)
+      : BitmapIdx(BitmapIdx), NumConditions(NumConditions), FileID(FileID),
         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,
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, 0, 0, 0, 0, 0,
+                                FileID, 0, LineStart, ColumnStart, LineEnd,
+                                ColumnEnd, BranchRegion);
+  }
+
+  static CounterMappingRegion                                                    
+  makeBranchRegion(Counter Count, Counter FalseCount, unsigned ID,               
+                   unsigned TrueID, unsigned FalseID, unsigned FileID,           
+                   unsigned LineStart, unsigned ColumnStart, unsigned LineEnd,   
+                   unsigned ColumnEnd) {                                         
+    return CounterMappingRegion(Count, FalseCount, 0, 0, ID, TrueID, FalseID,    
+                                FileID, 0, LineStart, ColumnStart, LineEnd,      
+                                ColumnEnd,                                       
+                                ID == 0 ? BranchRegion : MCDCBranchRegion);      
+  }  
+
+  static CounterMappingRegion
+  makeDecisionRegion(unsigned BitmapIdx, unsigned NumConditions,
+                     unsigned FileID, unsigned LineStart, unsigned ColumnStart,
+                     unsigned LineEnd, unsigned ColumnEnd) {
+    return CounterMappingRegion(BitmapIdx, NumConditions, 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 {
+  typedef enum { MCDC_DontCare = -1, MCDC_False = 0, MCDC_True = 1 } CondState;
+
+  using TestVector = std::vector<CondState>;
+  using TestVectors = std::vector<TestVector>;
+  using BoolVector = std::vector<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 IndepPairs;
+  BoolVector Folded;
+  CondIDMap PosToID;
+  LineColPairMap CondLoc;
+
+public:
+  MCDCRecord(CounterMappingRegion Region, TestVectors TV, TVPairMap IndepPairs,
+             BoolVector Folded, CondIDMap PosToID, LineColPairMap CondLoc)
+      : Region(Region), TV(TV), IndepPairs(IndepPairs), Folded(Folded),
+        PosToID(PosToID), CondLoc(CondLoc){};
+
+  CounterMappingRegion getDecisionRegion() const { return Region; }
+  unsigned getNumConditions() const { return Region.NumConditions; }
+  unsigned getNumTestVectors() const { return TV.size(); }
+  bool isCondFolded(unsigned Condition) const { return Folded[Condition]; }
+
+  CondState getTVCondition(unsigned TestVector, unsigned Condition) {
+    // Accessing conditions in the TestVectors requires a translation from a
+    // ordinal position to actual condition ID. This is done via PosToID[].
+    return TV[TestVector][PosToID[Condition]];
+  }
+
+  CondState getTVResult(unsigned TestVector) {
+    // The last value for a Test Vector, after its constituent conditions, is
+    // always the Result. See MCDCRecordProcessor::RecordTestVector().
+    return TV[TestVector][getNumConditions()];
+  }
+
+  bool isCondIndepPairCovered(unsigned Condition) const {
+    // Accessing conditions in the TestVector Row Pairs requires a translation
+    // from a ordinal position to actual condition ID. This is done via
+    // PosToID[].
+    auto it = PosToID.find(Condition);
+    if (it != PosToID.end())
+      return (IndepPairs.find(it->second) != IndepPairs.end());
+    llvm_unreachable("Condition ID without an Ordinal mapping");
+  }
+
+  TVRowPair getCondIndepPair(unsigned Condition) {
+    // Accessing conditions in the TestVector Row Pairs requires a translation
+    // from a ordinal position to actual condition ID. This is done via
+    // PosToID[].
+    assert(isCondIndepPairCovered(Condition));
+    return IndepPairs[PosToID[Condition]];
+  }
+
+  float getPercentCovered() const {
+    unsigned folded = 0;
+    unsigned covered = 0;
+    for (unsigned c = 0; c < getNumConditions(); c++) {
+      if (isCondFolded(c))
+        folded++;
+      else if (isCondIndepPairCovered(c))
+        covered++;
+    }
+
+    return ((double)(covered) / (double)(getNumConditions() - folded)) * 100.0;
+  }
+
+  std::string getConditionHdrStr(unsigned Condition) {
+    std::ostringstream ss;
+    ss << "Condition C" << Condition + 1 << " --> (";
+    ss << CondLoc[Condition].first << ":" << CondLoc[Condition].second;
+    ss << ")\n";
+    return ss.str();
+  }
+
+  std::string getTestVectorHdrStr() {
+    std::ostringstream ss;
+    if (getNumTestVectors() == 0) {
+      ss << "None.\n";
+      return ss.str();
+    }
+    for (unsigned i = 0; i < getNumConditions(); i++) {
+      ss << "C" << i + 1;
+      if (i != getNumConditions() - 1)
+        ss << ", ";
+    }
+    ss << "    Result\n";
+    return ss.str();
+  }
+
+  std::string getTestVectorStr(unsigned TestVector) {
+    assert(TestVector < getNumTestVectors());
+    std::ostringstream ss;
+    // Print Individual Conditions
+    ss << "  " << TestVector + 1 << " { ";
+    for (unsigned Condition = 0; Condition < getNumConditions(); Condition++) {
+      if (isCondFolded(Condition))
+        ss << "C";
+      else {
+        switch (getTVCondition(TestVector, Condition)) {
+        case MCDCRecord::MCDC_DontCare:
+          ss << "-";
+          break;
+        case MCDCRecord::MCDC_True:
+          ss << "T";
+          break;
+        case MCDCRecord::MCDC_False:
+          ss << "F";
+          break;
+        }
+      }
+      if (Condition != getNumConditions() - 1)
+        ss << ",  ";
+    }
+
+    // Print Result
+    ss << "  = ";
+    if (getTVResult(TestVector) == MCDC_True)
+      ss << "T";
+    else
+      ss << "F";
+    ss << "      }\n";
+
+    return ss.str();
+  }
+
+  std::string getCondCoverageStr(unsigned Condition) {
+    assert(Condition < getNumConditions());
+    std::ostringstream ss;
+
+    ss << "  C" << Condition + 1 << "-Pair: ";
+    if (isCondFolded(Condition)) {
+      ss << "constant folded\n";
+    } else if (isCondIndepPairCovered(Condition)) {
+      TVRowPair rows = getCondIndepPair(Condition);
+      ss << "covered: (" << rows.first << ",";
+      ss << rows.second << ")\n";
+    } else
+      ss << "not covered\n";
+
+    return ss.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 = None)
       : 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(unsigned Bitmap, unsigned NumCond) 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 <iterator>
 #include <map>
 #include <memory>
 #include <optional>
 #include <string>
 #include <system_error>
 #include <utility>
 #include <vector>
+#include <cmath>
 
 using namespace llvm;
 using namespace coverage;
 
 #define DEBUG_TYPE "coverage-mapping"
 
 Counter CounterExpressionBuilder::get(const CounterExpression &E) {
   auto It = ExpressionIndices.find(E);
case Counter::Expression: {
     if (!RHS)
       return RHS;
     return E.Kind == CounterExpression::Subtract ? *LHS - *RHS : *LHS + *RHS;
   }
   }
   llvm_unreachable("Unhandled CounterKind");
 }
 
+Expected<BitVector> CounterMappingContext::evaluateBitmap(unsigned ID,
+                                                           unsigned NC) const {
+  unsigned SizeInBits = llvm::alignTo(1L << 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 {
+  BitVector &Bitmap;
+  CounterMappingRegion &Region;
+  ArrayRef<CounterMappingRegion> Branches;
+  unsigned NumConditions;
+  llvm::DenseMap<unsigned, const CounterMappingRegion *> Map;
+
+  MCDCRecord::BoolVector Folded;
+  MCDCRecord::TVPairMap IndepPairs;
+  MCDCRecord::TestVectors TestVectors;
+  MCDCRecord::TestVectors ExecVectors;
+
+public:
+  MCDCRecordProcessor(BitVector &Bitmap, CounterMappingRegion &Region,
+                      ArrayRef<CounterMappingRegion> Branches)
+      : Bitmap(Bitmap), Region(Region), Branches(Branches),
+        NumConditions(Region.NumConditions), Folded(NumConditions, false),
+        IndepPairs(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 idx = 0;
+    for (auto Cond = std::rbegin(TV); Cond != std::rend(TV); ++Cond) {
+      idx <<= 1;
+      idx |= (*Cond == MCDCRecord::MCDC_True) ? 0x1 : 0x0;
+    }
+
+    // Copy the completed test vector to the vector of testvectors.
+    TestVectors[idx] = TV;
+
+    // The final value (T,F) is equal to the last non-dontcare state on the
+    // path (in a short-circuiting system).
+    TestVectors[idx].push_back(Result);
+  }
+
+  void buildTestVector(MCDCRecord::TestVector &TV, unsigned ID = 1) {
+    // Branch regions are hashed based on an ID.
+    const CounterMappingRegion *Branch = Map[ID];
+
+    // An ID of '0' indicates the end of a test vector, at which point, the
+    // test vector can be copied off, and the algorithm can keep going.
+
+    // Follow "True" Path in Test Vector.
+    TV[ID - 1] = MCDCRecord::MCDC_True;
+    if (Branch->TrueID > 0)
+      buildTestVector(TV, Branch->TrueID);
+    else
+      recordTestVector(TV, MCDCRecord::MCDC_True);
+
+    // Follow "False" Path in Test Vector.
+    TV[ID - 1] = MCDCRecord::MCDC_False;
+    if (Branch->FalseID > 0)
+      buildTestVector(TV, Branch->FalseID);
+    else
+      recordTestVector(TV, MCDCRecord::MCDC_False);
+
+    // Reset back to DontCare
+    TV[ID - 1] = MCDCRecord::MCDC_DontCare;
+  }
+
+  void findExecutedTestVectors(BitVector &Bitmap) {
+    // 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.
+    for (unsigned i = 0; i < Bitmap.size(); i++)
+      if (Bitmap[i] == 1) {
+        assert(!TestVectors[i].empty() && "Test Vector doesn't exist.");
+        ExecVectors.push_back(TestVectors[i]);
+      }
+  }
+
+  bool matchTestVectors(unsigned Aidx, unsigned Bidx, unsigned C) {
+    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.
+    if (!((A[C] ^ B[C]) == 1))
+      return false;
+
+    // If the results of both A and B aren't opposites, no match.
+    if (!((A[NumConditions] ^ B[NumConditions]) == 1))
+      return false;
+
+    // If just one of the other conditions don't match, no match.
+    for (unsigned i = 0; i < NumConditions; i++) {
+      if (i == C)
+        continue;
+      if (A[i] != MCDCRecord::MCDC_DontCare &&
+          B[i] != MCDCRecord::MCDC_DontCare && A[i] != B[i])
+        return false;
+    }
+
+    // Otherwise, match.
+    return true;
+  }
+
+  void findIndependencePairs() {
+    unsigned NumTVs = ExecVectors.size();
+
+    // For each condition.
+    for (unsigned c = 0; c < NumConditions; c++) {
+      bool pair_found = false;
+
+      // For each executed test vector.
+      for (unsigned i = 0; !pair_found && i < NumTVs; i++) {
+
+        // Compared to every other executed test vector.
+        for (unsigned j = 0; !pair_found && j < NumTVs; j++) {
+          if (i == j)
+            continue;
+
+          // If a matching pair of vectors is found, record them.
+          if ((pair_found = matchTestVectors(i, j, c)))
+            IndepPairs[c] = std::make_pair(i + 1, j + 1);
+        }
+      }
+    }
+  }
+
+public:
+  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.ID] = &B;
+      PosToID[i] = B.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(Bitmap);
+
+    // 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, IndepPairs, Folded, PosToID, CondLoc);
+    return Res;
+  }
+};
+
+Expected<MCDCRecord> CounterMappingContext::evaluateMCDCRegion(
+    CounterMappingRegion Region, BitVector Bitmap,
+    ArrayRef<CounterMappingRegion> Branches) {
+
+  MCDCRecordProcessor MCDCProcessor(Bitmap, Region, Branches);
+  return MCDCProcessor.processMCDCRecord();
+}
+
 unsigned CounterMappingContext::getMaxCounterID(const Counter &C) const {
   switch (C.getKind()) {
   case Counter::Zero:
     return 0;
   case Counter::CounterValueReference:
     return C.getCounterID();
   case Counter::Expression: {
     if (C.getExpressionID() >= Expressions.size())
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.BitmapIdx;
+      NumConditions = Region.NumConditions;
+      break;
+    }
+  }
+  unsigned SizeInBits = llvm::alignTo(1L << 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);
 
   if (Record.Filenames.empty())
if (IPE == instrprof_error::hash_mismatch) {
                                       Record.FunctionHash);
       return Error::success();
     } else 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 = 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)
+      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 MCDC DecisionRegion is seen, track the BranchRegions that follow
+    // it according to Region.NumConditions.
+    if (Region.Kind == CounterMappingRegion::MCDCDecisionRegion) {
+      assert(NumConds == 0);
+      MCDCDecision = &Region;
+      NumConds = Region.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 as well as the BranchRegions that
+    // correspond to it stored in a vector, according to the number of
+    // conditions recorded for the region.
+    if (NumConds > 0 && Region.Kind == CounterMappingRegion::MCDCBranchRegion) {
+      MCDCBranches.push_back(Region);
+      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> Bitmap = Ctx.evaluateBitmap(
+            MCDCDecision->BitmapIdx, MCDCDecision->NumConditions);
+        if (auto E = Bitmap.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, *Bitmap, 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 BitmapIdx = 0, Conditions = 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(BitmapIdx, std::numeric_limits<unsigned>::max()))
+            return Err;
+          if (auto Err =
+                  readIntMax(Conditions, std::numeric_limits<unsigned>::max()))
+            return Err;
+          break;
         default:
           return make_error<CoverageMapError>(coveragemap_error::malformed);
         }
       }
     }
 
     // Read the source range.
     uint64_t LineStartDelta, ColumnStart, NumLines, ColumnEnd;
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, BitmapIdx, Conditions, ID, TID, FID, InferredFileID,
+        ExpandedFileID, LineStart, ColumnStart, LineStart + NumLines, ColumnEnd,
+        Kind);
     if (CMR.startLoc() > CMR.endLoc())
       return make_error<CoverageMapError>(coveragemap_error::malformed);
     MappingRegions.push_back(CMR);
   }
   return Error::success();
 }
 
 Error RawCoverageMappingReader::read() {

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->ID), OS);
+      encodeULEB128(unsigned(I->TrueID), OS);
+      encodeULEB128(unsigned(I->FalseID), OS);
+      break;
+    case CounterMappingRegion::MCDCDecisionRegion:
+      encodeULEB128(unsigned(I->Kind)
+                        << Counter::EncodingCounterTagAndExpansionRegionTagBits,
+                    OS);
+      encodeULEB128(unsigned(I->BitmapIdx), OS);
+      encodeULEB128(unsigned(I->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;
   }
   // Ensure that all file ids have at least one mapping region.
   assert(CurrentFileID == (VirtualFileMapping.size() - 1));
 }

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

 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:
+1
+
+
+_Z5case5b
+# Func Hash:
+1551
+# Num Counters:
+3
+# Counter Values:
+4
+1
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+6
+
+
+_Z5caseabb
+# Func Hash:
+99214
+# Num Counters:
+5
+# Counter Values:
+4
+3
+2
+4
+3
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+a2
+
+
+_Z5case6b
+# Func Hash:
+1551
+# Num Counters:
+3
+# Counter Values:
+4
+4
+1
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+5
+
+
+_Z5casegbb
+# Func Hash:
+99214
+# Num Counters:
+5
+# Counter Values:
+4
+2
+0
+3
+2
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+23
+
+
+_Z5case1b
+# Func Hash:
+1550
+# Num Counters:
+3
+# Counter Values:
+4
+3
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+3
+
+
+_Z5case7b
+# Func Hash:
+1551
+# Num Counters:
+3
+# Counter Values:
+4
+1
+1
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+3
+
+
+_Z5casedbb
+# Func Hash:
+99279
+# Num Counters:
+5
+# Counter Values:
+4
+0
+0
+1
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+12
+
+
+_Z5casekbb
+# Func Hash:
+99279
+# Num Counters:
+5
+# Counter Values:
+4
+0
+0
+1
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+12
+
+
+_Z5casehbb
+# Func Hash:
+99214
+# Num Counters:
+5
+# Counter Values:
+4
+0
+0
+3
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+3
+
+
+_Z5case4b
+# Func Hash:
+1551
+# Num Counters:
+3
+# Counter Values:
+4
+0
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+2
+
+
+_Z5caseibb
+# Func Hash:
+99214
+# Num Counters:
+5
+# Counter Values:
+4
+2
+2
+3
+2
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+83
+
+
+_Z5case2b
+# Func Hash:
+1550
+# Num Counters:
+3
+# Counter Values:
+4
+4
+3
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+a
+
+
+_Z5casefbb
+# Func Hash:
+99279
+# Num Counters:
+5
+# Counter Values:
+4
+1
+0
+1
+1
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+6
+
+
+_Z5caselbb
+# Func Hash:
+99279
+# Num Counters:
+5
+# Counter Values:
+4
+0
+0
+1
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+12
+
+
+_Z5casenbb
+# Func Hash:
+99279
+# Num Counters:
+5
+# Counter Values:
+4
+1
+0
+1
+1
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+6
+
+
+_Z5case9bb
+# Func Hash:
+99214
+# Num Counters:
+5
+# Counter Values:
+4
+0
+0
+3
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+3
+
+
+_Z5casecbb
+# Func Hash:
+99279
+# Num Counters:
+5
+# Counter Values:
+4
+0
+0
+0
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+2
+
+
+_Z5casebbb
+# Func Hash:
+99214
+# Num Counters:
+5
+# Counter Values:
+4
+3
+2
+3
+3
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+a1
+
+
+_Z5case0b
+# Func Hash:
+1550
+# Num Counters:
+3
+# Counter Values:
+4
+0
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+1
+
+
+_Z5casejbb
+# Func Hash:
+99214
+# Num Counters:
+5
+# Counter Values:
+4
+3
+2
+3
+3
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+a1
+
+
+_Z5caseebb
+# Func Hash:
+99279
+# Num Counters:
+5
+# Counter Values:
+4
+1
+0
+4
+1
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+14
+
+
+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:
+9
+
+
+_Z5casembb
+# Func Hash:
+99279
+# Num Counters:
+5
+# Counter Values:
+4
+0
+0
+1
+0
+# Num Bitmask Bytes:
+$1
+# Bitmask Byte Values:
+12
+
+

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:
+2f
+8
+b
+9
+83
+80
+
+

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.o32l -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.o32l -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.o32l -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: |  C2-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { F,  C  = F      }
+// CHECKFULLCASE: |  2 { T,  C  = F      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE: |  C2-Pair: constant folded
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { C,  F  = F      }
+// CHECKFULLCASE: |  2 { C,  T  = T      }
+// CHECKFULLCASE: |  C1-Pair: constant folded
+// CHECKFULLCASE: |  C2-Pair: covered: (1,2)
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 100.00%
+// CHECKFULLCASE: |  1 { F,  C  = F      }
+// CHECKFULLCASE: |  2 { T,  C  = T      }
+// CHECKFULLCASE: |  C1-Pair: covered: (1,2)
+// CHECKFULLCASE: |  C2-Pair: constant folded
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 100.00%
+// CHECKFULLCASE: |  1 { C,  -  = T      }
+// CHECKFULLCASE: |  C1-Pair: constant folded
+// CHECKFULLCASE: |  C2-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { T,  C  = T      }
+// CHECKFULLCASE: |  2 { F,  C  = T      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE: |  C2-Pair: constant folded
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { C,  F  = F      }
+// CHECKFULLCASE: |  2 { C,  T  = T      }
+// CHECKFULLCASE: |  C1-Pair: constant folded
+// CHECKFULLCASE: |  C2-Pair: covered: (1,2)
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 100.00%
+// CHECKFULLCASE: |  1 { F,  C  = F      }
+// CHECKFULLCASE: |  2 { T,  C  = T      }
+// CHECKFULLCASE: |  C1-Pair: covered: (1,2)
+// CHECKFULLCASE: |  C2-Pair: constant folded
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 100.00%
+// CHECKFULLCASE: |  1 { C,  -,  -  = F      }
+// CHECKFULLCASE: |  C1-Pair: constant folded
+// CHECKFULLCASE: |  C2-Pair: not covered
+// CHECKFULLCASE: |  C3-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { F,  C,  -  = F      }
+// CHECKFULLCASE: |  2 { T,  C,  -  = F      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE: |  C2-Pair: constant folded
+// CHECKFULLCASE: |  C3-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { C,  F,  -  = F      }
+// CHECKFULLCASE: |  2 { C,  T,  F  = F      }
+// CHECKFULLCASE: |  3 { C,  T,  T  = T      }
+// CHECKFULLCASE: |  C1-Pair: constant folded
+// CHECKFULLCASE: |  C2-Pair: covered: (1,3)
+// CHECKFULLCASE: |  C3-Pair: covered: (2,3)
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 100.00%
+// CHECKFULLCASE: |  1 { F,  C,  -  = F      }
+// CHECKFULLCASE: |  2 { T,  C,  F  = F      }
+// CHECKFULLCASE: |  3 { T,  C,  T  = T      }
+// CHECKFULLCASE: |  C1-Pair: covered: (1,3)
+// CHECKFULLCASE: |  C2-Pair: constant folded
+// CHECKFULLCASE: |  C3-Pair: covered: (2,3)
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 100.00%
+// CHECKFULLCASE: |  1 { C,  -,  -  = T      }
+// CHECKFULLCASE: |  C1-Pair: constant folded
+// CHECKFULLCASE: |  C2-Pair: not covered
+// CHECKFULLCASE: |  C3-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { T,  C,  -  = T      }
+// CHECKFULLCASE: |  2 { F,  C,  -  = T      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE: |  C2-Pair: constant folded
+// CHECKFULLCASE: |  C3-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { C,  F,  T  = T      }
+// CHECKFULLCASE: |  2 { C,  T,  -  = T      }
+// CHECKFULLCASE: |  C1-Pair: constant folded
+// CHECKFULLCASE: |  C2-Pair: not covered
+// CHECKFULLCASE: |  C3-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { T,  C,  -  = T      }
+// CHECKFULLCASE: |  2 { F,  C,  T  = T      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE: |  C2-Pair: constant folded
+// CHECKFULLCASE: |  C3-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { F,  -,  C  = F      }
+// CHECKFULLCASE: |  2 { T,  F,  C  = F      }
+// CHECKFULLCASE: |  3 { T,  T,  C  = F      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE: |  C2-Pair: not covered
+// CHECKFULLCASE: |  C3-Pair: constant folded
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { F,  C,  -  = F      }
+// CHECKFULLCASE: |  2 { T,  C,  -  = F      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE: |  C2-Pair: constant folded
+// CHECKFULLCASE: |  C3-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { F,  -,  C  = F      }
+// CHECKFULLCASE: |  2 { T,  F,  C  = F      }
+// CHECKFULLCASE: |  3 { T,  T,  C  = T      }
+// CHECKFULLCASE: |  C1-Pair: covered: (1,3)
+// CHECKFULLCASE: |  C2-Pair: covered: (2,3)
+// CHECKFULLCASE: |  C3-Pair: constant folded
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 100.00%
+// CHECKFULLCASE: |  1 { F,  C,  -  = F      }
+// CHECKFULLCASE: |  2 { T,  C,  F  = F      }
+// CHECKFULLCASE: |  3 { T,  C,  T  = T      }
+// CHECKFULLCASE: |  C1-Pair: covered: (1,3)
+// CHECKFULLCASE: |  C2-Pair: constant folded
+// CHECKFULLCASE: |  C3-Pair: covered: (2,3)
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 100.00%
+// CHECKFULLCASE: |  1 { T,  -,  C  = T      }
+// CHECKFULLCASE: |  2 { F,  T,  C  = T      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE: |  C2-Pair: not covered
+// CHECKFULLCASE: |  C3-Pair: constant folded
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { T,  C,  -  = T      }
+// CHECKFULLCASE: |  2 { F,  C,  -  = T      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE: |  C2-Pair: constant folded
+// CHECKFULLCASE: |  C3-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { T,  -,  C  = T      }
+// CHECKFULLCASE: |  2 { F,  T,  C  = T      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE: |  C2-Pair: not covered
+// CHECKFULLCASE: |  C3-Pair: constant folded
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+// CHECKFULLCASE: |  1 { T,  C,  -  = T      }
+// CHECKFULLCASE: |  2 { F,  C,  T  = T      }
+// CHECKFULLCASE: |  C1-Pair: not covered
+// CHECKFULLCASE: |  C2-Pair: constant folded
+// CHECKFULLCASE: |  C3-Pair: not covered
+// CHECKFULLCASE: |  MC/DC Coverage for Decision: 0.00%
+
+// REPORT: _Z5case0b {{.*}} 1       1   0.00%
+// REPORT: _Z5case1b {{.*}} 1       1   0.00%
+// REPORT: _Z5case2b {{.*}} 1       0 100.00%
+// REPORT: _Z5case3b {{.*}} 1       0 100.00%
+// REPORT: _Z5case4b {{.*}} 1       1   0.00%
+// REPORT: _Z5case5b {{.*}} 1       1   0.00%
+// REPORT: _Z5case6b {{.*}} 1       0 100.00%
+// REPORT: _Z5case7b {{.*}} 1       0 100.00%
+// REPORT: _Z5case8bb {{.*}} 2       2   0.00%
+// REPORT: _Z5case9bb {{.*}} 2       2   0.00%
+// REPORT: _Z5caseabb {{.*}} 2       0 100.00%
+// REPORT: _Z5casebbb {{.*}} 2       0 100.00%
+// REPORT: _Z5casecbb {{.*}} 2       2   0.00%
+// REPORT: _Z5casedbb {{.*}} 2       2   0.00%
+// REPORT: _Z5caseebb {{.*}} 2       2   0.00%
+// REPORT: _Z5casefbb {{.*}} 2       2   0.00%
+// REPORT: _Z5casegbb {{.*}} 2       2   0.00%
+// REPORT: _Z5casehbb {{.*}} 2       2   0.00%
+// REPORT: _Z5caseibb {{.*}} 2       0 100.00%
+// REPORT: _Z5casejbb {{.*}} 2       0 100.00%
+// REPORT: _Z5casekbb {{.*}} 2       2   0.00%
+// REPORT: _Z5caselbb {{.*}} 2       2   0.00%
+// REPORT: _Z5casembb {{.*}} 2       2   0.00%
+// REPORT: _Z5casenbb {{.*}} 2       2   0.00%
+// REPORT: TOTAL {{.*}} 40      28  30.00%

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.o32l -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}

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.o32l -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.o32l -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.o32l -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.o32l -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.o32l -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.o32l -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

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.o32l -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.o32l -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.o32l -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.o32l -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.o32l -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.o32l -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

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()) {
+      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.ShowOutputDirectory = ShowOutputDirectory;
   ViewOpts.TabSize = TabSize;
   ViewOpts.ProjectTitle = ProjectTitle;
 
   if (ViewOpts.hasOutputDirectory()) {

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/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/JSON.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.isCondIndepPairCovered(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";
 
   bool EmptyFiles = false;
   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 branches 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(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 void sumMCDCPairs(size_t &NumPairs, size_t &CoveredPairs,
+                         const ArrayRef<MCDCRecord> &Records) {
+  for (const auto &Record : Records)
+    for (unsigned c = 0; c < Record.getNumConditions(); c++) {
+      if (!Record.isCondFolded(c))
+        ++NumPairs;
+      if (Record.isCondIndepPairCovered(c))
+        ++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;
+  sumMCDCPairs(NumPairs, CoveredPairs, 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 ExportSummaryOnly;
   bool SkipExpansions;
   bool SkipFunctions;
   bool SkipBranches;
   OutputFormat Format;
   BranchOutputType ShowBranches;

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

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);
void CoveragePrinterHTML::emitFileSummary(raw_ostream &OS, StringRef SF,
   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");
 }
 
 Error CoveragePrinterHTML::createIndexFile(
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 = utostr(uint64_t(DecisionRegion.LineStart));
+    std::string ColNoStr = utostr(uint64_t(DecisionRegion.ColumnStart));
+    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.getConditionHdrStr(i);
+    }
+    OS << "\n";
+    OS << "  Executed MC/DC Test Vectors:\n\n     ";
+    OS << Record.getTestVectorHdrStr();
+    for (unsigned i = 0; i < Record.getNumTestVectors(); i++)
+      OS << Record.getTestVectorStr(i);
+    OS << "\n";
+    for (unsigned i = 0; i < Record.getNumConditions(); i++)
+      OS << Record.getCondCoverageStr(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.getConditionHdrStr(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.getTestVectorHdrStr();
+    for (unsigned i = 0; i < Record.getNumTestVectors(); i++) {
+      renderLinePrefix(OS, ViewDepth);
+      OS << Record.getTestVectorStr(i);
+    }
+    renderLinePrefix(OS, ViewDepth);
+    OS << "\n";
+    for (unsigned i = 0; i < Record.getNumConditions(); i++) {
+      renderLinePrefix(OS, ViewDepth);
+      OS << Record.getCondCoverageStr(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(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, 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;