[llvm-cov] Allow multiple remaps in --path-equivalence

[tcamin]

Summary

Previously the --path-equivalence parameter would allow to specify a single remap pair (coverage data path - local source file path). This patch changes this allowing to pass as many remaps as needed.

[tcamin]

Add separate Windows tests

[tcamin]

Use same test for Linux and Windows

[tcamin]

Fix Windows paths

[tcamin]

Add empty path error message

[keith]

llvm/docs/CommandGuide/llvm-cov.rst

339

instead of passing multiple comma separated values here would it make more sense to pass -path-equivalence multiple times? it seems like that's the more common way to repeat flags (we might have talked about this in the past)

[tcamin]

Use multiple arguments instead of comma separated values

llvm/docs/CommandGuide/llvm-cov.rst

  Show code coverage only for functions with region coverage greater than the
  given threshold.
 
 .. option:: -region-coverage-lt=<N>
 
  Show code coverage only for functions with region coverage less than the given
  threshold.
 
 .. option:: -path-equivalence=<from>,<to>
 
  Map the paths in the coverage data to local source file paths. This allows you
  to generate the coverage data on one machine, and then use llvm-cov on a
- different machine where you have the same files on a different path.
+ different machine where you have the same files on a different path. Multiple
+ `-path-equivalence` arguments can be passed to specify different mappings. Each
+ argument consists of a source path `<from>` and its corresponding local path `<to>`.
+ The mappings are applied in the order they are specified. If multiple mappings can
+ be applied to a single path, the first mapping encountered is used.
 
 .. option:: -coverage-watermark=<high>,<low>
 
  Set high and low watermarks for coverage in html format output. This allows you
  to set the high and low watermark of coverage as desired, green when
  coverage >= high, red when coverage < low, and yellow otherwise. Both high and
  low should be between 0-100 and high > low.
 

llvm/test/tools/llvm-cov/Inputs/multiple-path_equivalence.proftext

+f1
+0x0
+1
+1
+
+f2
+0x0
+1
+1
+
+f3
+0x0
+1
+1
+
+f4
+0x0
+1
+1

llvm/test/tools/llvm-cov/multiple-path_equivalence.test

+# multiple-path_equivalence.covmapping contains references to 4 files:
+# /tmp/coverage/main.c
+# /tmp/coverage/f1.c
+# /tmp/coverage/a/f2.c
+# /tmp/coverage/b/f3.c
+# /tmp/coverage/b/c/f4.c
+
+# Setup
+// RUN: touch %/T/main.c; touch %/T/f1.c; touch %/T/f2.c; touch %/T/f3.c; touch %/T/f4.c
+// RUN: llvm-profdata merge %S/Inputs/multiple-path_equivalence.proftext -o %t.profdata
+
+# Make sure that remapping follows the specified order with the first matching entry being used first (f4 comes before f3)
+// RUN: llvm-cov show %S/Inputs/multiple-path_equivalence.covmapping -instr-profile=%t.profdata -path-equivalence=/tmp/coverage/a,%/T -path-equivalence=/tmp/coverage/b/c,%/T -path-equivalence=/tmp/coverage/b,%/T -path-equivalence=/tmp/coverage,%/T 2>&1 | FileCheck %s
+
+// CHECK-DAG: {{/|\\}}tmp{{/|\\}}coverage{{/|\\}}main.c:
+// CHECK-DAG: {{/|\\}}tmp{{/|\\}}coverage{{/|\\}}f1.c:
+// CHECK-DAG: {{/|\\}}tmp{{/|\\}}coverage{{/|\\}}a{{/|\\}}f2.c:
+// CHECK-DAG: {{/|\\}}tmp{{/|\\}}coverage{{/|\\}}b{{/|\\}}f3.c:
+// CHECK-DAG: {{/|\\}}tmp{{/|\\}}coverage{{/|\\}}b{{/|\\}}c{{/|\\}}f4.c:
+// CHECK-NOT: isn't covered.
+
+# Make sure remapping follows the specified order by proving paths in an overriding order (f4 comes after f3)
+// RUN: llvm-cov show %S/Inputs/multiple-path_equivalence.covmapping -instr-profile=%t.profdata -path-equivalence=/tmp/coverage/a,%/T -path-equivalence=/tmp/coverage/b,%/T -path-equivalence=/tmp/coverage/b/c,%/T -path-equivalence=/tmp/coverage,%/T 2>&1 | FileCheck %s -check-prefix=OVERRIDING_ORDER
+
+// OVERRIDING_ORDER-DAG: {{/|\\}}tmp{{/|\\}}coverage{{/|\\}}main.c:
+// OVERRIDING_ORDER-DAG: {{/|\\}}tmp{{/|\\}}coverage{{/|\\}}f1.c:
+// OVERRIDING_ORDER-DAG: {{/|\\}}tmp{{/|\\}}coverage{{/|\\}}a{{/|\\}}f2.c:
+// OVERRIDING_ORDER-DAG: {{/|\\}}tmp{{/|\\}}coverage{{/|\\}}b{{/|\\}}f3.c:
+// OVERRIDING_ORDER-DAG: warning: The file '{{/|\\}}tmp{{/|\\}}coverage{{/|\\}}b{{/|\\}}c{{/|\\}}f4.c' isn't covered.
+
+// RUN: not llvm-cov show %S/Inputs/multiple-path_equivalence.covmapping -instr-profile=%t.profdata -path-equivalence=/tmp/coverage/a,%/T -path-equivalence=/tmp/coverage/b, -path-equivalence=/tmp/coverage/b/c,%/T -path-equivalence=/tmp/coverage,%/T 2>&1 | FileCheck %s -check-prefix=EMPTY_PATH
+// EMPTY_PATH: must be in format 'from,to'
 No newline at end of file

llvm/test/tools/llvm-cov/path_equivalence.c

 // RUN: llvm-profdata merge %S/Inputs/path_equivalence.proftext -o %t.profdata
 // RUN: llvm-cov show %S/Inputs/path_equivalence.covmapping -instr-profile=%t.profdata -path-equivalence=/tmp,%S | FileCheck %s
 // RUN: llvm-cov show %S/Inputs/path_equivalence.covmapping -instr-profile=%t.profdata -path-equivalence=/tmp/,%S/ | FileCheck %s
 int main() {} // CHECK: [[@LINE]]|      1|int main() {}
 
 // RUN: not llvm-cov show --instr-profile=/dev/null -path-equivalence=foo /dev/null 2>&1 | FileCheck --check-prefix=INVALID %s
 // INVALID: error: -path-equivalence: invalid argument 'foo', must be in format 'from,to'
+
+// RUN: not llvm-cov show --instr-profile=/dev/null -path-equivalence=,foo /dev/null 2>&1 | FileCheck --check-prefix=EMPTY_PATH %s
+// EMPTY_PATH: error: -path-equivalence: invalid argument ',foo', must be in format 'from,to'

llvm/tools/llvm-cov/CodeCoverage.cpp

private:
   std::vector<std::string> SourceFiles;
 
   /// In -path-equivalence mode, this maps the absolute paths from the coverage
   /// mapping data to the input source files.
   StringMap<std::string> RemappedFilenames;
 
   /// The coverage data path to be remapped from, and the source path to be
   /// remapped to, when using -path-equivalence.
-  std::optional<std::pair<std::string, std::string>> PathRemapping;
+  std::optional<std::vector<std::pair<std::string, std::string>>>
+      PathRemappings;
 
   /// File status cache used when finding the same file.
   StringMap<std::optional<sys::fs::file_status>> FileStatusCache;
 
   /// The architecture the coverage mapping data targets.
   std::vector<StringRef> CoverageArches;
 
   /// A cache for demangled symbols.
if (!IgnoreFilenameFilters.matchesFilename(EffectivePath))
     SourceFiles.emplace_back(EffectivePath.str());
   HadSourceFiles = !SourceFiles.empty();
 }
 
 void CodeCoverageTool::collectPaths(const std::string &Path) {
   llvm::sys::fs::file_status Status;
   llvm::sys::fs::status(Path, Status);
   if (!llvm::sys::fs::exists(Status)) {
-    if (PathRemapping)
+    if (PathRemappings)
       addCollectedPath(Path);
     else
       warning("Source file doesn't exist, proceeded by ignoring it.", Path);
     return;
   }
 
   if (llvm::sys::fs::is_regular_file(Status)) {
     addCollectedPath(Path);
if (!SourceFiles.empty())
     removeUnmappedInputs(*Coverage);
 
   demangleSymbols(*Coverage);
 
   return Coverage;
 }
 
 void CodeCoverageTool::remapPathNames(const CoverageMapping &Coverage) {
-  if (!PathRemapping)
+  if (!PathRemappings)
     return;
 
   // Convert remapping paths to native paths with trailing seperators.
   auto nativeWithTrailing = [](StringRef Path) -> std::string {
     if (Path.empty())
       return "";
     SmallString<128> NativePath;
     sys::path::native(Path, NativePath);
     sys::path::remove_dots(NativePath, true);
     if (!NativePath.empty() && !sys::path::is_separator(NativePath.back()))
       NativePath += sys::path::get_separator();
     return NativePath.c_str();
   };
-  std::string RemapFrom = nativeWithTrailing(PathRemapping->first);
-  std::string RemapTo = nativeWithTrailing(PathRemapping->second);
+
+  for (std::pair<std::string, std::string> &PathRemapping : *PathRemappings) {
+    std::string RemapFrom = nativeWithTrailing(PathRemapping.first);
+    std::string RemapTo = nativeWithTrailing(PathRemapping.second);
 
     // Create a mapping from coverage data file paths to local paths.
     for (StringRef Filename : Coverage.getUniqueSourceFiles()) {
+      if (RemappedFilenames.count(Filename) == 1)
+        continue;
+
       SmallString<128> NativeFilename;
       sys::path::native(Filename, NativeFilename);
       sys::path::remove_dots(NativeFilename, true);
       if (NativeFilename.startswith(RemapFrom)) {
         RemappedFilenames[Filename] =
             RemapTo + NativeFilename.substr(RemapFrom.size()).str();
       }
     }
+  }
 
   // Convert input files from local paths to coverage data file paths.
   StringMap<std::string> InvRemappedFilenames;
   for (const auto &RemappedFilename : RemappedFilenames)
     InvRemappedFilenames[RemappedFilename.getValue()] =
         std::string(RemappedFilename.getKey());
 
   for (std::string &Filename : SourceFiles) {
cl::opt<CoverageViewOptions::OutputFormat> Format(
       cl::values(clEnumValN(CoverageViewOptions::OutputFormat::Text, "text",
                             "Text output"),
                  clEnumValN(CoverageViewOptions::OutputFormat::HTML, "html",
                             "HTML output"),
                  clEnumValN(CoverageViewOptions::OutputFormat::Lcov, "lcov",
                             "lcov tracefile output")),
       cl::init(CoverageViewOptions::OutputFormat::Text));
 
-  cl::opt<std::string> PathRemap(
+  cl::list<std::string> PathRemaps(
       "path-equivalence", cl::Optional,
       cl::desc("<from>,<to> Map coverage data paths to local source file "
                "paths"));
 
   cl::OptionCategory FilteringCategory("Function filtering options");
 
   cl::list<std::string> NameFilters(
       "name", cl::Optional,
case CoverageViewOptions::OutputFormat::HTML:
       break;
     case CoverageViewOptions::OutputFormat::Lcov:
       if (UseColor == cl::BOU_TRUE)
         errs() << "Color output cannot be enabled when generating lcov.\n";
       ViewOpts.Colors = false;
       break;
     }
 
-    // If path-equivalence was given and is a comma seperated pair then set
-    // PathRemapping.
-    if (!PathRemap.empty()) {
+    if (!PathRemaps.empty()) {
+      std::vector<std::pair<std::string, std::string>> Remappings;
+
+      for (const std::string &PathRemap : PathRemaps) {
         auto EquivPair = StringRef(PathRemap).split(',');
         if (EquivPair.first.empty() || EquivPair.second.empty()) {
           error("invalid argument '" + PathRemap +
                     "', must be in format 'from,to'",
                 "-path-equivalence");
           return 1;
         }
 
-      PathRemapping = {std::string(EquivPair.first),
-                       std::string(EquivPair.second)};
+        Remappings.push_back(
+            {std::string(EquivPair.first), std::string(EquivPair.second)});
+      }
+
+      PathRemappings = Remappings;
     }
 
     // If a demangler is supplied, check if it exists and register it.
     if (!DemanglerOpts.empty()) {
       auto DemanglerPathOrErr = sys::findProgramByName(DemanglerOpts[0]);
       if (!DemanglerPathOrErr) {
         error("Could not find the demangler!",
               DemanglerPathOrErr.getError().message());