[Profiler] Don't profile generated buffers

We may want to revisit this in the future, but for
now let's avoid profiling code in generated
buffers. To make this work we'll need to come up
with a scheme for writing out the generated buffers
such that tools like `llvm-cov` can reference them.

rdar://109562235

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/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()
+}