[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

[gulfem]

It can be useful to add an option for hierarchical directory structure like other coverage viewing options (https://github.com/llvm/llvm-project/blob/main/llvm/tools/llvm-cov/CoverageViewOptions.h#L30) to be able to turn it on/off:

llvm/tools/llvm-cov/CoverageReport.h

47

Can you please make sure that you only format the lines that you change, and not format the file whole file? This makes it easier for the reviewers to see the actual changes instead of formatting changes? AFAICT, most of the changes in CoverageReport.h and CoverageReport.cpp are formatting changes.

llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp

503

When the directory contains a single file, it is added to Files, but all the FileReports for Files are previously generated at line 494. So, there won't be any report generated for a single file in a directory.

[AtomicGu]

llvm/tools/llvm-cov/CoverageReport.h

47

Can you please make sure that you only format the lines that you change, and not format the file whole file? This makes it easier for the reviewers to see the actual changes instead of formatting changes? AFAICT, most of the changes in CoverageReport.h and CoverageReport.cpp are formatting changes.

47

Sorry, this is done by clang-format automatically. I will figure this out in the next commit.

llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp

503

Thank you! You are right, this is a mistake. I was too careless. I will solve this in the next commit.

[gulfem]

llvm/tools/llvm-cov/SourceCoverageViewHTML.h

47

createTopLevelIndexFile might be a better name.

[AtomicGu]

• [llvm-cov] Finish my new CoveragePrinter.
• [llvm-cov] Manual test passed

[AtomicGu]

llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp

503

The problem has been fixed in the new implementation.

llvm/tools/llvm-cov/SourceCoverageViewHTML.h

47

This function is to create index file in each subdirectory recursivly. I'm not sure the name "TopLevel" is more proper?

[AtomicGu]

llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp

571

This line has changed to LCP = sys::path::parent_path(SourceFiles.front()).size() + 1;

[AtomicGu]

• [llvm-cov] Add navigation link to the title

[gulfem]

llvm/tools/llvm-cov/SourceCoverageView.cpp

81 ↗

(On Diff #529607)

Some llvm-cov tests like llvm-cov::branch-c-general.test are failing in the presubmit tests. The reason is that you are changing the default behavior and some tests rely on that behavior. As a transitioning step, I would suggest adding a new option like showDirectoryCoverage into https://github.com/llvm/llvm-project/blob/main/llvm/tools/llvm-cov/CoverageViewOptions.h#L30, and using the associated class based on that option like:

if (Opts.ShowDirectoryCoverage)
  return std::make_unique<CoveragePrinterHTMLDirectory>(Opts);
else
  return std::make_unique<CoveragePrinterHTML>(Opts);

llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp

364

Please remove the whitespace at the end of this line.

652

I would suggest using the words CurrentFiles, CurrentDirs and CurrentTotals.

678–680

This is another formatting change.

687

Make sure that else starts after this curly base as stated in LLVM Coding Standards.
https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements

750

Use a curly brace for the else part make it uniform.

758

Can you use a long name here? What does buildNavLink mean? Try to use a full name unless the abbreviation is clear.

[AtomicGu]

• [llvm-cov] Finish the new CoveragePrinterHTMLDirectory.
• [llvm-cov] The new CoveragePrinterHTMLDirectory passed manual test.
• [llvm-cov] Add navigation links to the title of the index file.
• [llvm-cov] Add additional command line options.
• [llvm-cov] Accept advices from Gulfem's review.

[AtomicGu]

Here is a preview coverage report for llvm-cov llvm-profdata lli and llc :

report.tar.gz153 MBDownload

[yurybura]

In D151283#4420869, @AtomicGu wrote:

Here is a preview coverage report for llvm-cov llvm-profdata lli and llc :

report.tar.gz153 MBDownload

Provided preview contains wrong relative path to style.css. For example, it should be href='../../../../../style.css' in file coverage/root/GSoC/llvm-project/llvm/index.html.

[AtomicGu]

• [llvm-cov] Fix links to CSS in index files.
• [llvm-cov] Improve the title of index files.

[AtomicGu]

Reverse formatting changes.

[AtomicGu]

In D151283#4421727, @yurybura wrote:

In D151283#4420869, @AtomicGu wrote:

Here is a preview coverage report for llvm-cov llvm-profdata lli and llc :

report.tar.gz153 MBDownload

Provided preview contains wrong relative path to style.css. For example, it should be href='../../../../../style.css' in file coverage/root/GSoC/llvm-project/llvm/index.html.

Thank you. This issue has been fixed. I was testing by python -m http.server remotely and not aware of this.

[AtomicGu]

• [llvm-cov] Update documents.

[AtomicGu]

• [llvm-cov] Fix a format issue of git-clang-format.

[AtomicGu]

@davidxl @phosek @gulfem
I removed the WIP tag. Please review this! 😀
The new tests will be added in the comming few days.

[phosek]

llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp

558–564

This code is duplicated between CoveragePrinterHTML::createIndexFile and CoveragePrinterHTMLDirectory::createIndexFile, could it be extracted into a helper function?

620–645

This code is duplicated between CoveragePrinterHTML::createIndexFile and CoveragePrinterHTMLDirectory::createSubIndexFile, could it be extracted into one or more helper functions?

713–734

This code is duplicated between CoveragePrinterHTML::createIndexFile and CoveragePrinterHTMLDirectory::createSubIndexFile, could it be extracted into one or more helper functions?

[AtomicGu]

llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp

558–564

This can be extracted to a helper method of CoveragePrinterHTML.

Personally, I tolerate code repetition for modification flexibility if it's not more than twrice. If it is not welcomed in LLVM community, I will fix it.

[AtomicGu]

llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp

713–734

These codes are tightly coupled with variables around them. It may needs more boilerplate code than the code extracted. I don't think it will make the code easier to read to extract them into a common helper function.

[AtomicGu]

This comment was removed by AtomicGu.

[AtomicGu]

• [llvm-cov] Extract some common code to 2 methods.

[AtomicGu]

• [llvm-cov] Add new tests for directory coverage.

[phosek]

llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp

349

This is a just a suggestion, but I think that emitPrelude might be a better name.

[AtomicGu]

llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp

349

This name has been used by another function in the anonymous namespace in SourceCoverageViewHTML.cpp. So I chose a different name to avoid confusion, although no conflict would be caused if I used emitPrelude since the arguments are different.

[phosek]

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

1 ↗

(On Diff #539023)

Your test cannot assume that clang is available on the host since Clang is not one of LLVM's prerequisites, and we want LLVM to remain compiler agnostic. That's why you're seeing the issue on Windows pre-merge builders: Clang happens to be available on these builders, but it doesn't include the profile runtime, which is perfectly valid because we don't require it.

What we do instead is to either include raw profile in the .proftext textual format and then convert it to .profdata using llvm-profdata or include .profdata directly, plus include coverage mapping information in the textual format as .covmapping, and then run llvm-covas part of the test. We also include instructions for recreating the .profdata and .covmapping files inside the test.

Here are some examples as an inspiration:

https://github.com/llvm/llvm-project/blob/96ae0851c26237378fa1280b0a9ad713e1b72bdb/llvm/test/tools/llvm-cov/coverage-prefix-map.test
https://github.com/llvm/llvm-project/blob/96ae0851c26237378fa1280b0a9ad713e1b72bdb/llvm/test/tools/llvm-cov/multiple-objects.test

llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp

349

I see, how about emitReportHeader?

633–634

LLVM's StringMap is more efficient than std::map<StringRef, ...>.

634

We prefer LLVM SmallVector unless there's a specific reason for using std::vector.

723–734

Can you add some comments to explain the logic in this block?

736

Use llvm::SmallString.

740–741

Use llvm::sys::path::append appending to a path.

763

Use llvm::SmallString here as well.

[gulfem]

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

llvm/docs/CommandGuide/llvm-cov.rst

256 ↗

(On Diff #538601)

How about we stop the description before the parenthesis? I think "impossible to read" is a strong statement.

[gulfem]

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

4 ↗

(On Diff #539023)

I would use b0 for this directory name to be consistent overall the test.

[AtomicGu]

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

1 ↗

(On Diff #539023)

I tried this today. llvm-cov convert-for-testing works well for single source file program. But when I used it for multiple source files, the generated .covmapping file is failed to be load by llvm-cov show:

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

The commands used is same with those in coverage-prefix-map.test:

cp %S/Inputs/directory_coverage -r . /tmp
cd /tmp/directory_coverage
clang -fprofile-instr-generate -mllvm -enable-name-compression=false \
  -fcoverage-mapping -fcoverage-prefix-map=$PWD=. -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
LLVM_PROFILE_FILE="main.raw" ./main
llvm-profdata merge main.raw -o main.profdata
llvm-cov convert-for-testing ./main -o main.covmapping
rm main main.raw

llvm-cov report -path-equivalence=.,/tmp/coverage_prefix_map \
  -instr-profile main.profdata main.covmapping

Is this a bug or a designed behavior? Can I just include the program file directly for now?

llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp

736

I believe that S is not small. It contains hyperlinks <a href="..."> </a> for each level. So I think it can easily exceed 64 chars or more in large projects.

Also it's the return value. I choose std::string for the return type because the original code uses that. For example, CoveragePrinterHTML::buildLinkToFile returns a std::string.

740–741

S is not a path. It's a html snippet like:

<a href="../../index.html">/root</a>/<a href="./index.html">c0/c1</a>/

Here I just need native separators to show between the <a> tags.

763

I use std::string here because the parameters of the function a(..., ...) is const std::string &. In fact, the two helper function tag and a all uses const std::string &. Do I need to refactor them?

[AtomicGu]

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.

[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

516

@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

516

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

516

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

516

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 ↗

(On Diff #552263)

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

llvm/tools/llvm-cov/CoverageReport.cpp

501

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

101

126

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

[AtomicGu]

llvm/tools/llvm-cov/CoverageReport.cpp

501

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

126

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 ↗

(On Diff #552590)

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 ↗

(On Diff #552590)

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

[AtomicGu]

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

llvm/tools/llvm-cov/CoverageReport.h

 //===- CoverageReport.h - Code coverage report ----------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
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,
+  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;
+
+  /// Determine the length of the longest redundant prefix of the paths in
+  /// \p Paths.
+  static unsigned getRedundantPrefixLen(ArrayRef<std::string> Paths);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_COV_COVERAGEREPORT_H

llvm/tools/llvm-cov/CoverageReport.cpp

 //===- CoverageReport.cpp - Code coverage report -------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
for (const auto &Component :
         break;
       }
     }
   }
 
   return NumRedundant;
 }
 
-/// Determine the length of the longest redundant prefix of the paths in
-/// \p Paths.
-unsigned getRedundantPrefixLen(ArrayRef<std::string> Paths) {
-  // If there's at most one path, no path components are redundant.
-  if (Paths.size() <= 1)
-    return 0;
-
-  unsigned PrefixLen = 0;
-  unsigned NumRedundant = getNumRedundantPathComponents(Paths);
-  auto Component = sys::path::begin(Paths[0]);
-  for (unsigned I = 0; I < NumRedundant; ++I) {
-    auto LastComponent = Component;
-    ++Component;
-    PrefixLen += Component - LastComponent;
-  }
-  return PrefixLen;
-}
-
 } // end anonymous namespace
 
 namespace llvm {
 
 void CoverageReport::render(const FileCoverageSummary &File,
                             raw_ostream &OS) const {
   auto FileCoverageColor =
       determineCoveragePercentageColor(File.RegionCoverage);
if (File.InstantiationCoverage.getNumFunctions())
                     File.InstantiationCoverage.getPercentCovered())
           << '%';
     else
       OS << column("-", FileReportColumns[9], Column::RightAlignment);
   }
 
   OS << format("%*u", FileReportColumns[10],
                (unsigned)File.LineCoverage.getNumLines());
-  Options.colored_ostream(OS, LineCoverageColor) << format(
-      "%*u", FileReportColumns[11], (unsigned)(File.LineCoverage.getNumLines() -
-                                               File.LineCoverage.getCovered()));
+  Options.colored_ostream(OS, LineCoverageColor)
+      << format("%*u", FileReportColumns[11],
+                (unsigned)(File.LineCoverage.getNumLines() -
   if (File.LineCoverage.getNumLines())
     Options.colored_ostream(OS, LineCoverageColor)
         << format("%*.2f", FileReportColumns[12] - 1,
                   File.LineCoverage.getPercentCovered())
         << '%';
   else
     OS << column("-", FileReportColumns[12], Column::RightAlignment);
 
if (Options.ShowBranchSummary) {
     else
       OS << column("-", FileReportColumns[15], Column::RightAlignment);
   }
 
   OS << "\n";
 }
 
 void CoverageReport::render(const FunctionCoverageSummary &Function,
-                            const DemangleCache &DC,
-                            raw_ostream &OS) const {
+                            const DemangleCache &DC, raw_ostream &OS) const {
   auto FuncCoverageColor =
       determineCoveragePercentageColor(Function.RegionCoverage);
   auto LineCoverageColor =
       determineCoveragePercentageColor(Function.LineCoverage);
   OS << column(DC.demangle(Function.Name), FunctionReportColumns[0],
                Column::RightTrim)
      << format("%*u", FunctionReportColumns[1],
                (unsigned)Function.RegionCoverage.getNumRegions());
for (StringRef Filename : Files) {
     if (Totals.ExecutionCount) {
       renderDivider(FunctionReportColumns, OS);
       OS << "\n";
       render(Totals, DC, OS);
     }
   }
 }
 
-void CoverageReport::prepareSingleFileReport(const StringRef Filename,
-    const coverage::CoverageMapping *Coverage,
+void CoverageReport::prepareSingleFileReport(
+    const StringRef Filename, const coverage::CoverageMapping *Coverage,
     const CoverageViewOptions &Options, const unsigned LCP,
     FileCoverageSummary *FileReport, const CoverageFilter *Filters) {
   for (const auto &Group : Coverage->getInstantiationGroups(Filename)) {
     std::vector<FunctionCoverageSummary> InstantiationSummaries;
     for (const coverage::FunctionRecord *F : Group.getInstantiations()) {
       if (!Filters->matches(*Coverage, *F))
         continue;
       auto InstantiationSummary = FunctionCoverageSummary::get(*Coverage, *F);
       FileReport->addInstantiation(InstantiationSummary);
       InstantiationSummaries.push_back(InstantiationSummary);
     }
     if (InstantiationSummaries.empty())
       continue;
 
     auto GroupSummary =
         FunctionCoverageSummary::get(Group, InstantiationSummaries);
 
     if (Options.Debug)
       outs() << "InstantiationGroup: " << GroupSummary.Name << " with "
              << "size = " << Group.size() << "\n";
 
     FileReport->addFunction(GroupSummary);
   }
-}
+} // ! It seems LCP is not used?
 
 std::vector<FileCoverageSummary> CoverageReport::prepareFileReports(
     const coverage::CoverageMapping &Coverage, FileCoverageSummary &Totals,
     ArrayRef<std::string> Files, const CoverageViewOptions &Options,
     const CoverageFilter &Filters) {
   unsigned LCP = getRedundantPrefixLen(Files);
 
   ThreadPoolStrategy S = hardware_concurrency(Options.NumThreads);
   if (Options.NumThreads == 0) {
     // If NumThreads is not specified, create one thread for each input, up to
     // the number of hardware cores.
     S = heavyweight_hardware_concurrency(Files.size());
     S.Limit = true;
   }
   ThreadPool Pool(S);
 
   std::vector<FileCoverageSummary> FileReports;
   FileReports.reserve(Files.size());
 
   for (StringRef Filename : Files) {
     FileReports.emplace_back(Filename.drop_front(LCP));
-    Pool.async(&CoverageReport::prepareSingleFileReport, Filename,
-               &Coverage, Options, LCP, &FileReports.back(), &Filters);
+    Pool.async(&CoverageReport::prepareSingleFileReport, Filename, &Coverage,
+               Options, LCP, &FileReports.back(), &Filters);
   }
   Pool.wait();
 
   for (const auto &FileReport : FileReports)
     Totals += FileReport;
 
   return FileReports;
 }
 
 void CoverageReport::renderFileReports(
     raw_ostream &OS, const CoverageFilters &IgnoreFilenameFilters) const {
   std::vector<std::string> UniqueSourceFiles;
   for (StringRef SF : Coverage.getUniqueSourceFiles()) {
     // Apply ignore source files filters.
     if (!IgnoreFilenameFilters.matchesFilename(SF))
       UniqueSourceFiles.emplace_back(SF.str());
   }
   renderFileReports(OS, UniqueSourceFiles);
 }
 
-void CoverageReport::renderFileReports(
-    raw_ostream &OS, ArrayRef<std::string> Files) const {
+void CoverageReport::renderFileReports(raw_ostream &OS,
+                                       ArrayRef<std::string> Files) const {
   renderFileReports(OS, Files, CoverageFiltersMatchAll());
 }
 
 void CoverageReport::renderFileReports(
     raw_ostream &OS, ArrayRef<std::string> Files,
     const CoverageFiltersMatchAll &Filters) const {
   FileCoverageSummary Totals("TOTAL");
   auto FileReports =
for (const FileCoverageSummary &FCS : FileReports)
         render(FCS, OS);
   }
 
   renderDivider(FileReportColumns, OS);
   OS << "\n";
   render(Totals, OS);
 }
 
+unsigned CoverageReport::getRedundantPrefixLen(ArrayRef<std::string> Paths) {
+  // If there's at most one path, no path components are redundant.
+  if (Paths.size() <= 1)
+    return 0;
+
+  unsigned PrefixLen = 0;
+  unsigned NumRedundant = getNumRedundantPathComponents(Paths);
+  auto Component = sys::path::begin(Paths[0]);
+  for (unsigned I = 0; I < NumRedundant; ++I) {
+    auto LastComponent = Component;
+    ++Component;
+    PrefixLen += Component - LastComponent;
+  }
+  return PrefixLen;
+}
+
 } // end namespace llvm

llvm/tools/llvm-cov/SourceCoverageView.h

 //===- SourceCoverageView.h - Code coverage view for source code ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
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/SourceCoverageViewHTML.h

 //===- SourceCoverageViewHTML.h - 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
 //
 //===----------------------------------------------------------------------===//
 ///
Error createIndexFile(ArrayRef<std::string> SourceFiles,
                         const coverage::CoverageMapping &Coverage,
                         const CoverageFiltersMatchAll &Filters) override;
 
   CoveragePrinterHTML(const CoverageViewOptions &Opts)
       : CoveragePrinter(Opts) {}
 
 private:
   void emitFileSummary(raw_ostream &OS, StringRef SF,
-                       const FileCoverageSummary &FCS,
-                       bool IsTotals = false) const;
-  std::string buildLinkToFile(StringRef SF,
-                              const FileCoverageSummary &FCS) const;
+                       const FileCoverageSummary &FCS, bool IsTotals = false,
+                       bool IsDir = false) const;
+
+  std::string buildLinkToFile(StringRef SF, const FileCoverageSummary &FCS,
+                              bool IsDir = false) const;
+
+  Error createHierarchicalIndexFile(StringRef LCP, // Longest Common Prefix
+                                    ArrayRef<std::string> SourceFiles,
+                                    const coverage::CoverageMapping &Coverage,
+                                    const CoverageFiltersMatchAll &Filters,
+                                    FileCoverageSummary &Totals) const;
 };
 
 /// 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;
 

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/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"
 #include <optional>
 
 using namespace llvm;
 
 namespace {
 

 // 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>";
 }
 
 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 {
static void emitColumnLabelsForIndex(raw_ostream &OS,
   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"));
   OS << tag("tr", join(Columns.begin(), Columns.end(), ""));
 }
 
-std::string
-CoveragePrinterHTML::buildLinkToFile(StringRef SF,
-                                     const FileCoverageSummary &FCS) const {
+std::string CoveragePrinterHTML::buildLinkToFile(StringRef SF,
+                                                 const FileCoverageSummary &FCS,
+                                                 bool IsDir) const {
   SmallString<128> LinkTextStr(sys::path::relative_path(FCS.Name));
   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);
+
+  if (IsDir)
+    LinkText.push_back('/');
+  auto OutputPath = getOutputPath(SF, "html", /*InToplevel=*/true, true);
+  std::string LinkTarget = escape(OutputPath, Opts);
+
   return a(LinkTarget, LinkText);
 }
 
 /// 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 {
+                                          bool IsTotals, bool IsDir) 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 if (IsDir) {
+    Filename = buildLinkToFile(std::string(SF) + "index", FCS, true);
   } else {
-    Filename = buildLinkToFile(SF, FCS);
+    Filename = a(FCS.Name.str() + ".html", FCS.Name.str());
   }
 
   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(),
Error CoveragePrinterHTML::createIndexFile(
   // Emit the default stylesheet.
   auto CSSOrErr = createOutputStream("style", "css", /*InToplevel=*/true);
   if (Error E = CSSOrErr.takeError())
     return E;
 
   OwnedStream CSS = std::move(CSSOrErr.get());
   CSS->operator<<(CSSForCoverage);
 
+  // Create hierarchical html files.
+  StringRef LCP(SourceFiles[0].c_str(),
+                CoverageReport::getRedundantPrefixLen(SourceFiles));
+  FileCoverageSummary Totals("TOTALS");
+  if (auto E = createHierarchicalIndexFile(LCP, SourceFiles, Coverage, Filters,
+                                           Totals))
+    return E;
+
+  // Generate top level index.html.
+  auto OSOrErr = createOutputStream("index", "html", true);
+  if (auto E = OSOrErr.takeError())
+    return E;
+  auto OS = std::move(OSOrErr.get());
+
+  auto TopIndexHtmlPath =
+      getOutputPath(std::string(LCP) + "index", "html", false, true);
+  *OS.get() << R"(<!DOCTYPE html>
+  <html>
+    <head>
+      <meta http-equiv="Refresh" content="0; url=')"
+            << TopIndexHtmlPath << R"('" />
+    </head>
+    <body></body>
+  </html>
+  )"; // Use redirection for top level index.html.
+
+  return Error::success();
+}
+
+Error CoveragePrinterHTML::createHierarchicalIndexFile(
+    StringRef LCP, ArrayRef<std::string> SourceFiles,
+    const coverage::CoverageMapping &Coverage,
+    const CoverageFiltersMatchAll &Filters, FileCoverageSummary &Totals) const {
   // Emit a file index along with some coverage statistics.
-  auto OSOrErr = createOutputStream("index", "html", /*InToplevel=*/true);
+  auto OSOrErr = createOutputStream(std::string(LCP) + "index", "html",
+                                    /*InToplevel=*/false);
   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(""));
+  auto IndexHtmlPath = getOutputPath(std::string(LCP) + "index", "html",
+                                     /*InToplevel=*/false, false);
+  emitPrelude(OSRef, Opts, getPathToStyle(IndexHtmlPath));
 
   // Emit some basic information about the coverage report.
   if (Opts.hasProjectTitle())
     OSRef << tag(ProjectTitleTag, escape(Opts.ProjectTitle, Opts));
-  OSRef << tag(ReportTitleTag, "Coverage Report");
+  OSRef << tag(ReportTitleTag, "Coverage Report (" + LCP.str() + ")");
   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.");
 
+  // Filter out files in current directory and group other files by there
+  // diretory.
+  // TODO Unnecessary string copying here!
+  std::vector<std::string> Files;
+  StringMap<std::vector<std::string>> Dirs;
+  for (auto &&SourceFile : SourceFiles) {
+    auto Path = SourceFile.substr(LCP.size());
+
+    auto It = sys::path::begin(Path), End = sys::path::end(Path);
+    assert(It != End);
+
+    auto Name = *It;
+    if (++It == End)
+      Files.push_back(SourceFile);
+    else
+      Dirs[Name].push_back(SourceFile);
+  }
+
   // 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);
+  auto FileReports = CoverageReport::prepareFileReports(Coverage, Totals, Files,
+                                                        Opts, Filters);
+
+  // Emit subdirectory first to make them at the top of the list.
+  for (auto &&Dir : Dirs) {
+    FileCoverageSummary DirTotals("TOTALS");
+    StringRef DirLCP(Dir.second[0].data(),
+                     CoverageReport::getRedundantPrefixLen(Dir.second));
+    if (DirLCP.size() == 0) {
+      Files.push_back(DirLCP.str());
+      continue; // In this case, only one file in that directory.
+      // TODO It's better-looking to list those files above all other files in
+      //      current directory.
+    }
+
+    if (auto E = createHierarchicalIndexFile(DirLCP, Dir.second, Coverage,
+                                             Filters, DirTotals))
+      return E;
+    DirTotals.Name = DirLCP.substr(LCP.size());
+    emitFileSummary(OSRef, DirTotals.Name, DirTotals, false, true);
+    Totals += DirTotals;
+  }
+
+  // Then emit the files in current directory.
   bool EmptyFiles = false;
   for (unsigned I = 0, E = FileReports.size(); I < E; ++I) {
     if (FileReports[I].FunctionCoverage.getNumFunctions())
-      emitFileSummary(OSRef, SourceFiles[I], FileReports[I]);
+      emitFileSummary(OSRef, Files[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

 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 = Snippets.size(); I < E; ++I)
     Snippets[I] = escape(Snippets[I], getOptions());
 
   // 3. Use \p WrappedSegment to set the highlight for snippet 0. Use segment
   //    1 to set the highlight for snippet 2, segment 2 to set the highlight for
   //    snippet 3, and so on.
 
   std::optional<StringRef> Color;
   SmallVector<std::pair<unsigned, unsigned>, 2> HighlightedRanges;
   auto Highlight = [&](const std::string &Snippet, unsigned LC, unsigned RC) {
     if (getOptions().Debug)
       HighlightedRanges.emplace_back(LC, RC);
     return tag("span", Snippet, std::string(*Color));
   };
 
   auto CheckIfUncovered = [&](const CoverageSegment *S) {
     return S && (!S->IsGapRegion || (Color && *Color == "red")) &&
            S->HasCount && S->Count == 0;
   };
 
   if (CheckIfUncovered(LCS.getWrappedSegment())) {
     Color = "red";
     if (!Snippets[0].empty())
       Snippets[0] = Highlight(Snippets[0], 1, 1 + Snippets[0].size());
   }
 
   for (unsigned I = 0, E = Segments.size(); I < E; ++I) {
     const auto *CurSeg = Segments[I];
     if (CheckIfUncovered(CurSeg))
       Color = "red";
     else if (CurSeg->Col == ExpansionCol)
       Color = "cyan";
     else
       Color = std::nullopt;
 
     if (Color)
       Snippets[I + 1] = Highlight(Snippets[I + 1], CurSeg->Col,
                                   CurSeg->Col + Snippets[I + 1].size());
   }
 
   if (Color && Segments.empty())
     Snippets.back() = Highlight(Snippets.back(), 1, 1 + Snippets.back().size());
 
   if (getOptions().Debug) {
     for (const auto &Range : HighlightedRanges) {
       errs() << "Highlighted line " << LineNo << ", " << Range.first << " -> ";
       if (Range.second == 0)
         errs() << "?";
       else
         errs() << Range.second;
if (shouldRenderRegionMarkers(LCS)) {
     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"),
+          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";
     }
   }
 
   OS << BeginCodeTD;
   OS << BeginPre;
   for (const auto &Snippet : Snippets)
     OS << Snippet;
   OS << EndPre;
 
   // If there are no sub-views left to attach to this cell, end the cell.
if (Line.isMapped())
     Count = tag("pre", formatCount(Line.getExecutionCount()));
   std::string CoverageClass =
       (Line.getExecutionCount() > 0) ? "covered-line" : "uncovered-line";
   OS << tag("td", Count, CoverageClass);
 }
 
 void SourceCoverageViewHTML::renderLineNumberColumn(raw_ostream &OS,
                                                     unsigned LineNo) {
   std::string LineNoStr = utostr(uint64_t(LineNo));
   std::string TargetName = "L" + LineNoStr;
   OS << tag("td", a("#" + TargetName, tag("pre", LineNoStr), TargetName),
             "line-number");
 }
 
 void SourceCoverageViewHTML::renderRegionMarkers(raw_ostream &,
                                                  const LineCoverageStats &Line,
                                                  unsigned) {
   // Region markers are rendered in-line using tooltips.
 }
 
 void SourceCoverageViewHTML::renderExpansionSite(raw_ostream &OS, LineRef L,
                                                  const LineCoverageStats &LCS,
                                                  unsigned ExpansionCol,
                                                  unsigned ViewDepth) {
   // Render the line containing the expansion site. No extra formatting needed.
   renderLine(OS, L, LCS, ExpansionCol, ViewDepth);
 }
 
 void SourceCoverageViewHTML::renderExpansionView(raw_ostream &OS,
                                                  ExpansionView &ESV,
                                                  unsigned ViewDepth) {
   OS << BeginExpansionDiv;
   ESV.View->print(OS, /*WholeFile=*/false, /*ShowSourceName=*/false,
                   /*ShowTitle=*/false, ViewDepth + 1);
   OS << EndExpansionDiv;
 }
 
 void SourceCoverageViewHTML::renderBranchView(raw_ostream &OS, BranchView &BRV,
                                               unsigned ViewDepth) {
   // Render the child subview.
   if (getOptions().Debug)
     errs() << "Branch at line " << BRV.getLine() << '\n';
 
   OS << BeginExpansionDiv;
   OS << BeginPre;
   for (const auto &R : BRV.Regions) {
     // Calculate TruePercent and False Percent.
     double TruePercent = 0.0;
     double FalsePercent = 0.0;
     unsigned Total = R.ExecutionCount + R.FalseExecutionCount;
 
     if (!getOptions().ShowBranchCounts && Total != 0) {
       TruePercent = ((double)(R.ExecutionCount) / (double)Total) * 100.0;
       FalsePercent = ((double)(R.FalseExecutionCount) / (double)Total) * 100.0;
     }
 
     // Display Line + Column.
     std::string LineNoStr = utostr(uint64_t(R.LineStart));
     std::string ColNoStr = utostr(uint64_t(R.ColumnStart));
     std::string TargetName = "L" + LineNoStr;
 
     OS << "  Branch (";
     OS << tag("span",
               a("#" + TargetName, tag("span", LineNoStr + ":" + ColNoStr),
                 TargetName),
               "line-number") +
               "): [";