[llvm-cov] Support directory layout in coverage reports

[AtomicGu]

Summary

This is a GSoC 2023 project (discourse link).

llvm-cov currently generates a single top-level index HTML file, which causes rendering scalability issues in large projects. This patch adds support for hierarchical directory structure into the HTML reports to solve scalability issues by introducing the following changes:

• Added a new command line option --show-directory-coverage for llvm-cov show. It works both for --format=html and --format=text.
• Two new classes: CoveragePrinterHTMLDirectory and CoveragePrinterTextDirectory was added to support the new option.
• A tool class DirectoryCoverageReport was added to support the two classes above.
• Updated the document.
• Added a new regression test for --show-directory-coverage.

Here is a coverage report preview of LLVM:

report1.7z109 MBDownload

[AtomicGu]

• [llvm-cov] Take advices from phosek and gulfem.

[AtomicGu]

• [llvm-cov] --show-directory_coverage for text.

I refactored the HTML printer and extract the recursion part into a common template method pattern class named "DirectoryCoverageReport".

Manual test is passed (both on linux and windows).

[gulfem]

In D151283#4505153, @AtomicGu wrote:

In D151283#4503401, @gulfem wrote:

Can we simplify the commit message? We do not need all the details in the commit message as we have them in the Discourse discussion. I would suggest something like: "llvm-cov currently generates a single top-level index HTML file, which causes rendering scalability issues in large projects. This patch adds support for hierarchical directory structure into the HTML reports to solve scalability issues."

Do you mean I should squash the commits into one single commit? I thought Phabricator would do this for me as I always use arc diff with origin/main. I'm not sure what should I do.

Current commit message looks like this:

[llvm-cov] Support a Hierarchical Structure for HTML Coverage Report Generating
   
> This is a GSoC23 project ([discourse link](https://discourse.llvm.org/t/coverage-support-a-hierarchical-directory-structure-in-generated-coverage-html-reports/68239/7)).

Clang supports [source-based coverage](https://clang.llvm.org/docs/SourceBasedCodeCoverage.html) that shows which lines of code are covered by the executed tests. It uses [llvm-profdata](https://llvm.org/docs/CommandGuide/llvm-profdata.html) and [llvm-cov](https://llvm.org/docs/CommandGuide/llvm-cov.html) tools to generate coverage reports. llvm-cov currently generates a single top-level index HTML file. For example, a single top-level directory [code coverage report](https://lab.llvm.org/coverage/coverage-reports/index.html) for LLVM repo is published on a coverage bot. Top-level indexing causes rendering scalability issues in large projects, such as [Fuchsia](https://fuchsia.dev). The goal of this project is to generate a hierarchical directory structure in generated coverage html reports to match the directory structure and solve scalability issues. Chromium uses its own [post-processing tools](https://source.chromium.org/chromium/chromium/tools/build/+/main:recipes/recipe_modules/code_coverage/resources/generate_coverage_metadata.py) to show a per-directory hierarchical structure for [coverage results](https://analysis.chromium.org/coverage/p/chromium). Similarly, [Lcov](https://llvm.org/reports/coverage/index.html), which is a graphical front-end [Gcov](https://gcc.gnu.org/onlinedocs/gcc/Gcov.html), provides a one-level directory structure to display coverage results.

Changes to the code:

- Added a new CoveragePrinterHTMLDirectory by inheriting the original CoveragePrinterHTML.
- Added a new command line option `--show-directory-coverage` to select the new CoveragePrinterHTMLDirectory.
- Updated the coverage report generating script of LLVM itself to use the new option.
- Updated the document.
- Added a new regression test for `--show-directory-coverage`.

Currently the new option only works with `--format=html`. There is a plan to support `--format=text` too in the future.

I'm suggesting removing the first paragraph:

[llvm-cov] Support directory layout in coverage reports 
    
This is a GSoC 2023 project ([discourse link](https://discourse.llvm.org/t/coverage-support-a-hierarchical-directory-structure-in-generated-coverage-html-reports/68239)).
 
llvm-cov currently generates a single top-level index HTML file, which causes rendering scalability issues in large projects. This patch adds support for hierarchical directory structure into the HTML reports to solve scalability issues by introducing the following changes:
 - Added a new CoveragePrinterHTMLDirectory by inheriting the original CoveragePrinterHTML.
 - Added a new command line option `--show-directory-coverage` to select the new CoveragePrinterHTMLDirectory.
 - Updated the coverage report generating script of LLVM itself to use the new option.
 - Updated the document.
 - Added a new regression test for `--show-directory-coverage`.
 
 Currently the new option only works with `--format=html`. There is a plan to support `--format=text` too in the future.

[AtomicGu]

• [llvm-cov] Add regression tests.

llvm-cov convert-for-testing not works for me. When I use it for program with multiple source files, the generated .covmapping file can not be read back by llvm-cov:

error: Failed to load coverage: 'main.covmapping': Malformed coverage data

So, I just include two program files (one for Linux and the other one for Windows) directly.

[AtomicGu]

@gulfem OK, I have updated the title and summary. I hope this will do.

[AtomicGu]

• [llvm-cov] Add regression tests.

I think they can pass the pre-merge checks now.

[phosek]

llvm/test/tools/llvm-cov/directory_coverage.test

1 ↗

(On Diff #539023)

That's not expected, I'd try to investigate this further. Did you build all the tools yourself from the latest revision? Did you enable zlib?

We definitely don't want to include the program file directly since that's going to be in the Git history forever and will take extra space.

[AtomicGu]

llvm/test/tools/llvm-cov/directory_coverage.test

1 ↗

(On Diff #539023)

I pulled the newest commit and tried again. The problem still exists.

I checked the CMakeCache.txt. LLVM_ENABLE_ZLIB is ON.

Here are the source code, program, profdata and covmapping files:

directory_coverage.tar.gz21 KBDownload

Commands to reproduce the issue:

llvm-cov report main.covmapping --instr-profile main.profdata

[gulfem]

llvm/test/tools/llvm-cov/directory_coverage.test

1 ↗

(On Diff #539023)

I was able to reproduce it locally. AFAICT, the error is thrown in the following line:
https://github.com/llvm/llvm-project/blob/main/llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp#L720

The issue seems about the filenames. I did not have much time to dig into that yet, but we might be uncovering an issue about convert-for-testing flag in llvm-cov.

[gulfem]

In D151283#4511131, @AtomicGu wrote:

@gulfem OK, I have updated the title and summary. I hope this will do.

Thanks, that looks better.

[AtomicGu]

• [llvm-cov] Add regression tests.

[AtomicGu]

• [llvm-cov] Use .covmapping files for tests.

[AtomicGu]

@gulfem @phosek Hi. Do I need to update the Release Notes to indicate the new llvm-cov functionality?

[AtomicGu]

This comment was removed by AtomicGu.

[AtomicGu]

Update differential based on D156611.

[AtomicGu]

llvm/tools/llvm-cov/CoverageReport.cpp

578

@gulfem @phosek Any advises for this problem?

[AtomicGu]

Rebase to D156611.

[AtomicGu]

Linux tests passed.

[AtomicGu]

• Pass windows tests and fix COFF support of convert-for-testing.
• Disable name compression of directory_coverage.linux.test

[AtomicGu]

@phosek @gulfem All tests have been passed. The patch is ready to land, unless you may want to check this problem: https://reviews.llvm.org/D151283#inline-1531509 .

[gulfem]

llvm/tools/llvm-cov/CoverageReport.cpp

578

Can you use sys::path::native to convert the path to native path? I looked at native_separators.c test:
https://github.com/llvm/llvm-project/blob/main/llvm/test/tools/llvm-cov/native_separators.c

It's a Windows test, but its *.covmapping file input does not include backslashes for the filenames because it converts the path read to native path:
https://github.com/llvm/llvm-project/blob/main/llvm/test/tools/llvm-cov/Inputs/native_separators.covmapping

So, what I was thinking is that you can have two separate tests directory_coverage.linux.test and directory_coverage.win.test, but they use the same inputs for *.profdata and *.covmapping files. Do you think that would work? If not, having two separate files with their own inputs should be fine.

[AtomicGu]

llvm/tools/llvm-cov/CoverageReport.cpp

578

Actually there's another difference between the two tests: the linux test uses absolute path in the .covmapping file but the windows test uses relative path.

The key problem here is: do we want to support generating reports for inputs of different platforms? I think native_separators.c answers "yes", so I will follow it.

[phosek]

llvm/tools/llvm-cov/CoverageReport.cpp

578

Yes, I think so, we don't currently restrict handling of inputs to a particular platform so this would be a regression. I agree that using sys::path::native to convert all paths to native format is likely the right approach.

[AtomicGu]

• Use same input for linux and windows test.

[AtomicGu]

• Use sys::path::native to suport showing on different platforms.

[phosek]

llvm/docs/CommandGuide/llvm-cov.rst

254–256

I think this would be a better summary of what this flag does.

llvm/tools/llvm-cov/CoverageReport.cpp

563

Rather than using an assert which would be compiled out when assertions are disabled, I'd consider returning an Error in this case.

llvm/tools/llvm-cov/CoverageReport.h

104

129

Is there a reason for using an operator here rather than a regular method?

[AtomicGu]

llvm/tools/llvm-cov/CoverageReport.cpp

563

This assertion is to prevent coding errors. In a correctly written program, it cannot fail. All its callers, prepareSubDirectoryReports and prepareDirectoryReports, won't pass an empty Files to it. The only exception is that the prepareDirectoryReports is used incorrectly. So, I think returning an` Error` is unnecessary and might cause runtime overhead, potentially delaying the discovery of bugs.

llvm/tools/llvm-cov/CoverageReport.h

129

No. I was thinking this class would be used like functions, but so far it's not. I'm going to rename it to generateSubDirectoryReport.

[AtomicGu]

• Rename operator()() and revise comments.

[AtomicGu]

@phosek @gulfem The tests finished. I think we can land the patch now. One test failed because of timeout, but it has nothing to do with this patch.

[AtomicGu]

Retry per-merge checks.

[AtomicGu]

Acturally, I have got the commit access from Chris (😊). But I'm not sure how to do that. Accroding to the documentation: https://llvm.org/docs/Contributing.html#commit-from-git . Should I use git push to commit? How to squash all the commits into a single one and set the commit message correctly? Does arc have some automatic commands?

[phosek]

llvm/utils/prepare-code-coverage-artifact.py

70

Would it be possible to drop this change from this patch and do it as a separate change? That way, if the coverage bot breaks for some reason, we can only revert a much smaller change rather than having to revert this entire change.

[AtomicGu]

llvm/utils/prepare-code-coverage-artifact.py

70

Nice advice. So thoughtful of you! I will do this.

[AtomicGu]

• Revert llvm/utils/prepare-code-coverage-artifact.py

llvm/docs/CommandGuide/llvm-cov.rst

  the character where the region starts. Defaults to false.
 
 .. option:: -show-line-counts-or-regions
 
  Show the execution counts for each line if there is only one region on the
  line, but show the individual regions if there are multiple on the line.
  Defaults to false.
 
+.. option:: -show-directory-coverage
+
+ Generate index files in each level of the directory to show the coverage.
+ Defaults to false and a single index file will be generated in the output
+ directory.
+
 .. option:: -use-color
 
  Enable or disable color output. By default this is autodetected.
 
 .. option:: -arch=[*NAMES*]
 
  Specify a list of architectures such that the Nth entry in the list
  corresponds to the Nth specified binary. If the covered object is a universal

llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp

static Error readCoverageMappingData(
   // In Version4, function records are not affixed to coverage headers. Read
   // the records from their dedicated section.
   if (Version >= CovMapVersion::Version4)
     return Reader->readFunctionRecords(FuncRecBuf, FuncRecBufEnd, std::nullopt,
                                        nullptr, nullptr);
   return Error::success();
 }
 
-static const char *TestingFormatMagic = "llvmcovmtestdata";
+// Use last character to indicate the version. The first version use
+// letter 'a' for historical reasons.
+static const char TestingFormatMagic[] = "llvmcovmtestdat";
+static const char TestingFormatVersions[] = {'a', '2'};
 
 Expected<std::unique_ptr<BinaryCoverageReader>>
 BinaryCoverageReader::createCoverageReaderFromBuffer(
     StringRef Coverage, FuncRecordsStorage &&FuncRecords,
     InstrProfSymtab &&ProfileNames, uint8_t BytesInAddress,
     support::endianness Endian, StringRef CompilationDir) {
   std::unique_ptr<BinaryCoverageReader> Reader(
       new BinaryCoverageReader(std::move(FuncRecords)));
BinaryCoverageReader::createCoverageReaderFromBuffer(
   return std::move(Reader);
 }
 
 static Expected<std::unique_ptr<BinaryCoverageReader>>
 loadTestingFormat(StringRef Data, StringRef CompilationDir) {
   uint8_t BytesInAddress = 8;
   support::endianness Endian = support::endianness::little;
 
-  Data = Data.substr(StringRef(TestingFormatMagic).size());
+  Data = Data.substr(sizeof(TestingFormatMagic) - 1);
+  auto TestingFormat = Data.front();
+  Data = Data.substr(1);
   if (Data.empty())
     return make_error<CoverageMapError>(coveragemap_error::truncated);
   unsigned N = 0;
   uint64_t ProfileNamesSize = decodeULEB128(Data.bytes_begin(), &N);
   if (N > Data.size())
     return make_error<CoverageMapError>(coveragemap_error::malformed);
   Data = Data.substr(N);
   if (Data.empty())
     return make_error<CoverageMapError>(coveragemap_error::truncated);
   N = 0;
   uint64_t Address = decodeULEB128(Data.bytes_begin(), &N);
   if (N > Data.size())
     return make_error<CoverageMapError>(coveragemap_error::malformed);
   Data = Data.substr(N);
   if (Data.size() < ProfileNamesSize)
     return make_error<CoverageMapError>(coveragemap_error::malformed);
   InstrProfSymtab ProfileNames;
   if (Error E = ProfileNames.create(Data.substr(0, ProfileNamesSize), Address))
     return std::move(E);
   Data = Data.substr(ProfileNamesSize);
+
+  StringRef CoverageMapping;
+  BinaryCoverageReader::FuncRecordsStorage CoverageRecords;
+  if (TestingFormat == TestingFormatVersions[0]) {
     // Skip the padding bytes because coverage map data has an alignment of 8.
     size_t Pad = offsetToAlignedAddr(Data.data(), Align(8));
     if (Data.size() < Pad)
       return make_error<CoverageMapError>(coveragemap_error::malformed);
     Data = Data.substr(Pad);
     if (Data.size() < sizeof(CovMapHeader))
       return make_error<CoverageMapError>(coveragemap_error::malformed);
     auto const *CovHeader = reinterpret_cast<const CovMapHeader *>(
         Data.substr(0, sizeof(CovMapHeader)).data());
     CovMapVersion Version =
         (CovMapVersion)CovHeader->getVersion<support::endianness::little>();
-  StringRef CoverageMapping;
-  BinaryCoverageReader::FuncRecordsStorage CoverageRecords;
     if (Version < CovMapVersion::Version4) {
       CoverageMapping = Data;
       if (CoverageMapping.empty())
         return make_error<CoverageMapError>(coveragemap_error::truncated);
       CoverageRecords = MemoryBuffer::getMemBuffer("");
     } else {
       uint32_t FilenamesSize =
           CovHeader->getFilenamesSize<support::endianness::little>();
       uint32_t CoverageMappingSize = sizeof(CovMapHeader) + FilenamesSize;
       CoverageMapping = Data.substr(0, CoverageMappingSize);
       if (CoverageMapping.empty())
         return make_error<CoverageMapError>(coveragemap_error::truncated);
       Data = Data.substr(CoverageMappingSize);
       // Skip the padding bytes because coverage records data has an alignment
       // of 8.
       Pad = offsetToAlignedAddr(Data.data(), Align(8));
       if (Data.size() < Pad)
         return make_error<CoverageMapError>(coveragemap_error::malformed);
       CoverageRecords = MemoryBuffer::getMemBuffer(Data.substr(Pad));
       if (CoverageRecords->getBufferSize() == 0)
         return make_error<CoverageMapError>(coveragemap_error::truncated);
     }
+  } else if (TestingFormat == TestingFormatVersions[1]) {
+    N = 0;
+    auto CoverageMappingSize = decodeULEB128(Data.bytes_begin(), &N);
+    if (N > Data.size())
+      return make_error<CoverageMapError>(coveragemap_error::malformed);
+    Data = Data.substr(N);
+
+    // Skip the padding bytes because coverage map data has an alignment of 8.
+    size_t Pad = offsetToAlignedAddr(Data.data(), Align(8));
+    if (Data.size() < Pad)
+      return make_error<CoverageMapError>(coveragemap_error::malformed);
+    Data = Data.substr(Pad);
+    if (Data.size() < CoverageMappingSize)
+      return make_error<CoverageMapError>(coveragemap_error::malformed);
+    StringRef CoverageMapping = Data.substr(0, CoverageMappingSize);
+    Data = Data.substr(CoverageMappingSize);
+
+    // Skip the padding bytes because coverage records data has an alignment
+    // of 8.
+    Pad = offsetToAlignedAddr(Data.data(), Align(8));
+    if (Data.size() < Pad)
+      return make_error<CoverageMapError>(coveragemap_error::malformed);
+    Data = Data.substr(Pad);
+    BinaryCoverageReader::FuncRecordsStorage CoverageRecords =
+        MemoryBuffer::getMemBuffer(Data);
+
+    // Some extra checking.
+    if (CoverageMapping.size() < sizeof(CovMapHeader))
+      return make_error<CoverageMapError>(coveragemap_error::truncated);
+    auto const *CovHeader =
+        reinterpret_cast<const CovMapHeader *>(CoverageMapping.data());
+    CovMapVersion Version =
+        (CovMapVersion)CovHeader->getVersion<support::endianness::little>();
+    if (Version < CovMapVersion::Version4) {
+      if (CoverageRecords->getBufferSize() != 0)
+        return make_error<CoverageMapError>(coveragemap_error::malformed);
+    } else {
+      if (CoverageRecords->getBufferSize() == 0)
+        return make_error<CoverageMapError>(coveragemap_error::truncated);
+    }
+  } else
+    return make_error<CoverageMapError>(coveragemap_error::malformed);
+
   return BinaryCoverageReader::createCoverageReaderFromBuffer(
       CoverageMapping, std::move(CoverageRecords), std::move(ProfileNames),
       BytesInAddress, Endian, CompilationDir);
 }
 
 /// Find all sections that match \p Name. There may be more than one if comdats
 /// are in use, e.g. for the __llvm_covfun section on ELF.
 static Expected<std::vector<SectionRef>> lookupSections(ObjectFile &OF,

llvm/test/tools/llvm-cov/Inputs/directory_coverage/a0/a1/a2.cc

+#include "../../header.h"
+
+template<>
+bool equal<int>(int a, int b)
+{
+  return a == b;
+}

llvm/test/tools/llvm-cov/Inputs/directory_coverage/b0/b1.h

+int add(int a, int b);
+
+int sub(int a, int b);

llvm/test/tools/llvm-cov/Inputs/directory_coverage/b0/b1_1.cc

+#include "b1.h"
+
+int add(int a, int b) {
+  return a + b;
+}

llvm/test/tools/llvm-cov/Inputs/directory_coverage/b0/b1_2.cc

+#include "b1.h"
+
+int sub(int a, int b) {
+  return a - b;
+}

llvm/test/tools/llvm-cov/Inputs/directory_coverage/c0/c1/c2.h

+int mul(int a, int b);
+
+int div(int a, int b);
+
+#ifdef DEF
+int div(int a, int b) {
+  return a / b;
+}
+#endif

llvm/test/tools/llvm-cov/Inputs/directory_coverage/c0/c1/c2_1.cc

+int mul(int a, int b) {
+  return a * b;
+}

llvm/test/tools/llvm-cov/Inputs/directory_coverage/c0/c1/c2_2.cc

+#define DEF
+#include "c2.h"

llvm/test/tools/llvm-cov/Inputs/directory_coverage/header.h

+#include "b0/b1.h"
+#include "c0/c1/c2.h"
+
+template<typename T>
+bool equal(T a, T b);

llvm/test/tools/llvm-cov/Inputs/directory_coverage/main.cc

+#include "header.h"
+
+int main() {
+  int a = 3;
+  int b = 4;
+  int c = c = add(a, b);
+  int d = mul(a, b);
+  return equal(a, sub(c, b)) - equal(a, div(d, b));
+}

llvm/test/tools/llvm-cov/directory_coverage.linux.test

+# REQUIRES: system-linux
+# RUN: mkdir -p %t
+
+# RUN: llvm-cov show %S/Inputs/directory_coverage/main.linux.covmapping \
+# RUN:   --instr-profile %S/Inputs/directory_coverage/main.linux.profdata \
+# RUN:   --path-equivalence=/tmp/directory_coverage,%S/Inputs/directory_coverage \
+# RUN:   --format=text --show-directory-coverage -o %t/report-text
+
+# RUN: llvm-cov show %S/Inputs/directory_coverage/main.linux.covmapping \
+# RUN:   --instr-profile %S/Inputs/directory_coverage/main.linux.profdata \
+# RUN:   --path-equivalence=/tmp/directory_coverage,%S/Inputs/directory_coverage \
+# RUN:   --format=html --show-directory-coverage -o %t/report-html
+
+# RUN: FileCheck --input-file %t/report-text/index.txt %s --check-prefix=ROOT
+# RUN: FileCheck --input-file %t/report-text/coverage/tmp/directory_coverage/index.txt %s --check-prefix=ROOT
+# RUN: FileCheck --input-file %t/report-text/coverage/tmp/directory_coverage/b0/index.txt %s --check-prefix=B0
+# RUN: FileCheck --input-file %t/report-text/coverage/tmp/directory_coverage/c0/c1/index.txt %s --check-prefix=C1
+
+# RUN: FileCheck --input-file %t/report-html/index.html %s --check-prefix=HTML-TOP --allow-empty
+# RUN: FileCheck --input-file %t/report-html/coverage/tmp/directory_coverage/index.html %s --check-prefix=ROOT
+# RUN: FileCheck --input-file %t/report-html/coverage/tmp/directory_coverage/b0/index.html %s --check-prefix=B0
+# RUN: FileCheck --input-file %t/report-html/coverage/tmp/directory_coverage/c0/c1/index.html %s --check-prefix=C1
+
+
+
+# HTML-TOP: coverage/index.html
+
+# ROOT: a0/a1/a2.cc
+# ROOT: b0/
+# ROOT-NOT: b1_1.cc
+# ROOT-NOT: b1_2.cc
+# ROOT: c0/c1/
+# ROOT-NOT: c2_1.cc
+# ROOT-NOT: b2_2.cc
+# ROOT: main.cc
+
+# B0: b1_1.cc
+# B0: b1_2.cc
+
+# C1: c2_1.cc
+# C1: c2.h
+
+
+For regenerating the test:
+
+cp -r %S/Inputs/directory_coverage /tmp
+clang -fprofile-instr-generate -fcoverage-mapping -o main main.cc a0/a1/a2.cc b0/b1_1.cc b0/b1_2.cc c0/c1/c2_1.cc c0/c1/c2_2.cc
+./main
+llvm-cov convert-for-testing main -o main.linux.covmapping
+llvm-profdata merge default.profraw -o main.linux.profdata
+rm default.profraw

llvm/test/tools/llvm-cov/directory_coverage.win.test

+# REQUIRES: system-windows
+# RUN: mkdir -p %t
+
+# RUN: llvm-cov show %S/Inputs/directory_coverage/main.win.covmapping \
+# RUN:   --instr-profile %S/Inputs/directory_coverage/main.win.profdata \
+# RUN:   --path-equivalence=.,%S/Inputs/directory_coverage \
+# RUN:   --format=text --show-directory-coverage -o %t/report-text
+
+# RUN: llvm-cov show %S/Inputs/directory_coverage/main.win.covmapping \
+# RUN:   --instr-profile %S/Inputs/directory_coverage/main.win.profdata \
+# RUN:   --path-equivalence=.,%S/Inputs/directory_coverage \
+# RUN:   --format=html --show-directory-coverage -o %t/report-html
+
+# RUN: FileCheck --input-file %t/report-text/index.txt %s --check-prefix=ROOT
+# RUN: FileCheck --input-file %t/report-text/coverage/index.txt %s --check-prefix=ROOT
+# RUN: FileCheck --input-file %t/report-text/coverage/b0/index.txt %s --check-prefix=B0
+# RUN: FileCheck --input-file %t/report-text/coverage/c0/c1/index.txt %s --check-prefix=C1
+
+# RUN: FileCheck --input-file %t/report-html/index.html %s --check-prefix=HTML-TOP --allow-empty
+# RUN: FileCheck --input-file %t/report-html/coverage/index.html %s --check-prefix=ROOT
+# RUN: FileCheck --input-file %t/report-html/coverage/b0/index.html %s --check-prefix=B0
+# RUN: FileCheck --input-file %t/report-html/coverage/c0/c1/index.html %s --check-prefix=C1
+
+
+
+# HTML-TOP: coverage\index.html
+
+# ROOT: a0\a1\a2.cc
+# ROOT: b0\
+# ROOT-NOT: b1_1.cc
+# ROOT-NOT: b1_2.cc
+# ROOT: c0\c1\
+# ROOT-NOT: c2_1.cc
+# ROOT-NOT: b2_2.cc
+# ROOT: main.cc
+
+# B0: b1_1.cc
+# B0: b1_2.cc
+
+# C1: c2_1.cc
+# C1: c2.h
+
+
+For regenerating the test:
+
+cd %S\Inputs\directory_coverage
+clang -fprofile-instr-generate -fcoverage-mapping "-fcoverage-prefix-map=$PWD=." -o main.exe main.cc a0\a1\a2.cc b0\b1_1.cc b0\b1_2.cc c0\c1\c2_1.cc c0\c1\c2_2.cc
+.\main.exe
+llvm-cov convert-for-testing main.exe -o main.win.covmapping
+llvm-profdata merge default.profraw -o main.win.profdata
+rm main.exe default.profraw

llvm/tools/llvm-cov/CodeCoverage.cpp

int CodeCoverageTool::doShow(int argc, const char **argv,
   cl::opt<bool> ShowExpansions("show-expansions", cl::Optional,
                                cl::desc("Show expanded source regions"),
                                cl::cat(ViewCategory));
 
   cl::opt<bool> ShowInstantiations("show-instantiations", cl::Optional,
                                    cl::desc("Show function instantiations"),
                                    cl::init(true), cl::cat(ViewCategory));
 
+  cl::opt<bool> ShowDirectoryCoverage("show-directory-coverage", cl::Optional,
+                                      cl::desc("Show directory coverage"),
+                                      cl::cat(ViewCategory));
+
   cl::opt<std::string> ShowOutputDirectory(
       "output-dir", cl::init(""),
       cl::desc("Directory in which coverage information is written out"));
   cl::alias ShowOutputDirectoryA("o", cl::desc("Alias for --output-dir"),
                                  cl::aliasopt(ShowOutputDirectory));
 
   cl::opt<uint32_t> TabSize(
       "tab-size", cl::init(2),
ViewOpts.ShowLineStats = ShowLineExecutionCounts.getNumOccurrences() != 0 ||
                            !ShowRegions || ShowBestLineRegionsCounts;
   ViewOpts.ShowRegionMarkers = ShowRegions || ShowBestLineRegionsCounts;
   ViewOpts.ShowExpandedRegions = ShowExpansions;
   ViewOpts.ShowBranchCounts =
       ShowBranches == CoverageViewOptions::BranchOutputType::Count;
   ViewOpts.ShowBranchPercents =
       ShowBranches == CoverageViewOptions::BranchOutputType::Percent;
   ViewOpts.ShowFunctionInstantiations = ShowInstantiations;
+  ViewOpts.ShowDirectoryCoverage = ShowDirectoryCoverage;
   ViewOpts.ShowOutputDirectory = ShowOutputDirectory;
   ViewOpts.TabSize = TabSize;
   ViewOpts.ProjectTitle = ProjectTitle;
 
   if (ViewOpts.hasOutputDirectory()) {
     if (auto E = sys::fs::create_directories(ViewOpts.ShowOutputDirectory)) {
       error("Could not create output directory!", E.message());
       return 1;

llvm/tools/llvm-cov/CoverageReport.h

 #define LLVM_COV_COVERAGEREPORT_H
 
 #include "CoverageFilters.h"
 #include "CoverageSummaryInfo.h"
 #include "CoverageViewOptions.h"
 
 namespace llvm {
 
+class ThreadPool;
+
 /// Displays the code coverage report.
 class CoverageReport {
   const CoverageViewOptions &Options;
   const coverage::CoverageMapping &Coverage;
 
   void render(const FileCoverageSummary &File, raw_ostream &OS) const;
   void render(const FunctionCoverageSummary &Function, const DemangleCache &DC,
               raw_ostream &OS) const;
public:
   /// Prepare file reports for the files specified in \p Files.
   static std::vector<FileCoverageSummary>
   prepareFileReports(const coverage::CoverageMapping &Coverage,
                      FileCoverageSummary &Totals, ArrayRef<std::string> Files,
                      const CoverageViewOptions &Options,
                      const CoverageFilter &Filters = CoverageFiltersMatchAll());
 
   static void
   prepareSingleFileReport(const StringRef Filename,
                           const coverage::CoverageMapping *Coverage,
                           const CoverageViewOptions &Options,
                           const unsigned LCP,
                           FileCoverageSummary *FileReport,
                           const CoverageFilter *Filters);
 
   /// Render file reports for every unique file in the coverage mapping.
   void renderFileReports(raw_ostream &OS,
                          const CoverageFilters &IgnoreFilenameFilters) const;
 
   /// Render file reports for the files specified in \p Files.
   void renderFileReports(raw_ostream &OS, ArrayRef<std::string> Files) const;
 
   /// Render file reports for the files specified in \p Files and the functions
   /// in \p Filters.
   void renderFileReports(raw_ostream &OS, ArrayRef<std::string> Files,
                          const CoverageFiltersMatchAll &Filters) const;
+
+  /// Render file reports with given data.
+  void renderFileReports(raw_ostream &OS,
+                         const std::vector<FileCoverageSummary> &FileReports,
+                         const FileCoverageSummary &Totals,
+                         bool ShowEmptyFiles) const;
+};
+
+/// Prepare reports for every non-trivial directories (which have more than 1
+/// source files) of the source files. This class uses template method pattern.
+class DirectoryCoverageReport {
+public:
+  DirectoryCoverageReport(
+      const CoverageViewOptions &Options,
+      const coverage::CoverageMapping &Coverage,
+      const CoverageFiltersMatchAll &Filters = CoverageFiltersMatchAll())
+      : Options(Options), Coverage(Coverage), Filters(Filters) {}
+
+  virtual ~DirectoryCoverageReport() = default;
+
+  /// Prepare file reports for each directory in \p SourceFiles. The total
+  /// report for all files is returned and its Name is set to the LCP of all
+  /// files. The size of \p SourceFiles must be greater than 1 or else the
+  /// behavior is undefined, in which case you should use
+  /// `CoverageReport::prepareSingleFileReport` instead. If an error occurs,
+  /// the recursion will stop immediately.
+  Expected<FileCoverageSummary>
+  prepareDirectoryReports(ArrayRef<std::string> SourceFiles);
+
+protected:
+  // These member variables below are used for avoiding being passed
+  // repeatedly in recursion.
+  const CoverageViewOptions &Options;
+  const coverage::CoverageMapping &Coverage;
+  const CoverageFiltersMatchAll &Filters;
+
+  // For calling CoverageReport::prepareSingleFileReport asynchronously
+  // in prepareSubDirectoryReports. It's not disigned to be changed by
+  // operator().
+  ThreadPool *TPool;
+
+  // One report level may correspond to multiple directory levels as we omit
+  // directories which have only one subentry. So we use this Stack to track
+  // each report level's corresponding drectory level.
+  // Each value in the stack is the LCP prefix length length of that report
+  // level. LCPStack.front() is the root LCP. Current LCP is LCPStack.back().
+  SmallVector<unsigned, 32> LCPStack;
+
+  using SubFileReports = StringMap<FileCoverageSummary>;
+  using SubDirReports =
+      StringMap<std::pair<FileCoverageSummary, SmallVector<StringRef, 0>>>;
+
+  /// This method is called when a report level is prepared during the
+  /// recursion. \p SubFiles are the reports for those files directly in the
+  /// current directory. \p SubDirs are the reports for subdirectories in
+  /// current directory. \p SubTotals is the sum of all, and its name is the
+  /// current LCP. Note that this method won't be called for trivial
+  /// directories. FileCoverageSummary::Name will be set to the relative path
+  /// of current LCP. For trivial directories, the name will be set to the
+  /// relative path of the only file in that directory.
+  virtual Error operator()(SubFileReports &&SubFiles, SubDirReports &&SubDirs,
+                           FileCoverageSummary &&SubTotals) = 0;
+
+private:
+  Error prepareSubDirectoryReports(const ArrayRef<StringRef> &Files,
+                                   FileCoverageSummary *Totals);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_COV_COVERAGEREPORT_H

llvm/tools/llvm-cov/CoverageReport.cpp

unsigned getRedundantPrefixLen(ArrayRef<std::string> Paths) {
   for (unsigned I = 0; I < NumRedundant; ++I) {
     auto LastComponent = Component;
     ++Component;
     PrefixLen += Component - LastComponent;
   }
   return PrefixLen;
 }
 
+/// Determine the length of the longest redundant prefix of the substrs starts
+/// from \p LCP in \p Paths. \p Paths can't be empty. If there's only one
+/// element in \p Paths, the length of the substr is returned. Note this is
+/// differnet from the behavior of the function above.
+unsigned getRedundantPrefixLen(ArrayRef<StringRef> Paths, unsigned LCP) {
+  assert(!Paths.empty() && "Paths must have at least one element");
+
+  auto Iter = Paths.begin();
+  auto IterE = Paths.end();
+  auto First = Iter->substr(LCP);
+  SmallVector<StringRef, 16> CommonComponents{sys::path::begin(First),
+                                              sys::path::end(First)};
+  unsigned Len = First.size() - LCP;
+  while (++Iter != IterE) {
+    auto Substr = Iter->substr(LCP);
+    auto I = sys::path::begin(Substr);
+    auto E = sys::path::end(Substr);
+
+    unsigned Index = 0;
+    while (I != E) {
+      if (Index >= CommonComponents.size())
+        break;
+      if (CommonComponents[Index] != *I) {
+        CommonComponents.resize(Index);
+        Len = I - sys::path::begin(Substr);
+        break;
+      }
+      ++Index, ++I;
+    }
+  }
+
+  return Len;
+}
+
 } // end anonymous namespace
 
 namespace llvm {
 
 void CoverageReport::render(const FileCoverageSummary &File,
                             raw_ostream &OS) const {
   auto FileCoverageColor =
       determineCoveragePercentageColor(File.RegionCoverage);
   auto FuncCoverageColor =
       determineCoveragePercentageColor(File.FunctionCoverage);
   auto InstantiationCoverageColor =
       determineCoveragePercentageColor(File.InstantiationCoverage);
   auto LineCoverageColor = determineCoveragePercentageColor(File.LineCoverage);
   SmallString<256> FileName = File.Name;
-  sys::path::remove_dots(FileName, /*remove_dot_dot=*/true);
   sys::path::native(FileName);
+
+  // remove_dots will remove trailing slash, so we need to check before it.
+  auto IsDir = FileName.endswith(sys::path::get_separator());
+  sys::path::remove_dots(FileName, /*remove_dot_dot=*/true);
+  if (IsDir)
+    FileName += sys::path::get_separator();
+
   OS << column(FileName, FileReportColumns[0], Column::NoTrim);
 
   if (Options.ShowRegionSummary) {
     OS << format("%*u", FileReportColumns[1],
                  (unsigned)File.RegionCoverage.getNumRegions());
     Options.colored_ostream(OS, FileCoverageColor)
         << format("%*u", FileReportColumns[2],
                   (unsigned)(File.RegionCoverage.getNumRegions() -

 }
 
 void CoverageReport::renderFileReports(
     raw_ostream &OS, ArrayRef<std::string> Files,
     const CoverageFiltersMatchAll &Filters) const {
   FileCoverageSummary Totals("TOTAL");
   auto FileReports =
       prepareFileReports(Coverage, Totals, Files, Options, Filters);
+  renderFileReports(OS, FileReports, Totals, Filters.empty());
+}
 
+void CoverageReport::renderFileReports(
+    raw_ostream &OS, const std::vector<FileCoverageSummary> &FileReports,
+    const FileCoverageSummary &Totals, bool ShowEmptyFiles) const {
   std::vector<StringRef> Filenames;
   Filenames.reserve(FileReports.size());
   for (const FileCoverageSummary &FCS : FileReports)
     Filenames.emplace_back(FCS.Name);
   adjustColumnWidths(Filenames, {});
 
   OS << column("Filename", FileReportColumns[0]);
   if (Options.ShowRegionSummary)
if (Options.ShowBranchSummary)
     OS << column("Branches", FileReportColumns[13], Column::RightAlignment)
        << column("Missed Branches", FileReportColumns[14],
                  Column::RightAlignment)
        << column("Cover", FileReportColumns[15], Column::RightAlignment);
   OS << "\n";
   renderDivider(FileReportColumns, OS);
   OS << "\n";
 
-  bool EmptyFiles = false;
+  std::vector<const FileCoverageSummary *> EmptyFiles;
   for (const FileCoverageSummary &FCS : FileReports) {
     if (FCS.FunctionCoverage.getNumFunctions())
       render(FCS, OS);
     else
-      EmptyFiles = true;
+      EmptyFiles.push_back(&FCS);
   }
 
-  if (EmptyFiles && Filters.empty()) {
+  if (!EmptyFiles.empty() && ShowEmptyFiles) {
     OS << "\n"
        << "Files which contain no functions:\n";
 
-    for (const FileCoverageSummary &FCS : FileReports)
-      if (!FCS.FunctionCoverage.getNumFunctions())
-        render(FCS, OS);
+    for (auto FCS : EmptyFiles)
+      render(*FCS, OS);
   }
 
   renderDivider(FileReportColumns, OS);
   OS << "\n";
   render(Totals, OS);
 }
 
+Expected<FileCoverageSummary> DirectoryCoverageReport::prepareDirectoryReports(
+    ArrayRef<std::string> SourceFiles) {
+  std::vector<StringRef> Files(SourceFiles.begin(), SourceFiles.end());
+
+  unsigned RootLCP = getRedundantPrefixLen(Files, 0);
+  auto LCPath = Files.front().substr(0, RootLCP);
+
+  ThreadPoolStrategy PoolS = hardware_concurrency(Options.NumThreads);
+  if (Options.NumThreads == 0) {
+    PoolS = heavyweight_hardware_concurrency(Files.size());
+    PoolS.Limit = true;
+  }
+  ThreadPool Pool(PoolS);
+
+  TPool = &Pool;
+  LCPStack = {RootLCP};
+  FileCoverageSummary RootTotals(LCPath);
+  if (auto E = prepareSubDirectoryReports(Files, &RootTotals))
+    return {std::move(E)};
+  return {std::move(RootTotals)};
+}
+
+/// Filter out files in `LCPStack.back()`, group others by subdirectory name
+/// and recurse on them. After returning from all subdirectories, call
+/// `operator()`. \p Files must be non-empty. The FileCoverageSummary of this
+/// directory will be added to \p Totals.
+Error DirectoryCoverageReport::prepareSubDirectoryReports(
+    const ArrayRef<StringRef> &Files, FileCoverageSummary *Totals) {
+  assert(!Files.empty() && "Only works when Files is not empty");
+
+  auto LCP = LCPStack.back();
+  auto LCPath = Files.front().substr(0, LCP).str();
+
+  // Use ordered map to keep entries in order.
+  SubFileReports SubFiles;
+  SubDirReports SubDirs;
+  for (auto &&File : Files) {
+    auto SubPath = File.substr(LCPath.size());
+
+    auto I = sys::path::begin(SubPath);
+    auto E = sys::path::end(SubPath);
+    assert(I != E && "Such case should have been filtered out in the caller");
+
+    // What if we report a Windows exe on Linux? In this case, all files will
+    // be considered be directly in the project root directory as Linux allows
+    // file names have backslash in them. So, only one report level will be
+    // generated. We can't distinguish whether a string is a Windows path or a
+    // strange Linux path, although the latter is very rare. So, A choice must
+    // be made: to support such uncommon usage, or to be fully correct. We
+    // choose the latter.
+
+    auto Name = *I;
+    if (++I == E) {
+      auto Iter = SubFiles.insert_or_assign(Name, SubPath).first;
+      // Makes files reporting overlap with subdir reporting.
+      TPool->async(&CoverageReport::prepareSingleFileReport, File, &Coverage,
+                   Options, LCP, &Iter->second, &Filters);
+    } else {
+      SubDirs[Name].second.push_back(File);
+    }
+  }
+
+  // Call recursively on subdirectories.
+  for (auto &&KV : SubDirs) {
+    auto &V = KV.second;
+    if (V.second.size() == 1) {
+      // If there's only one file in that subdirectory, we don't bother to
+      // recurse on it further.
+      V.first.Name = V.second.front().substr(LCP);
+      TPool->async(&CoverageReport::prepareSingleFileReport, V.second.front(),
+                   &Coverage, Options, LCP, &V.first, &Filters);
+    } else {
+      auto SubDirLCP = getRedundantPrefixLen(V.second, LCP);
+      V.first.Name = V.second.front().substr(LCP, SubDirLCP);
+      LCPStack.push_back(LCP + SubDirLCP);
+      if (auto E = prepareSubDirectoryReports(V.second, &V.first))
+        return E;
+    }
+  }
+
+  TPool->wait();
+
+  FileCoverageSummary CurrentTotals(LCPath);
+  for (auto &&KV : SubFiles)
+    CurrentTotals += KV.second;
+  for (auto &&KV : SubDirs)
+    CurrentTotals += KV.second.first;
+  *Totals += CurrentTotals;
+
+  if (auto E = operator()(std::move(SubFiles), std::move(SubDirs),
+                          std::move(CurrentTotals)))
+    return E;
+
+  LCPStack.pop_back();
+  return Error::success();
+}
+
 } // end namespace llvm

llvm/tools/llvm-cov/CoverageSummaryInfo.h

 struct FileCoverageSummary {
   StringRef Name;
   RegionCoverageInfo RegionCoverage;
   LineCoverageInfo LineCoverage;
   BranchCoverageInfo BranchCoverage;
   FunctionCoverageInfo FunctionCoverage;
   FunctionCoverageInfo InstantiationCoverage;
 
+  FileCoverageSummary() = default;
   FileCoverageSummary(StringRef Name) : Name(Name) {}
 
   FileCoverageSummary &operator+=(const FileCoverageSummary &RHS) {
     RegionCoverage += RHS.RegionCoverage;
     LineCoverage += RHS.LineCoverage;
     FunctionCoverage += RHS.FunctionCoverage;
     BranchCoverage += RHS.BranchCoverage;
     InstantiationCoverage += RHS.InstantiationCoverage;

llvm/tools/llvm-cov/CoverageViewOptions.h

struct CoverageViewOptions {
   bool ShowBranchCounts;
   bool ShowBranchPercents;
   bool ShowExpandedRegions;
   bool ShowFunctionInstantiations;
   bool ShowFullFilenames;
   bool ShowBranchSummary;
   bool ShowRegionSummary;
   bool ShowInstantiationSummary;
+  bool ShowDirectoryCoverage;
   bool ExportSummaryOnly;
   bool SkipExpansions;
   bool SkipFunctions;
   bool SkipBranches;
   OutputFormat Format;
   BranchOutputType ShowBranches;
   std::string ShowOutputDirectory;
   std::vector<std::string> DemanglerOpts;

llvm/tools/llvm-cov/SourceCoverageView.h

public:
   using OwnedStream = std::unique_ptr<raw_ostream, StreamDestructor>;
 
 protected:
   const CoverageViewOptions &Opts;
 
   CoveragePrinter(const CoverageViewOptions &Opts) : Opts(Opts) {}
 
   /// Return `OutputDir/ToplevelDir/Path.Extension`. If \p InToplevel is
-  /// false, skip the ToplevelDir component. If \p Relative is false, skip the
+  /// true, skip the ToplevelDir component. If \p Relative is true, skip the
   /// OutputDir component.
   std::string getOutputPath(StringRef Path, StringRef Extension,
                             bool InToplevel, bool Relative = true) const;
 
   /// If directory output is enabled, create a file in that directory
   /// at the path given by getOutputPath(). Otherwise, return stdout.
   Expected<OwnedStream> createOutputStream(StringRef Path, StringRef Extension,
                                            bool InToplevel) const;

llvm/tools/llvm-cov/SourceCoverageView.cpp

if (E)
     return errorCodeToError(E);
   return std::move(OS);
 }
 
 std::unique_ptr<CoveragePrinter>
 CoveragePrinter::create(const CoverageViewOptions &Opts) {
   switch (Opts.Format) {
   case CoverageViewOptions::OutputFormat::Text:
+    if (Opts.ShowDirectoryCoverage)
+      return std::make_unique<CoveragePrinterTextDirectory>(Opts);
     return std::make_unique<CoveragePrinterText>(Opts);
   case CoverageViewOptions::OutputFormat::HTML:
+    if (Opts.ShowDirectoryCoverage)
+      return std::make_unique<CoveragePrinterHTMLDirectory>(Opts);
     return std::make_unique<CoveragePrinterHTML>(Opts);
   case CoverageViewOptions::OutputFormat::Lcov:
     // Unreachable because CodeCoverage.cpp should terminate with an error
     // before we get here.
     llvm_unreachable("Lcov format is not supported!");
   }
   llvm_unreachable("Unknown coverage output format!");
 }
 

llvm/tools/llvm-cov/SourceCoverageViewHTML.h

 #define LLVM_COV_SOURCECOVERAGEVIEWHTML_H
 
 #include "SourceCoverageView.h"
 
 namespace llvm {
 
 using namespace coverage;
 
+class ThreadPool;
+
 struct FileCoverageSummary;
 
 /// A coverage printer for html output.
 class CoveragePrinterHTML : public CoveragePrinter {
 public:
   Expected<OwnedStream> createViewFile(StringRef Path,
                                        bool InToplevel) override;
 
   void closeViewFile(OwnedStream OS) override;
 
   Error createIndexFile(ArrayRef<std::string> SourceFiles,
                         const coverage::CoverageMapping &Coverage,
                         const CoverageFiltersMatchAll &Filters) override;
 
   CoveragePrinterHTML(const CoverageViewOptions &Opts)
       : CoveragePrinter(Opts) {}
 
+protected:
+  Error emitStyleSheet();
+  void emitReportHeader(raw_ostream &OSRef, const std::string &Title);
+
 private:
   void emitFileSummary(raw_ostream &OS, StringRef SF,
                        const FileCoverageSummary &FCS,
                        bool IsTotals = false) const;
   std::string buildLinkToFile(StringRef SF,
                               const FileCoverageSummary &FCS) const;
 };
 
+/// A coverage printer for html output, but generates index files in every
+/// subdirectory to show a hierarchical view.
+class CoveragePrinterHTMLDirectory : public CoveragePrinterHTML {
+public:
+  using CoveragePrinterHTML::CoveragePrinterHTML;
+
+  Error createIndexFile(ArrayRef<std::string> SourceFiles,
+                        const coverage::CoverageMapping &Coverage,
+                        const CoverageFiltersMatchAll &Filters) override;
+
+private:
+  struct Reporter;
+};
+
 /// A code coverage view which supports html-based rendering.
 class SourceCoverageViewHTML : public SourceCoverageView {
   void renderViewHeader(raw_ostream &OS) override;
 
   void renderViewFooter(raw_ostream &OS) override;
 
   void renderSourceName(raw_ostream &OS, bool WholeFile) override;
 

llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp

 //===- SourceCoverageViewHTML.cpp - A html code coverage view -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file This file implements the html coverage renderer.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "CoverageReport.h"
 #include "SourceCoverageViewHTML.h"
+#include "CoverageReport.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/ThreadPool.h"
 #include <optional>
 
 using namespace llvm;
 
 namespace {
 
 // Return a string with the special characters in \p Str escaped.
 std::string escape(StringRef Str, const CoverageViewOptions &Opts) {
std::string escape(StringRef Str, const CoverageViewOptions &Opts) {
   {
     raw_string_ostream OS{EscapedHTML};
     printHTMLEscaped(TabExpandedResult, OS);
   }
   return EscapedHTML;
 }
 
 // Create a \p Name tag around \p Str, and optionally set its \p ClassName.
-std::string tag(const std::string &Name, const std::string &Str,
-                const std::string &ClassName = "") {
-  std::string Tag = "<" + Name;
-  if (!ClassName.empty())
-    Tag += " class='" + ClassName + "'";
-  return Tag + ">" + Str + "</" + Name + ">";
+std::string tag(StringRef Name, StringRef Str, StringRef ClassName = "") {
+  std::string Tag = "<";
+  Tag += Name;
+  if (!ClassName.empty()) {
+    Tag += " class='";
+    Tag += ClassName;
+    Tag += "'";
+  }
+  Tag += ">";
+  Tag += Str;
+  Tag += "</";
+  Tag += Name;
+  Tag += ">";
+  return Tag;
 }
 
 // Create an anchor to \p Link with the label \p Str.
-std::string a(const std::string &Link, const std::string &Str,
-              const std::string &TargetName = "") {
-  std::string Name = TargetName.empty() ? "" : ("name='" + TargetName + "' ");
-  return "<a " + Name + "href='" + Link + "'>" + Str + "</a>";
+std::string a(StringRef Link, StringRef Str, StringRef TargetName = "") {
+  std::string Tag;
+  Tag += "<a ";
+  if (!TargetName.empty()) {
+    Tag += "name='";
+    Tag += TargetName;
+    Tag += "' ";
+  }
+  Tag += "href='";
+  Tag += Link;
+  Tag += "'>";
+  Tag += Str;
+  Tag += "</a>";
+  return Tag;
 }
 
 const char *BeginHeader =
     "<head>"
     "<meta name='viewport' content='width=device-width,initial-scale=1'>"
     "<meta charset='UTF-8'>";
 
 const char *CSSForCoverage =
     R"(.red {
   background-color: #ffd0d0;
 }
 .cyan {
if (PathToStyle.empty())
     OS << "<style>" << CSSForCoverage << "</style>";
   else
     OS << "<link rel='stylesheet' type='text/css' href='"
        << escape(PathToStyle, Opts) << "'>";
 
   OS << EndHeader << "<body>";
 }
 
+void emitTableRow(raw_ostream &OS, const CoverageViewOptions &Opts,
+                  const std::string &FirstCol, const FileCoverageSummary &FCS,
+                  bool IsTotals) {
+  SmallVector<std::string, 8> Columns;
+
+  // Format a coverage triple and add the result to the list of columns.
+  auto AddCoverageTripleToColumn =
+      [&Columns, &Opts](unsigned Hit, unsigned Total, float Pctg) {
+        std::string S;
+        {
+          raw_string_ostream RSO{S};
+          if (Total)
+            RSO << format("%*.2f", 7, Pctg) << "% ";
+          else
+            RSO << "- ";
+          RSO << '(' << Hit << '/' << Total << ')';
+        }
+        const char *CellClass = "column-entry-yellow";
+        if (Pctg >= Opts.HighCovWatermark)
+          CellClass = "column-entry-green";
+        else if (Pctg < Opts.LowCovWatermark)
+          CellClass = "column-entry-red";
+        Columns.emplace_back(tag("td", tag("pre", S), CellClass));
+      };
+
+  Columns.emplace_back(tag("td", tag("pre", FirstCol)));
+  AddCoverageTripleToColumn(FCS.FunctionCoverage.getExecuted(),
+                            FCS.FunctionCoverage.getNumFunctions(),
+                            FCS.FunctionCoverage.getPercentCovered());
+  if (Opts.ShowInstantiationSummary)
+    AddCoverageTripleToColumn(FCS.InstantiationCoverage.getExecuted(),
+                              FCS.InstantiationCoverage.getNumFunctions(),
+                              FCS.InstantiationCoverage.getPercentCovered());
+  AddCoverageTripleToColumn(FCS.LineCoverage.getCovered(),
+                            FCS.LineCoverage.getNumLines(),
+                            FCS.LineCoverage.getPercentCovered());
+  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 (IsTotals)
+    OS << tag("tr", join(Columns.begin(), Columns.end(), ""), "light-row-bold");
+  else
+    OS << tag("tr", join(Columns.begin(), Columns.end(), ""), "light-row");
+}
+
 void emitEpilog(raw_ostream &OS) {
   OS << "</body>"
      << "</html>";
 }
 
 } // anonymous namespace
 
 Expected<CoveragePrinter::OwnedStream>
CoveragePrinterHTML::buildLinkToFile(StringRef SF,
   sys::path::remove_dots(LinkTextStr, /*remove_dot_dot=*/true);
   sys::path::native(LinkTextStr);
   std::string LinkText = escape(LinkTextStr, Opts);
   std::string LinkTarget =
       escape(getOutputPath(SF, "html", /*InToplevel=*/false), Opts);
   return a(LinkTarget, LinkText);
 }
 
+Error CoveragePrinterHTML::emitStyleSheet() {
+  auto CSSOrErr = createOutputStream("style", "css", /*InToplevel=*/true);
+  if (Error E = CSSOrErr.takeError())
+    return E;
+
+  OwnedStream CSS = std::move(CSSOrErr.get());
+  CSS->operator<<(CSSForCoverage);
+
+  return Error::success();
+}
+
+void CoveragePrinterHTML::emitReportHeader(raw_ostream &OSRef,
+                                           const std::string &Title) {
+  // Emit some basic information about the coverage report.
+  if (Opts.hasProjectTitle())
+    OSRef << tag(ProjectTitleTag, escape(Opts.ProjectTitle, Opts));
+  OSRef << tag(ReportTitleTag, Title);
+  if (Opts.hasCreatedTime())
+    OSRef << tag(CreatedTimeTag, escape(Opts.CreatedTimeStr, Opts));
+
+  // Emit a link to some documentation.
+  OSRef << tag("p", "Click " +
+                        a("http://clang.llvm.org/docs/"
+                          "SourceBasedCodeCoverage.html#interpreting-reports",
+                          "here") +
+                        " for information about interpreting this report.");
+
+  // Emit a table containing links to reports for each file in the covmapping.
+  // Exclude files which don't contain any regions.
+  OSRef << BeginCenteredDiv << BeginTable;
+  emitColumnLabelsForIndex(OSRef, Opts);
+}
+
 /// Render a file coverage summary (\p FCS) in a table row. If \p IsTotals is
 /// false, link the summary to \p SF.
 void CoveragePrinterHTML::emitFileSummary(raw_ostream &OS, StringRef SF,
                                           const FileCoverageSummary &FCS,
                                           bool IsTotals) const {
-  SmallVector<std::string, 8> Columns;
-
-  // Format a coverage triple and add the result to the list of columns.
-  auto AddCoverageTripleToColumn =
-      [&Columns, this](unsigned Hit, unsigned Total, float Pctg) {
-        std::string S;
-        {
-          raw_string_ostream RSO{S};
-          if (Total)
-            RSO << format("%*.2f", 7, Pctg) << "% ";
-          else
-            RSO << "- ";
-          RSO << '(' << Hit << '/' << Total << ')';
-        }
-        const char *CellClass = "column-entry-yellow";
-        if (Pctg >= Opts.HighCovWatermark)
-          CellClass = "column-entry-green";
-        else if (Pctg < Opts.LowCovWatermark)
-          CellClass = "column-entry-red";
-        Columns.emplace_back(tag("td", tag("pre", S), CellClass));
-      };
-
   // Simplify the display file path, and wrap it in a link if requested.
   std::string Filename;
   if (IsTotals) {
     Filename = std::string(SF);
   } else {
     Filename = buildLinkToFile(SF, FCS);
   }
 
-  Columns.emplace_back(tag("td", tag("pre", Filename)));
-  AddCoverageTripleToColumn(FCS.FunctionCoverage.getExecuted(),
-                            FCS.FunctionCoverage.getNumFunctions(),
-                            FCS.FunctionCoverage.getPercentCovered());
-  if (Opts.ShowInstantiationSummary)
-    AddCoverageTripleToColumn(FCS.InstantiationCoverage.getExecuted(),
-                              FCS.InstantiationCoverage.getNumFunctions(),
-                              FCS.InstantiationCoverage.getPercentCovered());
-  AddCoverageTripleToColumn(FCS.LineCoverage.getCovered(),
-                            FCS.LineCoverage.getNumLines(),
-                            FCS.LineCoverage.getPercentCovered());
-  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 (IsTotals)
-    OS << tag("tr", join(Columns.begin(), Columns.end(), ""), "light-row-bold");
-  else
-    OS << tag("tr", join(Columns.begin(), Columns.end(), ""), "light-row");
+  emitTableRow(OS, Opts, Filename, FCS, IsTotals);
 }
 
 Error CoveragePrinterHTML::createIndexFile(
     ArrayRef<std::string> SourceFiles, const CoverageMapping &Coverage,
     const CoverageFiltersMatchAll &Filters) {
   // Emit the default stylesheet.
-  auto CSSOrErr = createOutputStream("style", "css", /*InToplevel=*/true);
-  if (Error E = CSSOrErr.takeError())
+  if (Error E = emitStyleSheet())
     return E;
 
-  OwnedStream CSS = std::move(CSSOrErr.get());
-  CSS->operator<<(CSSForCoverage);
-
   // Emit a file index along with some coverage statistics.
   auto OSOrErr = createOutputStream("index", "html", /*InToplevel=*/true);
   if (Error E = OSOrErr.takeError())
     return E;
   auto OS = std::move(OSOrErr.get());
   raw_ostream &OSRef = *OS.get();
 
   assert(Opts.hasOutputDirectory() && "No output directory for index file");
   emitPrelude(OSRef, Opts, getPathToStyle(""));
 
-  // Emit some basic information about the coverage report.
-  if (Opts.hasProjectTitle())
-    OSRef << tag(ProjectTitleTag, escape(Opts.ProjectTitle, Opts));
-  OSRef << tag(ReportTitleTag, "Coverage Report");
-  if (Opts.hasCreatedTime())
-    OSRef << tag(CreatedTimeTag, escape(Opts.CreatedTimeStr, Opts));
-
-  // Emit a link to some documentation.
-  OSRef << tag("p", "Click " +
-                        a("http://clang.llvm.org/docs/"
-                          "SourceBasedCodeCoverage.html#interpreting-reports",
-                          "here") +
-                        " for information about interpreting this report.");
+  emitReportHeader(OSRef, "Coverage Report");
 
-  // Emit a table containing links to reports for each file in the covmapping.
-  // Exclude files which don't contain any regions.
-  OSRef << BeginCenteredDiv << BeginTable;
-  emitColumnLabelsForIndex(OSRef, Opts);
   FileCoverageSummary Totals("TOTALS");
   auto FileReports = CoverageReport::prepareFileReports(
       Coverage, Totals, SourceFiles, Opts, Filters);
   bool EmptyFiles = false;
   for (unsigned I = 0, E = FileReports.size(); I < E; ++I) {
     if (FileReports[I].FunctionCoverage.getNumFunctions())
       emitFileSummary(OSRef, SourceFiles[I], FileReports[I]);
     else
       EmptyFiles = true;
   }
   emitFileSummary(OSRef, "Totals", Totals, /*IsTotals=*/true);
   OSRef << EndTable << EndCenteredDiv;
 
   // Emit links to files which don't contain any functions. These are normally
   // not very useful, but could be relevant for code which abuses the
   // preprocessor.
   if (EmptyFiles && Filters.empty()) {
     OSRef << tag("p", "Files which contain no functions. (These "
                       "files contain code pulled into other files "
                       "by the preprocessor.)\n");
     OSRef << BeginCenteredDiv << BeginTable;
     for (unsigned I = 0, E = FileReports.size(); I < E; ++I)
       if (!FileReports[I].FunctionCoverage.getNumFunctions()) {
         std::string Link = buildLinkToFile(SourceFiles[I], FileReports[I]);
         OSRef << tag("tr", tag("td", tag("pre", Link)), "light-row") << '\n';
       }
     OSRef << EndTable << EndCenteredDiv;
   }
 
   OSRef << tag("h5", escape(Opts.getLLVMVersionString(), Opts));
   emitEpilog(OSRef);
 
   return Error::success();
 }
 
+struct CoveragePrinterHTMLDirectory::Reporter : public DirectoryCoverageReport {
+  CoveragePrinterHTMLDirectory &Printer;
+
+  Reporter(CoveragePrinterHTMLDirectory &Printer,
+           const coverage::CoverageMapping &Coverage,
+           const CoverageFiltersMatchAll &Filters)
+      : DirectoryCoverageReport(Printer.Opts, Coverage, Filters),
+        Printer(Printer) {}
+
+  Error operator()(SubFileReports &&SubFiles, SubDirReports &&SubDirs,
+                   FileCoverageSummary &&SubTotals) override {
+    auto &LCPath = SubTotals.Name;
+    assert(Options.hasOutputDirectory() &&
+           "No output directory for index file");
+
+    SmallString<128> OSPath = LCPath;
+    sys::path::append(OSPath, "index");
+    auto OSOrErr = Printer.createOutputStream(OSPath, "html",
+                                              /*InToplevel=*/false);
+    if (auto E = OSOrErr.takeError())
+      return E;
+    auto OS = std::move(OSOrErr.get());
+    raw_ostream &OSRef = *OS.get();
+
+    auto IndexHtmlPath = Printer.getOutputPath((LCPath + "index").str(), "html",
+                                               /*InToplevel=*/false);
+    emitPrelude(OSRef, Options, getPathToStyle(IndexHtmlPath));
+
+    auto NavLink = buildTitleLinks(LCPath);
+    Printer.emitReportHeader(OSRef, "Coverage Report (" + NavLink + ")");
+
+    std::vector<const FileCoverageSummary *> EmptyFiles;
+
+    // Make directories at the top of the table.
+    for (auto &&SubDir : SubDirs) {
+      auto &Report = SubDir.second.first;
+      if (!Report.FunctionCoverage.getNumFunctions())
+        EmptyFiles.push_back(&Report);
+      else
+        emitTableRow(OSRef, Options, buildRelLinkToFile(Report.Name), Report,
+                     /*IsTotals=*/false);
+    }
+
+    for (auto &&SubFile : SubFiles) {
+      auto &Report = SubFile.second;
+      if (!Report.FunctionCoverage.getNumFunctions())
+        EmptyFiles.push_back(&Report);
+      else
+        emitTableRow(OSRef, Options, buildRelLinkToFile(Report.Name), Report,
+                     /*IsTotals=*/false);
+    }
+
+    // Emit the totals row.
+    emitTableRow(OSRef, Options, "Totals", SubTotals, /*IsTotals=*/false);
+    OSRef << EndTable << EndCenteredDiv;
+
+    // Emit links to files which don't contain any functions. These are normally
+    // not very useful, but could be relevant for code which abuses the
+    // preprocessor.
+    if (!EmptyFiles.empty()) {
+      OSRef << tag("p", "Files which contain no functions. (These "
+                        "files contain code pulled into other files "
+                        "by the preprocessor.)\n");
+      OSRef << BeginCenteredDiv << BeginTable;
+      for (auto FCS : EmptyFiles) {
+        auto Link = buildRelLinkToFile(FCS->Name);
+        OSRef << tag("tr", tag("td", tag("pre", Link)), "light-row") << '\n';
+      }
+      OSRef << EndTable << EndCenteredDiv;
+    }
+
+    // Emit epilog.
+    OSRef << tag("h5", escape(Options.getLLVMVersionString(), Options));
+    emitEpilog(OSRef);
+
+    return Error::success();
+  }
+
+  /// Make a title with hyperlinks to the index.html files of each hierarchy
+  /// of the report.
+  std::string buildTitleLinks(StringRef LCPath) const {
+    // For each report level in LCPStack, extract the path component and
+    // calculate the number of "../" relative to current LCPath.
+    SmallVector<std::pair<SmallString<128>, unsigned>, 16> Components;
+
+    auto Iter = LCPStack.begin(), IterE = LCPStack.end();
+    SmallString<128> RootPath;
+    if (*Iter == 0) {
+      // If llvm-cov works on relative coverage mapping data, the LCP of
+      // all source file paths can be 0, which makes the title path empty.
+      // As we like adding a slash at the back of the path to indicate a
+      // directory, in this case, we use "." as the root path to make it
+      // not be confused with the root path "/".
+      RootPath = ".";
+    } else {
+      RootPath = LCPath.substr(0, *Iter);
+      sys::path::native(RootPath);
+      sys::path::remove_dots(RootPath, /*remove_dot_dot=*/true);
+    }
+    Components.emplace_back(std::move(RootPath), 0);
+
+    for (auto Last = *Iter; ++Iter != IterE; Last = *Iter) {
+      SmallString<128> SubPath = LCPath.substr(Last, *Iter - Last);
+      sys::path::native(SubPath);
+      sys::path::remove_dots(SubPath, /*remove_dot_dot=*/true);
+      auto Level = unsigned(SubPath.count(sys::path::get_separator())) + 1;
+      Components.back().second += Level;
+      Components.emplace_back(std::move(SubPath), Level);
+    }
+
+    // Then we make the title accroding to Components.
+    std::string S;
+    for (auto I = Components.begin(), E = Components.end();;) {
+      auto &Name = I->first;
+      if (++I == E) {
+        S += a("./index.html", Name);
+        S += sys::path::get_separator();
+        break;
+      }
+
+      SmallString<128> Link;
+      for (unsigned J = I->second; J > 0; --J)
+        Link += "../";
+      Link += "index.html";
+      S += a(Link, Name);
+      S += sys::path::get_separator();
+    }
+    return S;
+  }
+
+  std::string buildRelLinkToFile(StringRef RelPath) const {
+    SmallString<128> LinkTextStr(RelPath);
+    sys::path::native(LinkTextStr);
+
+    // remove_dots will remove trailing slash, so we need to check before it.
+    auto IsDir = LinkTextStr.endswith(sys::path::get_separator());
+    sys::path::remove_dots(LinkTextStr, /*remove_dot_dot=*/true);
+
+    SmallString<128> LinkTargetStr(LinkTextStr);
+    if (IsDir) {
+      LinkTextStr += sys::path::get_separator();
+      sys::path::append(LinkTargetStr, "index.html");
+    } else {
+      LinkTargetStr += ".html";
+    }
+
+    auto LinkText = escape(LinkTextStr, Options);
+    auto LinkTarget = escape(LinkTargetStr, Options);
+    return a(LinkTarget, LinkText);
+  }
+};
+
+Error CoveragePrinterHTMLDirectory::createIndexFile(
+    ArrayRef<std::string> SourceFiles, const CoverageMapping &Coverage,
+    const CoverageFiltersMatchAll &Filters) {
+  // The createSubIndexFile function only works when SourceFiles is
+  // more than one. So we fallback to CoveragePrinterHTML when it is.
+  if (SourceFiles.size() <= 1)
+    return CoveragePrinterHTML::createIndexFile(SourceFiles, Coverage, Filters);
+
+  // Emit the default stylesheet.
+  if (Error E = emitStyleSheet())
+    return E;
+
+  // Emit index files in every subdirectory.
+  Reporter Report(*this, Coverage, Filters);
+  auto TotalsOrErr = Report.prepareDirectoryReports(SourceFiles);
+  if (auto E = TotalsOrErr.takeError())
+    return E;
+  auto &LCPath = TotalsOrErr->Name;
+
+  // Emit the top level index file. Top level index file is just a redirection
+  // to the index file in the LCP directory.
+  auto OSOrErr = createOutputStream("index", "html", /*InToplevel=*/true);
+  if (auto E = OSOrErr.takeError())
+    return E;
+  auto OS = std::move(OSOrErr.get());
+  auto LCPIndexFilePath =
+      getOutputPath((LCPath + "index").str(), "html", /*InToplevel=*/false);
+  *OS.get() << R"(<!DOCTYPE html>
+  <html>
+    <head>
+      <meta http-equiv="Refresh" content="0; url=')"
+            << LCPIndexFilePath << R"('" />
+    </head>
+    <body></body>
+  </html>
+  )";
+
+  return Error::success();
+}
+
 void SourceCoverageViewHTML::renderViewHeader(raw_ostream &OS) {
   OS << BeginCenteredDiv << BeginTable;
 }
 
 void SourceCoverageViewHTML::renderViewFooter(raw_ostream &OS) {
   OS << EndTable << EndCenteredDiv;
 }
 
 void SourceCoverageViewHTML::renderSourceName(raw_ostream &OS, bool WholeFile) {
   OS << BeginSourceNameDiv << tag("pre", escape(getSourceName(), getOptions()))
      << EndSourceNameDiv;
 }
 
 void SourceCoverageViewHTML::renderLinePrefix(raw_ostream &OS, unsigned) {
   OS << "<tr>";
 }
 
 void SourceCoverageViewHTML::renderLineSuffix(raw_ostream &OS, unsigned) {
   // If this view has sub-views, renderLine() cannot close the view's cell.
   // Take care of it here, after all sub-views have been rendered.
   if (hasSubViews())
     OS << EndCodeTD;
   OS << "</tr>";
 }
 
 void SourceCoverageViewHTML::renderViewDivider(raw_ostream &, unsigned) {
   // The table-based output makes view dividers unnecessary.
 }
 
 void SourceCoverageViewHTML::renderLine(raw_ostream &OS, LineRef L,
for (unsigned I = 0, E = Segments.size() - 1; I < E; ++I) {
       const auto *CurSeg = Segments[I];
       if (!CurSeg->IsRegionEntry)
         continue;
       if (CurSeg->Count == LCS.getExecutionCount())
         continue;
 
       Snippets[I + 1] =
           tag("div", Snippets[I + 1] + tag("span", formatCount(CurSeg->Count),
                                            "tooltip-content"),
               "tooltip");
 
       if (getOptions().Debug)
         errs() << "Marker at " << CurSeg->Line << ":" << CurSeg->Col << " = "
                << formatCount(CurSeg->Count) << "\n";
     }
   }
 

llvm/tools/llvm-cov/SourceCoverageViewText.h

public:
   Error createIndexFile(ArrayRef<std::string> SourceFiles,
                         const CoverageMapping &Coverage,
                         const CoverageFiltersMatchAll &Filters) override;
 
   CoveragePrinterText(const CoverageViewOptions &Opts)
       : CoveragePrinter(Opts) {}
 };
 
+/// A coverage printer for text output, but generates index files in every
+/// subdirectory to show a hierarchical view. The implementation is similar
+/// to CoveragePrinterHTMLDirectory. So please refer to that for more comments.
+class CoveragePrinterTextDirectory : public CoveragePrinterText {
+public:
+  using CoveragePrinterText::CoveragePrinterText;
+
+  Error createIndexFile(ArrayRef<std::string> SourceFiles,
+                        const CoverageMapping &Coverage,
+                        const CoverageFiltersMatchAll &Filters) override;
+
+private:
+  struct Reporter;
+};
+
 /// A code coverage view which supports text-based rendering.
 class SourceCoverageViewText : public SourceCoverageView {
   void renderViewHeader(raw_ostream &OS) override;
 
   void renderViewFooter(raw_ostream &OS) override;
 
   void renderSourceName(raw_ostream &OS, bool WholeFile) override;
 

llvm/tools/llvm-cov/SourceCoverageViewText.cpp

 //===- SourceCoverageViewText.cpp - A text-based code coverage view -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file This file implements the text-based coverage renderer.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "SourceCoverageViewText.h"
 #include "CoverageReport.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/Path.h"
 #include <optional>
 
 using namespace llvm;
 
 Expected<CoveragePrinter::OwnedStream>
 CoveragePrinterText::createViewFile(StringRef Path, bool InToplevel) {
   return createOutputStream(Path, "txt", InToplevel);
 }
Error CoveragePrinterText::createIndexFile(
   Report.renderFileReports(OSRef, SourceFiles, Filters);
 
   Opts.colored_ostream(OSRef, raw_ostream::CYAN) << "\n"
                                                  << Opts.getLLVMVersionString();
 
   return Error::success();
 }
 
+struct CoveragePrinterTextDirectory::Reporter : public DirectoryCoverageReport {
+  CoveragePrinterTextDirectory &Printer;
+
+  Reporter(CoveragePrinterTextDirectory &Printer,
+           const coverage::CoverageMapping &Coverage,
+           const CoverageFiltersMatchAll &Filters)
+      : DirectoryCoverageReport(Printer.Opts, Coverage, Filters),
+        Printer(Printer) {}
+
+  Error operator()(SubFileReports &&SubFiles, SubDirReports &&SubDirs,
+                   FileCoverageSummary &&SubTotals) override {
+    auto &LCPath = SubTotals.Name;
+    assert(Options.hasOutputDirectory() &&
+           "No output directory for index file");
+
+    SmallString<128> OSPath = LCPath;
+    sys::path::append(OSPath, "index");
+    auto OSOrErr = Printer.createOutputStream(OSPath, "txt",
+                                              /*InToplevel=*/false);
+    if (auto E = OSOrErr.takeError())
+      return E;
+    auto OS = std::move(OSOrErr.get());
+    raw_ostream &OSRef = *OS.get();
+
+    std::vector<FileCoverageSummary> Reports;
+    for (auto &&SubDir : SubDirs)
+      Reports.push_back(std::move(SubDir.second.first));
+    for (auto &&SubFile : SubFiles)
+      Reports.push_back(std::move(SubFile.second));
+
+    CoverageReport Report(Options, Coverage);
+    Report.renderFileReports(OSRef, Reports, SubTotals, Filters.empty());
+
+    Options.colored_ostream(OSRef, raw_ostream::CYAN)
+        << "\n"
+        << Options.getLLVMVersionString();
+
+    return Error::success();
+  }
+};
+
+Error CoveragePrinterTextDirectory::createIndexFile(
+    ArrayRef<std::string> SourceFiles, const CoverageMapping &Coverage,
+    const CoverageFiltersMatchAll &Filters) {
+  if (SourceFiles.size() <= 1)
+    return CoveragePrinterText::createIndexFile(SourceFiles, Coverage, Filters);
+
+  Reporter Report(*this, Coverage, Filters);
+  auto TotalsOrErr = Report.prepareDirectoryReports(SourceFiles);
+  if (auto E = TotalsOrErr.takeError())
+    return E;
+  auto &LCPath = TotalsOrErr->Name;
+
+  auto TopIndexFilePath =
+      getOutputPath("index", "txt", /*InToplevel=*/true, /*Relative=*/false);
+  auto LCPIndexFilePath =
+      getOutputPath((LCPath + "index").str(), "txt", /*InToplevel=*/false,
+                    /*Relative=*/false);
+  return errorCodeToError(
+      sys::fs::copy_file(LCPIndexFilePath, TopIndexFilePath));
+}
+
 namespace {
 
 static const unsigned LineCoverageColumnWidth = 7;
 static const unsigned LineNumberColumnWidth = 5;
 
 /// Get the width of the leading columns.
 unsigned getCombinedColumnWidth(const CoverageViewOptions &Opts) {
   return (Opts.ShowLineStats ? LineCoverageColumnWidth + 1 : 0) +

llvm/tools/llvm-cov/TestingSupport.cpp

 //===- TestingSupport.cpp - Convert objects files into test files --------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Object/COFF.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Support/Alignment.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
if (BytesInAddress != 8) {
     errs() << "error: 64 bit binary expected\n";
     return 1;
   }
 
   // Look for the sections that we are interested in.
   int FoundSectionCount = 0;
   SectionRef ProfileNames, CoverageMapping, CoverageRecords;
   auto ObjFormat = OF->getTripleObjectFormat();
+
+  auto ProfileNamesSection = getInstrProfSectionName(IPSK_name, ObjFormat,
+                                                     /*AddSegmentInfo=*/false);
+  auto CoverageMappingSection =
+      getInstrProfSectionName(IPSK_covmap, ObjFormat, /*AddSegmentInfo=*/false);
+  auto CoverageRecordsSection =
+      getInstrProfSectionName(IPSK_covfun, ObjFormat, /*AddSegmentInfo=*/false);
+  if (isa<object::COFFObjectFile>(OF)) {
+    // On COFF, the object file section name may end in "$M". This tells the
+    // linker to sort these sections between "$A" and "$Z". The linker removes
+    // the dollar and everything after it in the final binary. Do the same to
+    // match.
+    auto Strip = [](std::string &Str) {
+      auto Pos = Str.find('$');
+      if (Pos != std::string::npos)
+        Str.resize(Pos);
+    };
+    Strip(ProfileNamesSection);
+    Strip(CoverageMappingSection);
+    Strip(CoverageRecordsSection);
+  }
+
   for (const auto &Section : OF->sections()) {
     StringRef Name;
     if (Expected<StringRef> NameOrErr = Section.getName()) {
       Name = *NameOrErr;
     } else {
       consumeError(NameOrErr.takeError());
       return 1;
     }
 
-    if (Name == llvm::getInstrProfSectionName(IPSK_name, ObjFormat,
-                                              /*AddSegmentInfo=*/false)) {
+    if (Name == ProfileNamesSection)
       ProfileNames = Section;
-    } else if (Name == llvm::getInstrProfSectionName(
-                           IPSK_covmap, ObjFormat, /*AddSegmentInfo=*/false)) {
+    else if (Name == CoverageMappingSection)
       CoverageMapping = Section;
-    } else if (Name == llvm::getInstrProfSectionName(
-                           IPSK_covfun, ObjFormat, /*AddSegmentInfo=*/false)) {
+    else if (Name == CoverageRecordsSection)
       CoverageRecords = Section;
-    } else
+    else
       continue;
     ++FoundSectionCount;
   }
   if (FoundSectionCount != 3)
     return 1;
 
   // Get the contents of the given sections.
   uint64_t ProfileNamesAddress = ProfileNames.getAddress();
int convertForTestingMain(int argc, const char *argv[]) {
 
   int FD;
   if (auto Err = sys::fs::openFileForWrite(OutputFilename, FD)) {
     errs() << "error: " << Err.message() << "\n";
     return 1;
   }
 
   raw_fd_ostream OS(FD, true);
-  OS << "llvmcovmtestdata";
+  OS << "llvmcovmtestdat2";
   encodeULEB128(ProfileNamesData.size(), OS);
   encodeULEB128(ProfileNamesAddress, OS);
   OS << ProfileNamesData;
+  encodeULEB128(CoverageMappingData.size(), OS);
   // Coverage mapping data is expected to have an alignment of 8.
   for (unsigned Pad = offsetToAlignment(OS.tell(), Align(8)); Pad; --Pad)
     OS.write(uint8_t(0));
   OS << CoverageMappingData;
   // Coverage records data is expected to have an alignment of 8.
   for (unsigned Pad = offsetToAlignment(OS.tell(), Align(8)); Pad; --Pad)
     OS.write(uint8_t(0));
   OS << CoverageRecordsData;
 
   return 0;
 }

llvm/utils/prepare-code-coverage-artifact.py

invocation = (
         + [
             "-format",
             "html",
             "-instr-profile",
             profile,
             "-o",
             report_dir,
             "-show-line-counts-or-regions",
+            "-show-directory-coverage",
             "-Xdemangler",
             "c++filt",
             "-Xdemangler",
             "-n",
         ]
         + restricted_dirs
     )
     if compilation_dir: