Merge pull request #15773 from vedantk/cov-decls

swift-ci · web-flow · commit 5e74cdabd72a · 2018-04-05T18:42:40.000-07:00
diff --git a/include/swift/SIL/SILFunction.h b/include/swift/SIL/SILFunction.h
@@ -266,9 +266,9 @@ class SILFunction
     Profiler = InheritedProfiler;
   }
 
-  void createProfiler(ASTNode Root) {
+  void createProfiler(ASTNode Root, ForDefinition_t forDefinition) {
     assert(!Profiler && "Function already has a profiler");
-    Profiler = SILProfiler::create(Module, Root);
+    Profiler = SILProfiler::create(Module, forDefinition, Root);
   }
 
   void discardProfiler() { Profiler = nullptr; }
diff --git a/include/swift/SIL/SILProfiler.h b/include/swift/SIL/SILProfiler.h
@@ -22,12 +22,14 @@
 #include "swift/AST/Stmt.h"
 #include "swift/Basic/ProfileCounter.h"
 #include "swift/SIL/SILAllocated.h"
+#include "swift/SIL/SILDeclRef.h"
 #include "llvm/ADT/DenseMap.h"
 
 namespace swift {
 
 class AbstractFunctionDecl;
 class SILCoverageMap;
+class SILFunction;
 class SILModule;
 
 /// SILProfiler - Maps AST nodes to profile counters.
@@ -61,7 +63,8 @@ class SILProfiler : public SILAllocated<SILProfiler> {
       : M(M), Root(Root), EmitCoverageMapping(EmitCoverageMapping) {}
 
 public:
-  static SILProfiler *create(SILModule &M, ASTNode N);
+  static SILProfiler *create(SILModule &M, ForDefinition_t forDefinition,
+                             ASTNode N);
 
   /// Check if the function is set up for profiling.
   bool hasRegionCounters() const { return NumRegionCounters != 0; }
diff --git a/lib/SIL/SILProfiler.cpp b/lib/SIL/SILProfiler.cpp
@@ -100,7 +100,22 @@ static void walkForProfiling(ASTNode N, ASTWalker &Walker) {
   }
 }
 
-SILProfiler *SILProfiler::create(SILModule &M, ASTNode N) {
+/// Check that the input AST has at least been type-checked.
+static bool hasASTBeenTypeChecked(ASTNode N) {
+  DeclContext *DC = N.getAsDeclContext();
+  assert(DC && "Invalid AST node for profiling");
+  SourceFile *SF = DC->getParentSourceFile();
+  return !SF || SF->ASTStage >= SourceFile::TypeChecked;
+}
+
+SILProfiler *SILProfiler::create(SILModule &M, ForDefinition_t forDefinition,
+                                 ASTNode N) {
+  // Avoid generating profiling state for declarations.
+  if (!forDefinition)
+    return nullptr;
+
+  assert(hasASTBeenTypeChecked(N) && "Cannot use this AST for code coverage");
+
   if (auto *D = N.dyn_cast<Decl *>()) {
     assert(isa<AbstractFunctionDecl>(D) ||
            isa<TopLevelCodeDecl>(D) && "Cannot create profiler");
@@ -465,21 +480,21 @@ struct PGOMapping : public ASTWalker {
       CounterMap[thenExpr] = NextCounter++;
       auto thenCount = loadExecutionCount(thenExpr);
       LoadedCounterMap[thenExpr] = thenCount;
-      if (auto elseExpr = IE->getElseExpr()) {
-        CounterMap[elseExpr] = parent;
-        auto count = loadExecutionCount(elseExpr);
-        if (!parent) {
-          auto thenVal = thenCount.getValue();
-          for (auto pCount = NextCounter - 1; pCount > 0; --pCount) {
-            auto cCount = LoadedCounts->Counts[pCount];
-            if (cCount > thenVal) {
-              count = cCount;
-              break;
-            }
+      auto elseExpr = IE->getElseExpr();
+      assert(elseExpr && "An if-expr must have an else subexpression");
+      CounterMap[elseExpr] = parent;
+      auto count = loadExecutionCount(elseExpr);
+      if (!parent) {
+        auto thenVal = thenCount.getValue();
+        for (auto pCount = NextCounter - 1; pCount > 0; --pCount) {
+          auto cCount = LoadedCounts->Counts[pCount];
+          if (cCount > thenVal) {
+            count = cCount;
+            break;
           }
         }
-        LoadedCounterMap[elseExpr] = subtract(count, thenCount);
       }
+      LoadedCounterMap[elseExpr] = subtract(count, thenCount);
     } else if (isa<AutoClosureExpr>(E) || isa<ClosureExpr>(E)) {
       CounterMap[E] = NextCounter++;
       auto eCount = loadExecutionCount(E);
diff --git a/lib/SILGen/SILGen.cpp b/lib/SILGen/SILGen.cpp
@@ -500,7 +500,7 @@ SILFunction *SILGenModule::getFunction(SILDeclRef constant,
     if (auto *fd = constant.getFuncDecl()) {
       if (hasSILBody(fd)) {
         // Set up the function for profiling instrumentation.
-        F->createProfiler(fd);
+        F->createProfiler(fd, forDefinition);
         profiledNode = fd->getBody(/*canSynthesize=*/false);
       }
     }
@@ -519,7 +519,7 @@ SILFunction *SILGenModule::getFunction(SILDeclRef constant,
 
     if (!profiledNode) {
       if (auto *ce = dyn_cast<ClosureExpr>(ace)) {
-        F->createProfiler(ce);
+        F->createProfiler(ce, forDefinition);
         profiledNode = ce;
       }
     }
@@ -747,19 +747,23 @@ void SILGenModule::emitConstructor(ConstructorDecl *decl) {
 
   SILDeclRef constant(decl);
 
-  bool ForCoverageMapping = M.getOptions().EmitProfileCoverageMapping;
+  ForDefinition_t ForCoverageMapping = M.getOptions().EmitProfileCoverageMapping
+                                           ? ForDefinition
+                                           : NotForDefinition;
 
   if (decl->getDeclContext()->getAsClassOrClassExtensionContext()) {
     // Class constructors have separate entry points for allocation and
     // initialization.
-    emitOrDelayFunction(*this, constant, [this,constant,decl](SILFunction *f){
-      preEmitFunction(constant, decl, f, decl);
-      PrettyStackTraceSILFunction X("silgen emitConstructor", f);
-      f->createProfiler(decl);
-      SILGenFunction(*this, *f)
-        .emitClassConstructorAllocator(decl);
-      postEmitFunction(constant, f);
-    }, /*forceEmission=*/ForCoverageMapping);
+    emitOrDelayFunction(
+        *this, constant,
+        [this, constant, decl, ForCoverageMapping](SILFunction *f) {
+          preEmitFunction(constant, decl, f, decl);
+          PrettyStackTraceSILFunction X("silgen emitConstructor", f);
+          f->createProfiler(decl, ForCoverageMapping);
+          SILGenFunction(*this, *f).emitClassConstructorAllocator(decl);
+          postEmitFunction(constant, f);
+        },
+        /*forceEmission=*/ForCoverageMapping);
 
     // If this constructor was imported, we don't need the initializing
     // constructor to be emitted.
@@ -775,13 +779,16 @@ void SILGenModule::emitConstructor(ConstructorDecl *decl) {
     }
   } else {
     // Struct and enum constructors do everything in a single function.
-    emitOrDelayFunction(*this, constant, [this,constant,decl](SILFunction *f) {
-      preEmitFunction(constant, decl, f, decl);
-      PrettyStackTraceSILFunction X("silgen emitConstructor", f);
-      f->createProfiler(decl);
-      SILGenFunction(*this, *f).emitValueConstructor(decl);
-      postEmitFunction(constant, f);
-    }, /*forceEmission=*/ForCoverageMapping);
+    emitOrDelayFunction(
+        *this, constant,
+        [this, constant, decl, ForCoverageMapping](SILFunction *f) {
+          preEmitFunction(constant, decl, f, decl);
+          PrettyStackTraceSILFunction X("silgen emitConstructor", f);
+          f->createProfiler(decl, ForCoverageMapping);
+          SILGenFunction(*this, *f).emitValueConstructor(decl);
+          postEmitFunction(constant, f);
+        },
+        /*forceEmission=*/ForCoverageMapping);
   }
 }
 
@@ -865,7 +872,7 @@ void SILGenModule::emitObjCAllocatorDestructor(ClassDecl *cd,
     SILFunction *f = getFunction(dealloc, ForDefinition);
     preEmitFunction(dealloc, dd, f, dd);
     PrettyStackTraceSILFunction X("silgen emitDestructor -dealloc", f);
-    f->createProfiler(dd);
+    f->createProfiler(dd, ForDefinition);
     SILGenFunction(*this, *f).emitObjCDestructor(dealloc);
     postEmitFunction(dealloc, f);
   }
@@ -935,7 +942,7 @@ void SILGenModule::emitDestructor(ClassDecl *cd, DestructorDecl *dd) {
     SILFunction *f = getFunction(deallocator, ForDefinition);
     preEmitFunction(deallocator, dd, f, dd);
     PrettyStackTraceSILFunction X("silgen emitDeallocatingDestructor", f);
-    f->createProfiler(dd);
+    f->createProfiler(dd, ForDefinition);
     SILGenFunction(*this, *f).emitDeallocatingDestructor(dd);
     f->setDebugScope(new (M) SILDebugScope(dd, f));
     postEmitFunction(deallocator, f);
@@ -1303,7 +1310,7 @@ void SILGenModule::visitTopLevelCodeDecl(TopLevelCodeDecl *td) {
   // A single SILFunction may be used to lower multiple top-level decls. When
   // this happens, fresh profile counters must be assigned to the new decl.
   TopLevelSGF->F.discardProfiler();
-  TopLevelSGF->F.createProfiler(td);
+  TopLevelSGF->F.createProfiler(td, ForDefinition);
 
   TopLevelSGF->emitProfilerIncrement(td->getBody());
  
diff --git a/test/SILGen/Inputs/coverage_imports.swift b/test/SILGen/Inputs/coverage_imports.swift
@@ -0,0 +1,7 @@
+public struct Box {
+  public lazy var x: Int = {
+    return true ? 0 : 1
+  }()
+
+  public init() {}
+}
diff --git a/test/SILGen/coverage_decls.swift b/test/SILGen/coverage_decls.swift
@@ -0,0 +1,9 @@
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -profile-generate -profile-coverage-mapping -emit-sorted-sil -emit-sil -module-name coverage_decls -primary-file %s %S/Inputs/coverage_imports.swift | %FileCheck %s
+
+// CHECK: sil_coverage_map {{.*}} $S14coverage_decls4mainyyF
+// CHECK-NOT: sil_coverage_map
+
+func main() {
+  var b = Box()
+  let _ = b.x
+}

Original file line number	Diff line number	Diff line change
`@@ -266,9 +266,9 @@ class SILFunction`
`266`	`266`	`Profiler = InheritedProfiler;`
`267`	`267`	`}`
`268`	`268`
`269`		`- void createProfiler(ASTNode Root) {`
	`269`	`+ void createProfiler(ASTNode Root, ForDefinition_t forDefinition) {`
`270`	`270`	`assert(!Profiler && "Function already has a profiler");`
`271`		`- Profiler = SILProfiler::create(Module, Root);`
	`271`	`+ Profiler = SILProfiler::create(Module, forDefinition, Root);`
`272`	`272`	`}`
`273`	`273`
`274`	`274`	`void discardProfiler() { Profiler = nullptr; }`