Merge pull request #66019 from hamishknight/cover-for-your-cover

Author: hamishknight

include/swift/Basic/SourceManager.h

@@ -191,6 +191,9 @@ class SourceManager {
   /// Set the generated source information associated with a given buffer.
   void setGeneratedSourceInfo(unsigned bufferID, GeneratedSourceInfo);
 
+  /// Checks whether the given buffer has generated source information.
+  bool hasGeneratedSourceInfo(unsigned bufferID);
+
   /// Retrieve the generated source information for the given buffer.
   Optional<GeneratedSourceInfo> getGeneratedSourceInfo(unsigned bufferID) const;
 

lib/Basic/SourceLoc.cpp

@@ -394,6 +394,10 @@ void SourceManager::setGeneratedSourceInfo(
   }
 }
 
+bool SourceManager::hasGeneratedSourceInfo(unsigned bufferID) {
+  return GeneratedSourceInfos.count(bufferID);
+}
+
 Optional<GeneratedSourceInfo> SourceManager::getGeneratedSourceInfo(
     unsigned bufferID
 ) const {

lib/IRGen/GenCoverage.cpp

@@ -27,16 +27,24 @@
 #include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Support/FileSystem.h"
 
-// This selects the coverage mapping format defined when `InstrProfData.inc`
-// is textually included.
-#define COVMAP_V3
-
 using namespace swift;
 using namespace irgen;
 
 using llvm::coverage::CounterMappingRegion;
 using llvm::coverage::CovMapVersion;
 
+// This affects the coverage mapping format defined when `InstrProfData.inc`
+// is textually included. Note that it means 'version >= 3', not 'version == 3'.
+#define COVMAP_V3
+
+/// This assert is here to make sure we make all the necessary code generation
+/// changes that are needed to support the new coverage mapping format. Note we
+/// cannot pin our version, as it must remain in sync with the version Clang is
+/// using.
+/// Do not bump without at least filing a bug and pinging a coverage maintainer.
+static_assert(CovMapVersion::CurrentVersion == CovMapVersion::Version6,
+              "Coverage mapping emission needs updating");
+
 static std::string getInstrProfSection(IRGenModule &IGM,
                                        llvm::InstrProfSectKind SK) {
   return llvm::getInstrProfSectionName(SK, IGM.Triple.getObjectFormat());
@@ -77,18 +85,26 @@ void IRGenModule::emitCoverageMaps(ArrayRef<const SILCoverageMap *> Mappings) {
   }
 
   std::vector<StringRef> Files;
-  for (const auto &M : Mappings)
+  for (const auto &M : Mappings) {
     if (std::find(Files.begin(), Files.end(), M->getFilename()) == Files.end())
       Files.push_back(M->getFilename());
-
-  auto remapper = getOptions().CoveragePrefixMap;
+  }
+  const auto &Remapper = getOptions().CoveragePrefixMap;
 
   llvm::SmallVector<std::string, 8> FilenameStrs;
-  for (StringRef Name : Files) {
-    llvm::SmallString<256> Path(Name);
-    llvm::sys::fs::make_absolute(Path);
-    FilenameStrs.push_back(remapper.remapPath(Path));
-  }
+  FilenameStrs.reserve(Files.size() + 1);
+
+  // First element needs to be the current working directory. Note if this
+  // scheme ever changes, the FileID computation below will need updating.
+  SmallString<256> WorkingDirectory;
+  llvm::sys::fs::current_path(WorkingDirectory);
+  FilenameStrs.emplace_back(Remapper.remapPath(WorkingDirectory));
+
+  // Following elements are the filenames present. We use their relative path,
+  // which llvm-cov will turn back into absolute paths using the working
+  // directory element.
+  for (auto Name : Files)
+    FilenameStrs.emplace_back(Remapper.remapPath(Name));
 
   // Encode the filenames.
   std::string Filenames;
@@ -112,13 +128,21 @@ void IRGenModule::emitCoverageMaps(ArrayRef<const SILCoverageMap *> Mappings) {
     const uint64_t NameHash = llvm::IndexedInstrProf::ComputeHash(NameValue);
     std::string FuncRecordName = "__covrec_" + llvm::utohexstr(NameHash);
 
-    unsigned FileID =
-        std::find(Files.begin(), Files.end(), M->getFilename()) - Files.begin();
+    // The file ID needs to be bumped by 1 to account for the working directory
+    // as the first element.
+    unsigned FileID = 1 +
+                      std::find(Files.begin(), Files.end(), M->getFilename()) -
+                      Files.begin();
+    assert(FileID < FilenameStrs.size());
+
     std::vector<CounterMappingRegion> Regions;
-    for (const auto &MR : M->getMappedRegions())
+    for (const auto &MR : M->getMappedRegions()) {
+      // The SubFileID here is 0, because it's an index into VirtualFileMapping,
+      // and we only ever have a single file associated for a function.
       Regions.emplace_back(CounterMappingRegion::makeRegion(
-          MR.Counter, /*FileID=*/0, MR.StartLine, MR.StartCol, MR.EndLine,
+          MR.Counter, /*SubFileID*/ 0, MR.StartLine, MR.StartCol, MR.EndLine,
           MR.EndCol));
+    }
     // Append each function's regions into the encoded buffer.
     ArrayRef<unsigned> VirtualFileMapping(FileID);
     llvm::coverage::CoverageMappingWriter W(VirtualFileMapping,

lib/SIL/IR/SILProfiler.cpp

@@ -86,18 +86,35 @@ static NodeToProfile getNodeToProfile(SILDeclRef Constant) {
 /// Check whether we should profile a given SILDeclRef.
 static bool shouldProfile(SILDeclRef Constant) {
   auto Root = getNodeToProfile(Constant);
+  auto *DC = Constant.getInnermostDeclContext();
 
-  // Do not profile AST nodes with invalid source locations.
   if (auto N = Root.getAsNode()) {
+    // Do not profile AST nodes with invalid source locations.
     if (N.getStartLoc().isInvalid() || N.getEndLoc().isInvalid()) {
       LLVM_DEBUG(llvm::dbgs()
                  << "Skipping ASTNode: invalid start/end locations\n");
       return false;
     }
+
+    // Do not profile generated code. This includes macro expansions, which we
+    // otherwise consider to be "written by the user", because they wrote the
+    // macro attribute or expr. We may want to revist this in the future. We'll
+    // need to figure out how we'll be writing out the macro expansions though,
+    // such that they can be referenced by llvm-cov.
+    // Note we check `getSourceFileContainingLocation` instead of
+    // `getParentSourceFile` to make sure initializer exprs are correctly
+    // handled.
+    auto *M = DC->getParentModule();
+    if (auto *SF = M->getSourceFileContainingLocation(N.getStartLoc())) {
+      auto &SM = M->getASTContext().SourceMgr;
+      if (SM.hasGeneratedSourceInfo(*SF->getBufferID())) {
+        LLVM_DEBUG(llvm::dbgs() << "Skipping ASTNode: generated code\n");
+        return false;
+      }
+    }
   }
 
   // Do not profile AST nodes in unavailable contexts.
-  auto *DC = Constant.getInnermostDeclContext();
   if (auto *D = DC->getInnermostDeclarationDeclContext()) {
     if (D->getSemanticUnavailableAttr()) {
       LLVM_DEBUG(llvm::dbgs() << "Skipping ASTNode: unavailable context\n");

test/Profiler/coverage_macros.swift

@@ -0,0 +1,49 @@
+// REQUIRES: swift_swift_parser
+
+// RUN: %empty-directory(%t)
+
+// RUN: %host-build-swift -swift-version 5 -emit-library -o %t/%target-library-name(MacroDefinition) -module-name=MacroDefinition %S/../Macros/Inputs/syntax_macro_definitions.swift -g -no-toolchain-stdlib-rpath
+
+// RUN: %target-swift-frontend -emit-sil -emit-sorted-sil -Xllvm -sil-full-demangle -profile-generate -profile-coverage-mapping -module-name coverage_macros %s -load-plugin-library %t/%target-library-name(MacroDefinition) | %FileCheck %s --implicit-check-not sil_coverage_map
+// RUN: %target-swift-frontend -emit-ir -profile-generate -profile-coverage-mapping -load-plugin-library %t/%target-library-name(MacroDefinition) %s
+
+@attached(accessor)
+macro accessViaStorage() = #externalMacro(module: "MacroDefinition", type: "AccessViaStorageMacro")
+
+@attached(
+  member,
+  names: named(`init`), named(Storage), named(storage), named(getStorage()), named(method)
+)
+macro addMembers() = #externalMacro(module: "MacroDefinition", type: "AddMembers")
+
+@freestanding(expression)
+macro nestedDeclInExpr() -> () -> Void = #externalMacro(module: "MacroDefinition", type: "NestedDeclInExprMacro")
+
+// Note we use implicit-check-not, so this test ensures we don't emit
+// coverage maps for the macro expansions.
+
+struct S1 {
+  // CHECK: sil_coverage_map{{.*}}variable initialization expression of coverage_macros.S1.x
+  var x: Int = 0
+
+  // CHECK: sil_coverage_map{{.*}}variable initialization expression of coverage_macros.S1.y
+  var y: Int = 0
+}
+
+@addMembers
+struct S2 {
+  // CHECK: sil_coverage_map{{.*}}variable initialization expression of coverage_macros.S2.(_storage
+  private var _storage = S1()
+
+  @accessViaStorage
+  var x: Int
+
+  // No coverage map for the initializer, as it gets subsumed.
+  @accessViaStorage
+  var y: Int = 17
+}
+
+// CHECK: sil_coverage_map{{.*}}s15coverage_macros3fooyyF
+func foo() {
+  _ = #nestedDeclInExpr()
+}

test/Profiler/coverage_relative_path.swift

@@ -1,15 +1,15 @@
 // To make sure this test is resilient to directory changes, we create nested directories inside of the
 // temporary test directory and assert those exist, or don't exist, in the emitted ir
 //
-// RUN: rm -rf %t
+// RUN: %empty-directory(%t)
 // RUN: mkdir -p %t/root/nested
 // RUN: echo "func coverage() {}" > %t/root/nested/coverage_relative_path.swift
 // RUN: cd %t/root
 
 // RUN: %target-swift-frontend -profile-generate -profile-coverage-mapping -Xllvm -enable-name-compression=false -emit-ir nested/coverage_relative_path.swift | %FileCheck -check-prefix=ABSOLUTE %s
 //
-// ABSOLUTE: @__llvm_coverage_mapping = {{.*"\\01.*root.*nested.*coverage_relative_path\.swift}}
+// ABSOLUTE: @__llvm_coverage_mapping = {{.*"\\02.*root[^/\\]*nested[/\\]*coverage_relative_path\.swift}}
 
 // RUN: %target-swift-frontend -profile-generate -profile-coverage-mapping -Xllvm -enable-name-compression=false -coverage-prefix-map %/t/root=. -emit-ir %/t/root/nested/coverage_relative_path.swift | %FileCheck -check-prefix=RELATIVE %s
 //
-// RELATIVE: @__llvm_coverage_mapping = {{.*"\\01[^/]*}}.{{/|\\}}nested{{.*coverage_relative_path\.swift}}
+// RELATIVE: @__llvm_coverage_mapping = {{.*"\\02.*\\01[^/]*\.[/\\]*nested[/\\]*coverage_relative_path\.swift}}

test/Profiler/coverage_relative_path_exec.swift

@@ -0,0 +1,25 @@
+// REQUIRES: profile_runtime
+// REQUIRES: executable_test
+// REQUIRES: OS=macosx
+
+// This test is to make sure llvm-cov can deal with a coverage-prefix-map.
+
+// To make sure this test is resilient to directory changes, we create nested directories inside of the
+// temporary test directory and assert those exist, or don't exist, in the emitted ir
+//
+// RUN: %empty-directory(%t)
+// RUN: mkdir -p %t/root/nested
+// RUN: echo "func coverage() {}" > %t/root/nested/coverage_relative_path.swift
+// RUN: cd %t/root
+
+// RUN: %target-build-swift -profile-generate -profile-coverage-mapping -Xfrontend -coverage-prefix-map -Xfrontend %/t/root=. -Xfrontend -disable-incremental-llvm-codegen -o %t/main %/t/root/nested/coverage_relative_path.swift
+
+// This unusual use of 'sh' allows the path of the profraw file to be
+// substituted by %target-run.
+// RUN: %target-codesign %t/main
+// RUN: %target-run sh -c 'env LLVM_PROFILE_FILE=$1 $2' -- %t/default.profraw %t/main
+
+// RUN: %llvm-profdata merge %t/default.profraw -o %t/default.profdata
+// RUN: %llvm-cov show %t/main -instr-profile=%t/default.profdata | %FileCheck %s
+
+// CHECK: func coverage